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