def convert_pixel_to_coord(position):
"""docstring for convert_pixel_to_coord"""
hexa = Hexagon((0, 0), SIZE, RED, BORDER)
x_coord = (position[0] - MARGIN) / (hexa.get_radius() * 1.5)
y_coord = (position[1] - MARGIN + x_coord + hexa.get_apothem()) / \
(hexa.get_radius() * 2)
return (x_coord, y_coord)
def convert_coord_to_pixel(coord):
"""docstring for convert_coord_to_pixel"""
hexa = Hexagon((0, 0), SIZE, RED, BORDER)
y_pos = MARGIN + coord[1] * hexa.get_apothem() * 2 - coord[0] * \
hexa.get_apothem()
x_pos = MARGIN + coord[0] * hexa.get_radius() * 1.5
return (x_pos, y_pos)
def get_clicked_hex(self, x, y):
for hex in Hexagon.get_all_hexagons():
if hex.is_pathable():
hex.clear_select_color()
x = int(x)
y = int(y)
c_hex_obj = controller_lib.Controller_get_clicked_hex(c_int(x), c_int(y))
return Hexagon.get_hexagon(c_hex_obj)
def get_clicked_hex(self, x, y):
for hex in Hexagon.get_all_hexagons():
if hex.is_pathable():
hex.clear_select_color()
x = int(x)
y = int(y)
c_hex_obj = controller_lib.Controller_get_clicked_hex(
c_int(x), c_int(y))
return Hexagon.get_hexagon(c_hex_obj)
def generate_court(size=50,
col_rows=10,
col_cols=17,
start_posx=0,
start_posy=0):
hexes = Group()
id, x = 0, 0
posy = start_posy
posx = start_posx
for j in range(col_cols):
posx += size // 1.45
y = 0
for i in range(col_rows):
posy += size // 1.24
hexes.add(
Hexagon(posx=posx,
posy=posy,
id_and_pos=(id, x, y),
width=size,
height=size))
x += 2
y += 1
id += 1
if posy == size // 1.24 * col_rows + start_posy:
posy = size // 2.4 + start_posy
x = 1
elif posy == size // 1.24 * col_rows + size // 2.4 + start_posy:
posy = start_posy
x = 0
return hexes
class TestHexagon(unittest.TestCase):
def setUp(self):
self.hexagon = Hexagon(10, 11, 12, 13, 14, 15)
# Return sum of perimeter
def test_calculate_perimeter(self):
self.assertEqual(75, self.hexagon.calculate_perimeter())
def set_destination(self, dest_hex):
from hexagon import Hexagon
start_hex = self.get_base_hex()
# self.curr_path = a_star(start_hex, dest_hex)
self.curr_path = Hexagon.find_path(start_hex, dest_hex)
def set_destination(self, dest_hex):
from hexagon import Hexagon
start_hex = self.get_base_hex()
# self.curr_path = a_star(start_hex, dest_hex)
self.curr_path = Hexagon.find_path(start_hex, dest_hex)
class TestHexagon(unittest.TestCase):
"""
Test Hexagon class
"""
def setUp(self):
"""intialize the environment for all tests"""
self.hexagon = Hexagon((0, 0), 50, sf.Color(127, 127, 127),
sf.Color(127, 127, 127))
def test_radius(self):
"""test the radius value of hexagon"""
radius = self.hexagon.get_radius()
self.assertEqual(radius, 50)
def test_apothem(self):
"""test the apothem value of hexagon"""
apothem = self.hexagon.get_apothem()
self.assertAlmostEqual(apothem, 43.301270189)
def make_hexagon(self, x, y, radius, phase=math.pi / 2):
"""Create an hexagon given its position in pixels and its radius."""
points = []
for a in range(6):
points.append(
(
int(x + radius * math.cos(a * 60 * math.pi / 180 + phase)),
int(y + radius * math.sin(a * 60 * math.pi / 180 + phase)),
)
)
return Hexagon(points)
def gen_grid(self):
grid = []
for x in range(-self.rad, self.rad + 1):
for y in range(-self.rad, self.rad + 1):
for z in range(-self.rad, self.rad + 1):
if (x + y + z == 0):
hexagon = Hexagon(self.myCanvas,
x,
y,
z,
size=self.size,
rot=self.rot)
grid.append(hexagon)
print("foo")
return (grid)
def link_segments(self):
for i in range(GlobalConsts.BOARD_WIDTH):
offset = self.get_neighbor_offset(i)
for j in range(GlobalConsts.BOARD_HEIGHT):
neighbor_dict = {}
curr_hex = self.get_hexagon(i, j)
for pos, (i_offset, j_offset) in offset.iteritems():
new_seg_i = i + i_offset
new_seg_j = j + j_offset
neighbor_hex = self.get_hexagon(new_seg_i, new_seg_j)
assert neighbor_hex not in neighbor_dict.values()
neighbor_dict[pos] = neighbor_hex
curr_hex.set_neighbors(neighbor_dict)
for curr_hex in Hexagon.get_all_hexagons():
curr_hex.link_verticies()
def link_segments(self):
for i in range(GlobalConsts.BOARD_WIDTH):
offset = self.get_neighbor_offset(i)
for j in range(GlobalConsts.BOARD_HEIGHT):
neighbor_dict = {}
curr_hex = self.get_hexagon(i, j)
for pos, (i_offset, j_offset) in offset.iteritems():
new_seg_i = i + i_offset
new_seg_j = j + j_offset
neighbor_hex = self.get_hexagon(new_seg_i, new_seg_j)
assert neighbor_hex not in neighbor_dict.values()
neighbor_dict[pos] = neighbor_hex
curr_hex.set_neighbors(neighbor_dict)
for curr_hex in Hexagon.get_all_hexagons():
curr_hex.link_verticies()
def generate(start_seg, stop_seg):#, distance, height_range=(0, 2)):
from hexagon import Hexagon
# for curr_seg in a_star(start_seg, stop_seg):
for curr_seg in Hexagon.find_path(start_seg, stop_seg):
curr_seg.set_improvement('road', True)
class HexagonTest(unittest.TestCase):
def setUp(self):
path = tempfile.mktemp('.ldb')
db = leveldb.LevelDB(path)
self.triangle = Hexagon(db)
def test_it_exists(self):
self.assertTrue(self.triangle)
def test_insertion(self):
wb = mock.Mock()
self.triangle.db = mock.Mock()
with mock.patch('hexagon.core.leveldb.WriteBatch', return_value=wb):
self.triangle.insert(s='Daniel', p='loves', o='Cheese')
self.assertEqual(
sorted(i[0][0] for i in wb.Put.call_args_list),
sorted([
'spo::Daniel::loves::Cheese', 'sop::Daniel::Cheese::loves',
'pso::loves::Daniel::Cheese', 'pos::loves::Cheese::Daniel',
'osp::Cheese::Daniel::loves', 'ops::Cheese::loves::Daniel'
]))
def test_retreival(self):
self.triangle.insert(s='Daniel', p='loves', o='Cheese')
self.triangle.insert(s='Daniel', p='loves', o='Sushi')
self.assertEqual(set(self.triangle.start(s='Daniel')),
{('Daniel', 'loves', 'Cheese'),
('Daniel', 'loves', 'Sushi')})
self.assertEqual(set(self.triangle.start(o='Sushi')),
{('Daniel', 'loves', 'Sushi')})
def test_retreival_2(self):
self.triangle.insert(s='Daniel', p='loves', o='Cheese')
self.triangle.insert(s='Daniel', p='loves', o='Sushi')
self.assertEqual(
set(self.triangle.start(s='Daniel').traverse(o='Cheese')), {
('Daniel', 'loves', 'Cheese'),
})
def test_batch_insert(self):
with self.triangle.batch_insert() as f:
f.insert(s='Daniel', p='loves', o='Cheese')
f.insert(s='Daniel', p='loves', o='Sushi')
self.assertEqual(set(self.triangle.start(s='Daniel')),
{('Daniel', 'loves', 'Cheese'),
('Daniel', 'loves', 'Sushi')})
def test_exception_rolls_back(self):
try:
with self.triangle.batch_insert() as f:
f.insert(s='Daniel', p='loves', o='Cheese')
f.insert(s='Daniel', p='loves', o='Sushi')
0 / 0
except ZeroDivisionError:
pass
self.assertEqual(len(set(self.triangle.start(s='Daniel'))), 0)
def test_graph_of_the_gods(self):
path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'data/graph_of_the_gods.json')
with open(path) as f:
graph = json.loads(f.read())
vertex_map = {}
for v in graph['node']:
vertex_map[v['-id']] = v['data'][1]['#text'] + ':' + v['data'][
0]['#text']
with self.triangle.batch_insert() as h:
for e in graph['edge']:
s = vertex_map[e['-source']]
o = vertex_map[e['-target']]
p = e['-label']
h.insert(s=s, p=p, o=o)
# Where do gods live?
self.assertEqual(
sorted(list(self.triangle.start(s='god').traverse(p='lives'))),
sorted([('god:jupiter', 'lives', 'location:sky'),
('god:neptune', 'lives', 'location:sea'),
('god:pluto', 'lives', 'location:tartarus')]))
# Usually gods live in the sky
self.assertEqual(
list(
self.triangle.start(s='god').traverse(p='lives').traverse(
o='location:sky')),
[('god:jupiter', 'lives', 'location:sky')])
result = (vs(self.triangle.start(s='demigod')) & vs(
self.triangle.start(p='mother').traverse(o='human:alcmene')))
self.assertEqual(result, {'demigod:hercules'})
def setUp(self):
path = tempfile.mktemp('.ldb')
db = leveldb.LevelDB(path)
self.triangle = Hexagon(db)
def setUp(self):
path = tempfile.mktemp('.ldb')
db = leveldb.LevelDB(path)
self.triangle = Hexagon(db)
_openings = list(
map(lambda x: str(int(x) + 1),
row['Openings'].strip().split(',')))
except Exception as e:
import ipdb
ipdb.set_trace(context=5)
print(e)
else:
_openings = row['Openings'].strip().split(',')
_new_hex = Hexagon(
id=_hexagon_id,
spreadsheet_row=row_id + 2,
center=row['Center'].strip(),
openings=_openings,
link1=row['Link1'].strip(),
link2=row['Link2'].strip(),
link3=row['Link3'].strip(),
link4=row['Link4'].strip(),
link5=row['Link5'].strip(),
link6=row['Link6'].strip(),
)
if _dup_hash.get(_new_hex.get_hash(), False):
continue
_dup_hash[_new_hex.get_hash()] = True
_hexagons.append(_new_hex)
for _missing_link_num in _hexagons[-1].get_available_links():
_link_name = convert_num_to_link_name(_missing_link_num)
_hexagon_missing_links[_link_name].append(_hexagon_id)
_hexagon_id += 1
class HexagonTest(unittest.TestCase):
def setUp(self):
path = tempfile.mktemp('.ldb')
db = leveldb.LevelDB(path)
self.triangle = Hexagon(db)
def test_it_exists(self):
self.assertTrue(self.triangle)
def test_insertion(self):
wb = mock.Mock()
self.triangle.db = mock.Mock()
with mock.patch('hexagon.core.leveldb.WriteBatch', return_value=wb):
self.triangle.insert(s='Daniel', p='loves', o='Cheese')
self.assertEqual(
sorted(i[0][0] for i in wb.Put.call_args_list),
sorted(['spo::Daniel::loves::Cheese',
'sop::Daniel::Cheese::loves',
'pso::loves::Daniel::Cheese',
'pos::loves::Cheese::Daniel',
'osp::Cheese::Daniel::loves',
'ops::Cheese::loves::Daniel'])
)
def test_retreival(self):
self.triangle.insert(s='Daniel', p='loves', o='Cheese')
self.triangle.insert(s='Daniel', p='loves', o='Sushi')
self.assertEqual(set(self.triangle.start(s='Daniel')), {
('Daniel', 'loves', 'Cheese'),
('Daniel', 'loves', 'Sushi')
})
self.assertEqual(set(self.triangle.start(o='Sushi')), {
('Daniel', 'loves', 'Sushi')
})
def test_retreival_2(self):
self.triangle.insert(s='Daniel', p='loves', o='Cheese')
self.triangle.insert(s='Daniel', p='loves', o='Sushi')
self.assertEqual(set(self.triangle.start(s='Daniel').traverse(o='Cheese')), {
('Daniel', 'loves', 'Cheese'),
})
def test_batch_insert(self):
with self.triangle.batch_insert() as f:
f.insert(s='Daniel', p='loves', o='Cheese')
f.insert(s='Daniel', p='loves', o='Sushi')
self.assertEqual(set(self.triangle.start(s='Daniel')), {
('Daniel', 'loves', 'Cheese'),
('Daniel', 'loves', 'Sushi')
})
def test_exception_rolls_back(self):
try:
with self.triangle.batch_insert() as f:
f.insert(s='Daniel', p='loves', o='Cheese')
f.insert(s='Daniel', p='loves', o='Sushi')
0/0
except ZeroDivisionError:
pass
self.assertEqual(len(set(self.triangle.start(s='Daniel'))), 0)
def test_graph_of_the_gods(self):
path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'data/graph_of_the_gods.json'
)
with open(path) as f:
graph = json.loads(f.read())
vertex_map = {}
for v in graph['node']:
vertex_map[v['-id']] = v['data'][1]['#text'] + ':' + v['data'][0]['#text']
with self.triangle.batch_insert() as h:
for e in graph['edge']:
s = vertex_map[e['-source']]
o = vertex_map[e['-target']]
p = e['-label']
h.insert(s=s, p=p, o=o)
# Where do gods live?
self.assertEqual(
sorted(list(self.triangle.start(s='god').traverse(p='lives'))),
sorted([('god:jupiter', 'lives', 'location:sky'),
('god:neptune', 'lives', 'location:sea'),
('god:pluto', 'lives', 'location:tartarus')])
)
# Usually gods live in the sky
self.assertEqual(
list(self.triangle.start(s='god').traverse(p='lives').traverse(o='location:sky')),
[('god:jupiter', 'lives', 'location:sky')]
)
result = (
vs(self.triangle.start(s='demigod')) &
vs(self.triangle.start(p='mother').traverse(o='human:alcmene'))
)
self.assertEqual(result, {'demigod:hercules'})
def generate(start_seg, stop_seg): #, distance, height_range=(0, 2)):
from hexagon import Hexagon
# for curr_seg in a_star(start_seg, stop_seg):
for curr_seg in Hexagon.find_path(start_seg, stop_seg):
curr_seg.set_improvement('road', True)
def __init__(self,
robot_id,
hex_internal_list,
hex_external_list,
ball,
hist_curve,
np_file='/tmp/magnetic_ground_truth.np',
height=40,
battery=99999,
debug=True):
self.robot_id = robot_id
self.debug = debug
self.status = 'GOING_TO_NEXT_HEX'
self.hex_index = 0
self.base_battery = battery
self.battery = self.base_battery
self.movement_mode = 0
self.max_delta = 10
self.step_p = 0.6 # 0.06
self.ball = ball
self.np_file = np_file
np_mat = np.loadtxt(self.np_file)
np_mat *= 255.0 / np_mat.max()
self.np_mat = np_mat
self.height = height
self.hex_external_list = hex_external_list
self.hex_polygon = dict()
for key in hex_internal_list.keys():
hex_obj = Hexagon(hex_internal_list[key],
external_points=self.hex_external_list[key])
self.hex_polygon[key] = hex_obj
self.hex_internal_list = hex_internal_list
self.hist_curve = hist_curve
self.last_position = [ball.y, ball.x, ball.z]
self.print_message("Starting pos: {0} {1} {2}".format(
ball.x, ball.y, ball.z))
self.home_position = self.last_position
self.home_route = []
self.return_to_route = []
self.history = []
self.wp_index = 0
# Define first route to reach hexagon
next_wp = self.hex_internal_list[self.hex_index][self.wp_index]
go_next_wp = math_helper.get_line_points(self.last_position,
next_wp,
step=20)
go_next_wp_3d = math_helper.get_3d_coverage_points(go_next_wp,
self.height,
self.np_file,
np_mat=self.np_mat)
self.next_hexagon_route = go_next_wp_3d
pass
def get_base_hex(self):
from hexagon import Hexagon
hex_ptr = board_object_lib.BoardObject_get_base_hex(self._c_pointer)
return Hexagon.get_hexagon(hex_ptr)
def setUp(self):
self.hexagon = Hexagon(10, 11, 12, 13, 14, 15)
def get_hexagon(self, i, j):
curr_c_hex = controller_lib.Controller_get_hexagon(c_int(i), c_int(j))
return Hexagon.get_hexagon(curr_c_hex)
def setUp(self):
"""intialize the environment for all tests"""
self.hexagon = Hexagon((0, 0), 50, sf.Color(127, 127, 127),
sf.Color(127, 127, 127))
def get_hexagon(self, i, j):
curr_c_hex = controller_lib.Controller_get_hexagon(c_int(i), c_int(j))
return Hexagon.get_hexagon(curr_c_hex)
def init_board(self):
from player_input import PlayerInput
self.player_input = PlayerInput()
controller_lib.Controller_set_player_input(
self.player_input._c_pointer)
self.zoom = GlobalConsts.START_ZOOM
self.rotation = GlobalConsts.START_ROTATION
self.view_range = GlobalConsts.BOARD_WIDTH
print 'Creating Board...'
for j in range(GlobalConsts.BOARD_HEIGHT):
for i in range(GlobalConsts.BOARD_WIDTH):
x = i * 1.5
y = j if not i % 2 else j + 0.5
curr_hex = Hexagon(x * GlobalConsts.COS_60,
y * GlobalConsts.SIN_60)
controller_lib.Controller_push_hexagon(curr_hex._c_pointer)
print "Linking Segments..."
self.link_segments()
if GlobalConsts.GENERATE_HILLS:
print 'Generating hills',
for i in range(int(20 * (GlobalConsts.BOARD_WIDTH / 100.0))):
print '.',
x_start = int(random() * GlobalConsts.BOARD_WIDTH)
y_start = int(random() * GlobalConsts.BOARD_WIDTH)
RollingHillsGen.generate(self.get_hexagon(x_start, y_start),
750 *
(GlobalConsts.BOARD_WIDTH / 100.0),
height_range=(0, 0.015))
RollingHillsGen.generate(self.get_hexagon(x_start, y_start),
750 *
(GlobalConsts.BOARD_WIDTH / 100.0),
height_range=(0, -0.0225))
print
if GlobalConsts.GENERATE_MOUNTAINS:
print 'Generating mountains',
for i in range(int(7 * (GlobalConsts.BOARD_WIDTH / 100.0))):
print '.',
x_start = int(random() * GlobalConsts.BOARD_WIDTH)
y_start = int(random() * GlobalConsts.BOARD_WIDTH)
MountainRangeGen.generate(
self.get_hexagon(x_start, y_start),
Hexagon.NEIGHBOR_DIRECTION[int(
random() * len(Hexagon.NEIGHBOR_DIRECTION))],
60 * (GlobalConsts.BOARD_WIDTH / 100.0),
2,
height_range=(0.25, 1.0))
print
road_hexagons = []
for i in range(3):
while True:
curr_hex = self.get_hexagon(
int(random() * GlobalConsts.BOARD_WIDTH),
int(random() * GlobalConsts.BOARD_HEIGHT))
if curr_hex.is_pathable():
road_hexagons.append(curr_hex)
break
RoadGen.generate(road_hexagons[0], road_hexagons[1])
RoadGen.generate(road_hexagons[1], road_hexagons[2])
RoadGen.generate(road_hexagons[2], road_hexagons[0])
from timeit import Timer
from functools import partial
def get_execution_time(function, *args, **kwargs):
"""Return the execution time of a function in seconds."""
numberOfExecTime = kwargs.pop('numberOfExecTime', 20)
return Timer(partial(function, *args,
**kwargs)).timeit(numberOfExecTime)
from util import a_star
# return a_star(hex_a, hex_b)
for i in range(3):
print 'cpp:', get_execution_time(Hexagon.find_path,
road_hexagons[i - 1],
road_hexagons[i])
print 'pyc:', get_execution_time(a_star, road_hexagons[i - 1],
road_hexagons[i])
print '---'
# while True:
# curr_hex = self.get_hexagon(int(random() * GlobalConsts.BOARD_WIDTH), int(random() * GlobalConsts.BOARD_HEIGHT))
# if curr_hex.is_pathable():
# break
# # print 'dist: ', dist_between(curr_hex, curr_hex.get_neighbor('N').get_neighbor('N')), 'should be 2'
# # print 'dist: ', dist_between(curr_hex, curr_hex.get_neighbor('S').get_neighbor('S')), 'should be 2'
# # print 'dist: ', dist_between(curr_hex, curr_hex.get_neighbor('S').get_neighbor('S').get_neighbor('SE').get_neighbor('SE')), 'should be 3ish'
# RoadGen.generate(
# curr_hex, curr_hex.get_neighbor('N').get_neighbor('N')
# )
# Hexagon.find_path(curr_hex, curr_hex.get_neighbor('N').get_neighbor('N'))
# from util import dist_between
# print dist_between(road_hexagons[0], road_hexagons[0].get_neighbor('N'))
# print 1 / dist_between(road_hexagons[0], road_hexagons[0].get_neighbor('S'))
# print dist_between(road_hexagons[0], road_hexagons[0].get_neighbor('NW'))
height_list = [hex.get_height() for hex in Hexagon.get_all_hexagons()]
max_height = max(height_list)
min_height = min(height_list)
if max_height and min_height:
for hex in Hexagon.get_all_hexagons():
height = hex.get_height()
if height > 0.0:
height_percent = (height / max_height)
if height_percent < 0.5:
curr_percent = height_percent * 2.0
red = curr_percent * 0.7
green = 0.5 + curr_percent * 0.2
blue = curr_percent * 0.7
else:
curr_percent = (height_percent - 0.5) * 2.0
red = 0.7 + curr_percent * 0.3
green = 0.7 + curr_percent * 0.3
blue = 0.7 + curr_percent * 0.3
else:
height_percent = abs(height / min_height)
if height_percent < 0.5:
curr_percent = height_percent * 2.0
red = curr_percent * 0.3
green = 0.5 - curr_percent * 0.5
blue = 0
else:
curr_percent = (height_percent - 0.5) * 2.0
red = 0.3 + curr_percent * 0.7
green = 0
blue = 0
hex.set_hex_color(red, green, blue)
else:
for hex in Hexagon.get_all_hexagons():
hex.set_hex_color(0, 0.5, 0)
img_list = [
'media/test_a.png',
'media/test_b.png',
]
for i in range(1):
while True:
curr_hex = self.get_hexagon(
int(random() * GlobalConsts.BOARD_WIDTH),
int(random() * GlobalConsts.BOARD_HEIGHT))
if curr_hex.is_pathable():
board_obj = BoardObject(curr_hex, img_list[i])
break
# orig_hex = self.get_hexagon(int(random() * GlobalConsts.BOARD_WIDTH), int(random() * GlobalConsts.BOARD_HEIGHT))
# for i in range(10):
# curr_hex = orig_hex
# for j in range(13):
# curr_hex.set_select_color(1, 0, 1)
# k = 0.0
# for neigh_hex in curr_hex.get_neighbors().values():
# k += 1.0 / 6.0
# neigh_hex.set_select_color(1, k, 0)
# curr_hex = curr_hex.get_neighbor("N").get_neighbor("N").get_neighbor("N")
# orig_hex = orig_hex.get_neighbor("NE").get_neighbor("SE").get_neighbor("NE").get_neighbor("SE")
board_obj.set_selected(True)
def get_base_hex(self):
from hexagon import Hexagon
hex_ptr = board_object_lib.BoardObject_get_base_hex(self._c_pointer)
return Hexagon.get_hexagon(hex_ptr)
def display_units(window, units):
"""
Display all unit on the map
:param window:window used to display
:param units:list of all units
"""
hexa = Hexagon((100, 100), SIZE, GRAY_127, BORDER)
texture_mgr = TextureManager()
for unit in units:
hexa.set_texture(texture_mgr.get_unit_texture(unit))
hexa.position = convert_coord_to_pixel(unit.get_position())
window.draw(hexa)
if unit.get_selected():
hexa.set_texture(None)
hexa.set_color(sf.Color(250, 50, 250, 50))
window.draw(hexa)
neighbors = unit.get_neighbors()
for i in range(len(neighbors)):
pos = unit.get_position()
neighbor = (neighbors[i][0] + pos[0], neighbors[i][1] + pos[1])
hexa.position = convert_coord_to_pixel(neighbor)
hexa.set_color(sf.Color(0, 0, 250, 50))
window.draw(hexa)
def init_board(self):
from player_input import PlayerInput
self.player_input = PlayerInput()
controller_lib.Controller_set_player_input(self.player_input._c_pointer)
self.zoom = GlobalConsts.START_ZOOM
self.rotation = GlobalConsts.START_ROTATION
self.view_range = GlobalConsts.BOARD_WIDTH
print 'Creating Board...'
for j in range(GlobalConsts.BOARD_HEIGHT):
for i in range(GlobalConsts.BOARD_WIDTH):
x = i * 1.5
y = j if not i%2 else j + 0.5
curr_hex = Hexagon(x * GlobalConsts.COS_60, y * GlobalConsts.SIN_60)
controller_lib.Controller_push_hexagon(curr_hex._c_pointer)
print "Linking Segments..."
self.link_segments()
if GlobalConsts.GENERATE_HILLS:
print 'Generating hills',
for i in range(int(20 * (GlobalConsts.BOARD_WIDTH / 100.0))):
print '.',
x_start = int(random() * GlobalConsts.BOARD_WIDTH)
y_start = int(random() * GlobalConsts.BOARD_WIDTH)
RollingHillsGen.generate(self.get_hexagon(x_start, y_start), 750 * (GlobalConsts.BOARD_WIDTH / 100.0), height_range=(0, 0.015))
RollingHillsGen.generate(self.get_hexagon(x_start, y_start), 750 * (GlobalConsts.BOARD_WIDTH / 100.0), height_range=(0, -0.0225))
print
if GlobalConsts.GENERATE_MOUNTAINS:
print 'Generating mountains',
for i in range(int(7 * (GlobalConsts.BOARD_WIDTH / 100.0))):
print '.',
x_start = int(random() * GlobalConsts.BOARD_WIDTH)
y_start = int(random() * GlobalConsts.BOARD_WIDTH)
MountainRangeGen.generate(
self.get_hexagon(x_start, y_start),
Hexagon.NEIGHBOR_DIRECTION[int(random() * len(Hexagon.NEIGHBOR_DIRECTION))],
60 * (GlobalConsts.BOARD_WIDTH / 100.0), 2, height_range=(0.25, 1.0)
)
print
road_hexagons = []
for i in range(3):
while True:
curr_hex = self.get_hexagon(int(random() * GlobalConsts.BOARD_WIDTH), int(random() * GlobalConsts.BOARD_HEIGHT))
if curr_hex.is_pathable():
road_hexagons.append(curr_hex)
break
RoadGen.generate(
road_hexagons[0], road_hexagons[1]
)
RoadGen.generate(
road_hexagons[1], road_hexagons[2]
)
RoadGen.generate(
road_hexagons[2], road_hexagons[0]
)
from timeit import Timer
from functools import partial
def get_execution_time(function, *args, **kwargs):
"""Return the execution time of a function in seconds."""
numberOfExecTime = kwargs.pop('numberOfExecTime', 20)
return Timer(partial(function, *args, **kwargs)).timeit(numberOfExecTime)
from util import a_star
# return a_star(hex_a, hex_b)
for i in range(3):
print 'cpp:', get_execution_time(Hexagon.find_path, road_hexagons[i-1], road_hexagons[i])
print 'pyc:', get_execution_time(a_star, road_hexagons[i-1], road_hexagons[i])
print '---'
# while True:
# curr_hex = self.get_hexagon(int(random() * GlobalConsts.BOARD_WIDTH), int(random() * GlobalConsts.BOARD_HEIGHT))
# if curr_hex.is_pathable():
# break
# # print 'dist: ', dist_between(curr_hex, curr_hex.get_neighbor('N').get_neighbor('N')), 'should be 2'
# # print 'dist: ', dist_between(curr_hex, curr_hex.get_neighbor('S').get_neighbor('S')), 'should be 2'
# # print 'dist: ', dist_between(curr_hex, curr_hex.get_neighbor('S').get_neighbor('S').get_neighbor('SE').get_neighbor('SE')), 'should be 3ish'
# RoadGen.generate(
# curr_hex, curr_hex.get_neighbor('N').get_neighbor('N')
# )
# Hexagon.find_path(curr_hex, curr_hex.get_neighbor('N').get_neighbor('N'))
# from util import dist_between
# print dist_between(road_hexagons[0], road_hexagons[0].get_neighbor('N'))
# print 1 / dist_between(road_hexagons[0], road_hexagons[0].get_neighbor('S'))
# print dist_between(road_hexagons[0], road_hexagons[0].get_neighbor('NW'))
height_list = [hex.get_height() for hex in Hexagon.get_all_hexagons()]
max_height = max(height_list)
min_height = min(height_list)
if max_height and min_height:
for hex in Hexagon.get_all_hexagons():
height = hex.get_height()
if height > 0.0:
height_percent = (height / max_height)
if height_percent < 0.5:
curr_percent = height_percent * 2.0
red = curr_percent * 0.7
green = 0.5 + curr_percent * 0.2
blue = curr_percent * 0.7
else:
curr_percent = (height_percent - 0.5) * 2.0
red = 0.7 + curr_percent * 0.3
green = 0.7 + curr_percent * 0.3
blue = 0.7 + curr_percent * 0.3
else:
height_percent = abs(height / min_height)
if height_percent < 0.5:
curr_percent = height_percent * 2.0
red = curr_percent * 0.3
green = 0.5 - curr_percent * 0.5
blue = 0
else:
curr_percent = (height_percent - 0.5) * 2.0
red = 0.3 + curr_percent * 0.7
green = 0
blue = 0
hex.set_hex_color(red, green, blue)
else:
for hex in Hexagon.get_all_hexagons():
hex.set_hex_color(0, 0.5, 0)
img_list = [
'media/test_a.png',
'media/test_b.png',
]
for i in range(1):
while True:
curr_hex = self.get_hexagon(int(random() * GlobalConsts.BOARD_WIDTH), int(random() * GlobalConsts.BOARD_HEIGHT))
if curr_hex.is_pathable():
board_obj = BoardObject(curr_hex, img_list[i])
break
# orig_hex = self.get_hexagon(int(random() * GlobalConsts.BOARD_WIDTH), int(random() * GlobalConsts.BOARD_HEIGHT))
# for i in range(10):
# curr_hex = orig_hex
# for j in range(13):
# curr_hex.set_select_color(1, 0, 1)
# k = 0.0
# for neigh_hex in curr_hex.get_neighbors().values():
# k += 1.0 / 6.0
# neigh_hex.set_select_color(1, k, 0)
# curr_hex = curr_hex.get_neighbor("N").get_neighbor("N").get_neighbor("N")
# orig_hex = orig_hex.get_neighbor("NE").get_neighbor("SE").get_neighbor("NE").get_neighbor("SE")
board_obj.set_selected(True)
