def test_dijkstra(self):
"""Test dijkstras."""
grid = Grid(5)
grid.create_grid()
hexagon = Hex(-1, 1, 0)
grid.get_hextile((0, 0, 0)).terrain = Terrain(TerrainType.MOUNTAIN,
BiomeType.GRASSLAND)
grid.get_hextile((0, 1, -1)).terrain = Terrain(TerrainType.MOUNTAIN,
BiomeType.GRASSLAND)
grid.get_hextile((-1, 0, 1)).terrain = Terrain(TerrainType.MOUNTAIN,
BiomeType.GRASSLAND)
result = [
Hex(-1, 1, 0),
Hex(-1, 2, -1),
Hex(-2, 2, 0),
Hex(-2, 1, 1),
Hex(0, 2, -2),
Hex(2, 0, -2),
Hex(2, -1, -1),
Hex(-2, 0, 2),
Hex(2, -2, 0),
Hex(1, -2, 1),
Hex(0, -2, 2)
]
dijkstra = [x for x in grid.dijkstra(hexagon, 2)]
result = set(result).difference(dijkstra)
self.assertEqual(set(), result)
def __init__(self, width, height):
Level.__init__(self, width, height)
##initialize blocks##
boxtop = Terrain(20, -19, 40, 2, 0, 0,100, self, 0.5)
boxleft= Terrain(-1,-5,2,30,0,0,100,self,0.5)
boxbottom= Terrain(27.0,9.0,54.0,2.0,0.0,0.0,100,self,0.5)
boxright= Terrain(55,-5,2,30,0,0,100,self,0.5)
goal= Goal(53,5,1,5,0,0,100,self,0.5)
b = Block(2, 2, 4, 1, 0, 0, 1, self, 0.5)
c = Player(7, 5, 1, 2, 0, 0, 1, self, 0.5)
d = Block(4, 2, 4, 1, 0, 5, 2, self, 0.5)
a = GoalBlock(4, 5, 2, 2, 0, 5, 2, self, 0.5)
m = Trampoline(30, -4, 2, 1, 0, 0, 1, self, 0.5)
e = Spike(30.0, 7.5, 41.0, 1.0, 0.0, 0.0, 100, self, 0.1)
f = Spike(29.0, 6.5, 1.0, 1.0, 0.0, 0.0, 100, self, 0.1)
self.add_elem(c)
self.add_elem(m)
self.add_elem(b)
self.add_elem(a)
self.add_elem(d)
self.add_elem(e)
self.add_elem(f)
self.add_elem(boxtop)
self.add_elem(boxright)
self.add_elem(boxbottom)
self.add_elem(boxleft)
self.add_elem(goal)
def __init__(self, width, height):
Level.__init__(self, width, height)
##initialize blocks##
boxtop = Terrain(20, -19, 40, 2, 0, 0, 100, self, 0.5)
boxleft = Terrain(-1, -5, 2, 30, 0, 0, 100, self, 0.5)
boxbottom = Terrain(20, 9, 40, 2, 0, 0, 100, self, 0.5)
boxright = Terrain(41, -5, 2, 30, 0, 0, 100, self, 0.5)
goal = Goal(38, 5, 1, 5, 0, 0, 100, self, 0.5)
b10 = Block(1, 7, 2, 2, 0, 0, 1, self, 0.5)
b20 = Block(3, 7, 2, 2, 0, 0, 1, self, 0.5)
b30 = Block(5, 7, 2, 2, 0, 0, 1, self, 0.5)
b40 = Block(7, 7, 2, 2, 0, 0, 1, self, 0.5)
b50 = Block(9, 7, 2, 2, 0, 0, 1, self, 0.5)
b11 = Block(1, 5, 2, 2, 0, 0, 1, self, 0.5)
b21 = Block(3, 5, 2, 2, 0, 0, 1, self, 0.5)
b31 = Block(5, 5, 2, 2, 0, 0, 1, self, 0.5)
b41 = Block(7, 5, 2, 2, 0, 0, 1, self, 0.5)
b51 = Block(9, 5, 2, 2, 0, 0, 1, self, 0.5)
b12 = Block(1, 3, 2, 2, 0, 0, 1, self, 0.5)
b22 = Block(3, 3, 2, 2, 0, 0, 1, self, 0.5)
b32 = Block(5, 3, 2, 2, 0, 0, 1, self, 0.5)
b42 = Block(7, 3, 2, 2, 0, 0, 1, self, 0.5)
b52 = Block(9, 3, 2, 2, 0, 0, 1, self, 0.5)
p = Player(15, 5, 1, 2, 0, 0, 1, self, 0.5)
g = GoalBlock(17, 5, 2, 2, 0, 0, 2, self, 0.5)
barrier = Terrain(35, -3, 1, 22, 0, 0, 100, self, 0.5)
self.add_elem(p)
self.add_elem(b10)
self.add_elem(b20)
self.add_elem(b30)
self.add_elem(b40)
self.add_elem(b50)
self.add_elem(b11)
self.add_elem(b21)
self.add_elem(b31)
self.add_elem(b41)
self.add_elem(b51)
self.add_elem(b12)
self.add_elem(b22)
self.add_elem(b32)
self.add_elem(b42)
self.add_elem(b52)
self.add_elem(barrier)
self.add_elem(g)
self.add_elem(boxtop)
self.add_elem(boxright)
self.add_elem(boxbottom)
self.add_elem(boxleft)
self.add_elem(goal)
def test_shortest_path(self):
"""Test shortest path."""
grid = Grid(5)
grid.create_grid()
start = Hex(-1, 1, 0)
end = Hex(1, -1, 0)
grid.get_hextile((0, 0, 0)).terrain = Terrain(TerrainType.MOUNTAIN,
BiomeType.GRASSLAND)
grid.get_hextile((0, 1, -1)).terrain = Terrain(TerrainType.MOUNTAIN,
BiomeType.GRASSLAND)
grid.get_hextile((-1, 0, 1)).terrain = Terrain(TerrainType.MOUNTAIN,
BiomeType.GRASSLAND)
result = [Hex(-1, 2, -1), Hex(2, -2, 0), Hex(1, -1, 0)]
self.assertEqual(grid.shortest_path(start, end, 3), result)
def __init__(self):
self.debug = False
ShowBase.__init__(self)
self.accept("escape",sys.exit)
# the dt should depend on the framerate
self.dt = 0.25
"""try:
self.database = Database()
self.ranking = self.database.getRankingFromDatabase()
except:
pass"""
self.musicManager.setConcurrentSoundLimit(2)
#initiate game state
self.state = 'Menu'
self.terrain = Terrain(1024)
"""try:
self.classement = Classement(self.ranking)
self.classement.hideMenu()
except:
pass"""
self.menu = Menu()
self.loadStartMenu()
if(self.debug == False):
self.disableMouse()
def reset(self, level=1):
pygame.mixer.music.stop()
pygame.mixer.music.play(10**8)
self.menu = Menu()
self.menu.add_button('Continue', (self.width // 2 - 150, 200),
target=self.open_menu)
self.menu.add_button('Music', target=self.switch_music, switch=True)
self.menu.add_button('Sounds', target=self.switch_sounds, switch=True)
self.menu.add_button('Quit game', target=self.terminate)
self.sprite_groups = {k: pygame.sprite.Group() for k in range(20, 30)}
self.conditions = {k: False for k in range(40, 50)}
self.conditions[RUNNING] = True
self.conditions[FULLSCREEN] = True
self.keys_pressed = []
self.terrain = Terrain(16 * 3 * 3, 16 * 3 * 3, level)
self.sprite_groups[CHUNKS] = pygame.sprite.Group(self.terrain.chunks)
for chunk in self.sprite_groups[CHUNKS]:
self.sprite_groups[ALL].add(chunk)
self.screen2 = pygame.Surface((self.width, self.height),
pygame.HWSURFACE, 32)
self.player = Player(
(self.sprite_groups[ENTITIES], self.sprite_groups[ALL]),
(500, 500))
self.camera = Camera(self.terrain.get_width(),
self.terrain.get_height(), self.player,
self.width // 2, self.height // 2)
self.pathfinder = PathFinder(self.terrain.obst_grid)
self.paths = dict()
self.sprite_groups[PLAYER].add(self.player)
self.camera.update()
async def on_start(self):
self.terrain: Terrain = Terrain(self)
self.creep_manager: CreepManager = CreepManager(self, self.terrain)
await self.terrain.store_map_feature_coordinates()
await self.terrain.calculate_expansion_path_distances()
await self.map_chunks()
def __init__(self, queue, door_coords):
self.agent_queue = queue
source = Human_source(1500)
event_list = [
Generator('0_0', door_coords[0][0], source, 3),
Generator('0_1', door_coords[0][1], source, 3),
Generator('0_2', door_coords[0][2], source, 3),
Generator('0_3', door_coords[0][3], source, 3),
Generator('1_0', door_coords[1][0], source, 3),
Generator('1_1', door_coords[1][1], source, 3),
Generator('2_0', door_coords[2][0], source, 3),
Generator('3_0', door_coords[3][0], source, 3),
Generator('4_0', door_coords[4][0], source, 3),
Generator('5_0', door_coords[5][0], source, 3)
]
for area, timming, initial_light in grid_info.traffic_lights :
green,red = timming
green,red = green*grid_info.FPS, red*grid_info.FPS
light = Traffic_light(area, (green,red), initial_light)
event_list.append(light)
self.engine = Engine(terrain = Terrain("grid_bits.txt"), initial_event_list = event_list)
super(Simulator, self).__init__()
def setup(self):
'''
Setting up the environment.
'''
# Setting up space.
self.space = pymunk.Space()
self.space.gravity = GRAVITY
self.space.sleep_time_threshold = 1
# Creating cars.
self.cars = []
for _ in range(NUM_CARS):
self.cars.append(BoxCar(self.space))
# Setting up terrain and checkpoints.
self.terrain = Terrain(self.space)
self.checkpoints = self.terrain.get_checkpoints()
# Setting up extra UI elements.
self.goal = arcade.create_line(self.checkpoints[-1].x - 40,
self.checkpoints[-1].y,
self.checkpoints[-1].x - 40,
self.checkpoints[-1].y + 50,
arcade.color.GREEN, 2)
self.generation_number = 1
self.best_score = 0
self.plot_history = []
self.score_history = []
self.score_list = arcade.ShapeElementList()
def __init__(self,
knot_points_per_phase,
steps,
total_duration,
model='hopper',
terrain='flat'):
super().__init__()
self.knot_points_per_phase = knot_points_per_phase
self.num_phases = steps
self.total_duration = total_duration
if model == 'hopper':
self.model = Hopper()
self.time_phases = {}
self.terrain = Terrain(type=terrain)
self.opti = ca.Opti()
self.q = {}
self.qdot = {}
self.u = {}
self.p0 = {} # i = 0
self.dp0 = {} # i = 0
self.f10 = {} # i = 0
self.ceq = []
self.ciq = []
self.setVariables()
self.setConstraints()
self.setBounds()
def main():
pg.init()
resolution = (1200, 900)
window = pg.display.set_mode(resolution, pg.DOUBLEBUF | pg.RESIZABLE)
pg.display.set_caption("pathfinder")
map = Terrain(8, 11, 100)
# format (y, x)
map.set_target([1, 6])
pawn = Pathfinder([6, 6], map.grid)
clock = pg.time.Clock()
run_flag = True
while run_flag:
clock.tick(20)
for event in pg.event.get():
if event.type == pg.QUIT:
run_flag = False
if event.type == pg.KEYDOWN:
if event.key == pg.K_w:
map.add_block_manually(pg.mouse.get_pos())
if event.key == pg.K_e:
map.set_target_manually(pg.mouse.get_pos())
if event.key == pg.K_q:
map.free_block_manually(pg.mouse.get_pos())
window.fill((120, 120, 120))
map.draw(window)
pg.display.update()
pawn.make_move(map.grid, window, map)
def populate(self):
if not os.path.exists(self.path):
os.mkdir(self.path)
if os.path.exists('%s/level.dat' % self.path):
cantLoad = False
f = open('%s/level.dat' % self.path, 'r')
try:
json.loads(f.read())
except:
cantLoad = True
self.server.log.error(
'level.dat unreadable or unparsable - resetting')
f.close()
defaults = {
'seed': random.randrange(-9999999, 9999999),
'time': 0,
'name': ''
}
if not os.path.exists('%s/level.dat' % self.path) or cantLoad:
f = open('%s/level.dat' % self.path, 'w')
f.write(json.dumps(defaults))
f.close()
f = open('%s/level.dat' % self.path, 'r')
self.level = json.loads(f.read())
f.close()
self.terrain = Terrain(self.level['seed'])
def __init__(self, screen: pygame.Surface):
global current_game
current_game = self
self.screen = screen
spritesheet = SpriteSheet('./assets/sprites.png')
self.life_image = pygame.transform.scale(
spritesheet.image_at((423, 345, 16, 8), color_key=-1), (64, 32))
self.checkpoint_image = pygame.transform.scale(
spritesheet.image_at((389, 335, 8, 8), color_key=-1), (32, 32))
self.simplex = OpenSimplex()
self.font = pygame.font.Font('freesansbold.ttf', 24)
self.next_hole = self.screen.get_width(
) + random.random() * HOLE_SPACE_VAR
self.holes = []
self.checkpoint = 0
self.checkpoint_score = 0
self.lives = 3
self.score = 0
self.highest_score = 0
self.terrain = Terrain(screen, MARTIAN_BROWN, self.terrain_point)
self.all_sprites = pygame.sprite.Group()
self.player = Player(START_LOCATION, 0)
self.all_sprites.add(self.player)
def fight(tribes, terrain=None):
results = []
for tribe in tribes:
opponent = random.choice(tribes)
terrain = terrain or Terrain()
results.append(terrain.pit(tribe, opponent))
return results
def test_movement_cost_of_path(self):
"""Test the movement_cost_of_path function."""
civ = Civilisation("myCiv", grid, logger)
hextile = Hex(0, 0, 0)
hextile2 = Hex(1, 0, -1)
hextile3 = Hex(1, 1, -2)
hextile._terrain = Terrain(TerrainType.FLAT, BiomeType.GRASSLAND)
hextile2._terrain = Terrain(TerrainType.HILL, BiomeType.GRASSLAND)
hextile3._terrain = Terrain(TerrainType.HILL, BiomeType.DESERT)
# costs are 1, 2 and 3 respectively
hexes = [hextile, hextile2, hextile3]
archer = Archer(1, 1, hextile, "myCiv")
archer.actions = 2
cost = civ.movement_cost_of_path(hexes)
self.assertEqual(cost, 6)
def importTerrain(self, context):
verts = []
indices = []
try:
heightOffset = Terrain(context).terrain["height_offset"]
except Exception:
heightOffset = None
minHeight = self.buildTerrain(verts, indices, heightOffset)
# apply the offset along z-axis
for v in verts:
v[2] -= minHeight
# create a mesh object in Blender
mesh = bpy.data.meshes.new("Terrain")
mesh.from_pydata(verts, [], indices)
mesh.update()
obj = bpy.data.objects.new("Terrain", mesh)
obj["height_offset"] = minHeight
context.scene.objects.link(obj)
context.scene.blender_osm.terrainObject = obj.name
# force smooth shading
obj.select = True
context.scene.objects.active = obj
bpy.ops.object.shade_smooth()
def __init__(self, map_width, map_height, map_depth):
""" Get the width, the height and the depth of the map """
self.map_width = map_width
self.map_height = map_height
self.map_depth = map_depth
self.light_direction = (50000, 500, 500)
# self.terrain = Terrain("Objects/ground/heightmap_squared.png", light_direction=self.light_direction, translate_y=-100, translate_x=-600, translate_z=-800, scale_total=8)
self.terrain = Terrain("Objects/ground/heightmap.png", light_direction=self.light_direction, translate_y=-100, translate_x=-600, translate_z=-800, scale_total=8)
def __init__(self, terrain_name):
pygame.init()
self.terrain = Terrain(terrain_name)
self.window_size = [self.terrain.pixel_size[0] + 250, self.terrain.pixel_size[1] + 150]
self.window = pygame.display.set_mode(self.window_size)
self.init_content()
def _create_terrain(self, terrain_number, terrain_type):
"""Create a terrain block """
terrain = Terrain(self, terrain_type)
terrain_width, terrain_height = terrain.rect.size
terrain.x = (terrain_width - 2) * terrain_number
terrain.rect.x = terrain.x
terrain.rect.y = 750
self.terrain_group.add(terrain)
def __init__(self, director: Director) -> None:
super().__init__(director)
self.level = 1
self.terrain = Terrain()
self.terrain.generate(self.level)
self.player = Player(self.terrain.data)
self.input_manager = InputManager()
self.gradation_render = GradationRender()
def initOsm(self, op, context, basePath, addonName):
self.op = op
self.assetPath = os.path.join(basePath, "assets")
self.setDataDir(context, basePath, addonName)
# create a sub-directory under <self.dataDir> for OSM files
osmDir = os.path.join(self.dataDir, self.osmDir)
if not os.path.exists(osmDir):
os.makedirs(osmDir)
# <self.logger> may be set in <setup(..)>
self.logger = None
# a Python dict to cache Blender meshes loaded from Blender files serving as an asset library
self.meshes = {}
self.setAttributes(context)
addon = context.scene.blender_osm
if addon.osmSource == "server":
# find a file name for the OSM file
osmFileName = self.osmFileName % ""
counter = 1
while True:
osmFilepath = os.path.realpath( os.path.join(osmDir, osmFileName) )
if os.path.isfile(osmFilepath):
counter += 1
osmFileName = self.osmFileName % "_%s" % counter
else:
break
self.osmFilepath = osmFilepath
self.download(
self.osmUrl % (app.minLon, app.minLat, app.maxLon, app.maxLat),
osmFilepath
)
else:
self.osmFilepath = os.path.realpath(bpy.path.abspath(self.osmFilepath))
if self.loadMissingMembers:
self.incompleteRelations = []
self.missingWays = set()
if not app.has(defs.Keys.mode3d):
self.mode = '2D'
# check if have a terrain Blender object set
terrain = Terrain(context)
self.terrain = terrain if terrain.terrain else None
if self.terrain:
terrain.init()
# manager (derived from manager.Manager) performing some processing
self.managers = []
self.prepareLayers()
if self.terrain and self.singleObject and not self.layered:
print("Imported OpenStreetMap objects will be arranged into layers")
self.layered = True
# tangent to check if an angle of the polygon is straight
Polygon.straightAngleTan = math.tan(math.radians( abs(180.-self.straightAngleThreshold) ))
def __init__(self, x_size=50, y_size=50, terrain=Terrain(5), players=None):
self.x_size = x_size
self.y_size = y_size
self.terrain = terrain
self.speed_of_movement = terrain.value
if players is None:
self.players = []
else:
self.players = player
def main():
tribes = initialize_tribes(amount=4)
for i in range(100):
results = []
terrain = Terrain()
for j in range(10):
results.append(fight(tribes, terrain))
store_best(results)
visualize_best(tribes, results, terrain) # Going to be on other thread
tribes = reinforce(tribes, results)
def main():
pg.init()
a = pg.display.set_mode((800, 400))
testsurf = pg.surface.Surface((2, 2))
testsurf.fill(COLOURS['green'])
t = Terrain('dirt', 'flattish')
t_surf = t.build_surface()
a.blit(t_surf, (0, 0))
print('blitted')
#d = CharacterImage('test', WeaponDummy(testsurf), (0, 0), {}, {})
#d.start_thread((200, 100), a)
print(
CharacterImage.get_topleft_coord(t,
*CharacterImage.find_closest_of(
t, '*')))
truecoord = CharacterImage.find_closest_of(
t, '*')[0], CharacterImage.find_closest_of(t, '*')[1]
print(
CharacterImage.get_topleft_coord(t, *truecoord),
CharacterImage.get_topleft_coord(t,
*CharacterImage.find_closest_of(
t, '*')))
#s.start_thread(CharacterImage.get_topleft_coord(t, *CharacterImage.find_closest_of(t, '#')), a)
# for i in range(100):
# i = CharacterImage('test', WeaponDummy(testsurf), (0,0), {}, {})
# i.start_thread((0, 0 ), a)
pause = events.Pause()
s = CharacterImage('test', WeaponDummy(testsurf),
CharacterImage.get_topleft_coord(t, *truecoord), {}, {})
print(CharacterImage.get_topleft_coord(t, *truecoord))
s.start_thread(800, a)
while True:
#a.blit(PICS['Maps']['army'], CharacterImage.get_topleft_coord(t, *CharacterImage.find_closest_of(t, '*')))
#s.build_image(a)
for i in pg.event.get():
if i.type == QUIT:
print('hello?')
# cleanup and saving and stuff like that can go here, but for now time.sleep tests it.
# always remove the pause from _internal_events before putting Quit
os._exit(0)
#import time; time.sleep(1)
try:
pg.display.update()
a.fill(COLOURS['black'])
a.blit(t_surf, (0, 0))
except pg.error:
# os._exit is about to be called in a seperate thread
pass
print('updated')
CLOCK.tick(FPS)
def __init__(self, window, gamers):
self.terrain = Terrain(1200)
self.worms = []
self.gamers = gamers
for i in range(len(gamers)):
self.worms += [
Worm(300 + i * 200,
self.terrain.get_level(300 + i * 200) + 5, gamers[i], i)
]
self.rockets = []
self.window = window
self.control = []
def __init__(self, width, height):
Level.__init__(self, width, height)
##initialize blocks##
boxtop = Terrain(20, -19, 40, 2, 0, 0, 100, self, 0.5)
boxleft = Terrain(-1, -5, 2, 30, 0, 0, 100, self, 0.5)
boxbottom = Terrain(20, 9, 40, 2, 0, 0, 100, self, 0.5)
boxright = Terrain(41, -5, 2, 30, 0, 0, 100, self, 0.5)
barrbottom = Terrain(15, -6, 6, 1, 0, 0, 100, self, .5)
barrright = Terrain(18.5, -11, 1, 10, 0, 0, 100, self, .5)
goal = Goal(38, -15.5, 1, 5, 0, 0, 100, self, 0.5)
tramp1 = Trampoline(7, 7, 6, 1, 0, 0, 100, self, .5)
tramp2 = Trampoline(36, 7, 6, 1, 0, 0, 100, self, .5)
tramp3 = Trampoline(32, -8, 6, 1, 0, 0, 100, self, .5)
tramp4 = Trampoline(36, -23, 6, 1, 0, 0, 100, self, .5)
p = Player(2, 5, 1, 2, 0, 0, 1, self, 0.5)
g = GoalBlock(16.5, -7, 2, 2, 0, 0, 2, self, 0.5)
self.add_elem(p)
self.add_elem(barrbottom)
self.add_elem(barrright)
self.add_elem(tramp1)
self.add_elem(tramp2)
self.add_elem(tramp3)
self.add_elem(tramp4)
self.add_elem(g)
self.add_elem(boxtop)
self.add_elem(boxright)
self.add_elem(boxbottom)
self.add_elem(boxleft)
self.add_elem(goal)
def _create_terrain_group(self):
"""Create the terrain group made up of terrain blocks"""
# Create a terrain block.
terrain = Terrain(self, 1)
terrain_width, terrain_height = terrain.rect.size
available_space_x = self.settings.screen_width
number_of_terrain_blocks = available_space_x // (terrain_width - 2)
pad_number = randint(2, number_of_terrain_blocks - 2)
for terrain_number in range(number_of_terrain_blocks):
if terrain_number == pad_number:
self._create_pad(terrain_number)
else:
terrain_type = randint(1, 5)
self._create_terrain(terrain_number, terrain_type)
def on_draw(self):
self.draw_number += 1
glLoadIdentity()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
self.camera.draw()
shape = self.shape
terrain = Terrain(self.textures[0], shape)
mat = terrain.get_example_mat(20, 20)
import matTerrian
matTerrian.draw(texture=terrain.sand_texture, mat=mat)
def initializeGL(self):
GL.glClearColor(0.50, 0.50, 0.50, 1.0)
self.heightMap = HeightMap('textures/atacama_height2.png')
self.projection = QMatrix4x4()
self.projection.perspective(self.fov, self.width / self.height, 0.01,
10000)
self.cameraPos = QVector3D(0.0, 1.0, 1.0)
self.terrainPos = QVector3D(0.0, 0.0, 0.0)
self.roverPos = QVector3D(0.0, 0.0, 0.0)
print(GL.glGetString(GL.GL_VERSION))
self.camera = Camera(self.cameraPos, self.heightMap)
self.terrain = Terrain(self.terrainPos, self.heightMap)
self.mask = np.zeros([1001, 1001])
self.terrain.updateRewards(self.mask)
def __init__(self, x, y, z):
"""
Create a new Hex object.
:param x: the x coordinate of the hexagon
:param y: the y coordinate of the hexagon
:param z: the z coordinate of the hexagon
"""
self._x = x
self._y = y
self._z = z
self._terrain = Terrain(TerrainType.FLAT, BiomeType.GRASSLAND)
self._unit = None
self._building = None
self._civ_id = None
self._city_id = None
