def _init_map_and_cm(self,mapName): if mapName == "srandom" or mapName == "sRandom" or mapName == "sr" or mapName == "sR": # Single player random -> adds AI self.mapName = str(random.randint(100,10000)) m = Map("random", numPlayers = 2, AIPlayers = ["1"], seed = int(self.mapName)) elif mapName == "random" or mapName == "Random" or mapName == "r" or mapName == "R": # Multi player random -> doesn't add AI self.mapName = str(random.randint(100,10000)) m = Map("random", numPlayers = 2, seed = int(self.mapName)) elif mapName.isdigit(): m = Map("random", numPlayers = 2, seed = int(mapName)) self.mapName = mapName else: m = Map(os.path.join("maps", mapName + ".map")) self.mapName = mapName # self.map = Map(os.path.join("maps", "random", "random487.map")) self.cm = collision_model.CollisionManagerGrid( -BLEED, m.w * CELL_SIZE + BLEED, -BLEED, m.h * CELL_SIZE + BLEED, CELL_SIZE / 2, CELL_SIZE / 2) m.cm = self.cm self.scroller = ScrollingManager(viewport=director.window) self.scroller.add(m) self.h = CELL_SIZE * m.h if self.h < WINDOW_HEIGHT: self.h = WINDOW_HEIGHT self.w = CELL_SIZE * m.w if self.w < WINDOW_WIDTH: self.w = WINDOW_WIDTH return m
def __init__(self, screen_size): self.screen = pygame.display.set_mode(screen_size, pygame.FULLSCREEN) self.screen.fill([255, 255, 255]) self.map = Map(self.screen, screen_size) self.strategy = Strategy(self.screen, screen_size) self.information = Information(self.screen, screen_size) self.fullmap = FullMap(self.screen, screen_size)
class Main: def __init__(self, screen_size): self.screen = pygame.display.set_mode(screen_size, pygame.FULLSCREEN) self.screen.fill([255, 255, 255]) self.map = Map(self.screen, screen_size) self.strategy = Strategy(self.screen, screen_size) self.information = Information(self.screen, screen_size) self.fullmap = FullMap(self.screen, screen_size) def run(self): clock = pygame.time.Clock() while True: for event in pygame.event.get(): if event.type == pygame.QUIT: return elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: pygame.quit() return # Update all the modules self.map.update(event) self.strategy.update(event) self.fullmap.update() # self.DroneI.update() pygame.display.update() clock.tick(60)
def load_data(self): root_folder = path.dirname(__file__) img_folder = path.join(root_folder, "images") fx_folder = path.join(root_folder, "sound") self.all_sprites = pygame.sprite.Group() self.walls = pygame.sprite.Group() self.fruits = pygame.sprite.Group() # MAPS WITHOUT COLLISION self.map = Map() self.map.load_from_file(MAP) self.map.create_sprites_from_map_data(self) # Load images self.head_image = pygame.image.load(path.join( IMG_FOLDER, SNAKE_HEAD)).convert_alpha() self.body_image = pygame.image.load(path.join( IMG_FOLDER, SNAKE_BODY)).convert_alpha() self.fruit_image = pygame.image.load(path.join(IMG_FOLDER, FRUIT)).convert_alpha() # self.wally_image = pygame.image.load( # path.join(IMG_FOLDER, WALL)).convert_alpha() # Load FX self.music = pygame.mixer.music.load( path.join(FX_FOLDER, BACKGROUND_MUSIC))
def build_output_based_on_hydrolic(self, water_shell_map_ascii_name, rpt_file, link_col_name, limit_node, inp_file_name, limit=1, merge_nodes=None): # merge_nodes format: {1: [1,2,3], 2: [5], 6: [6]} sub_dic = self.build_sub_dicts_by_inp_file(inp_file_name, limit_node, merge_nodes) data_list = self.hydrolic(rpt_file, link_col_name, limit_node, limit, sub_dic) for i in range(len(data_list)): data_list[i] = int(data_list[i]) water_shed_map = map_loader.load_map(WaterShellMap, water_shell_map_ascii_name) water_shed_m = water_shed_map.map self.output_for_watershell = Map() self.output_for_watershell.set_config(water_shed_m) self.build_basic_output_for_watershell() for i in range(len(water_shed_m.matrix)): for j in range(len(water_shed_m.matrix[i])): pixel = water_shed_m.matrix[i][j] if pixel == water_shed_m.no_data_value: continue if pixel in data_list: #print("pixel in data list:", pixel) self.output_for_watershell.matrix[i][j] = 1 else: self.output_for_watershell.matrix[i][j] = 0 return self.output_for_watershell
def test_list_maps(self): new_map = Map('xdps0') list_of_maps = new_map.list_maps() list_of_maps_top = list_of_maps[0] self.assertTrue(isinstance(list_of_maps_top, tuple)) self.assertEqual(2, len(list_of_maps_top)) self.assertTrue(isinstance(list_of_maps_top[0], str)) self.assertTrue(isinstance(list_of_maps_top[1], str))
def response_select(response): if response == Responses.map_direction: Say.phrase(Responses.map_direction) place = None while place is None: place = SpeechWorker.get_without_capture() print(place) place_name, directions = Map.get_to_place(place) Say.phrase(Responses.place_name(place_name)) Say.phrase(Responses.directions_intent()) for direction in directions: Say.phrase(direction) elif response == Responses.map_current_location: current_location = Map.where_am_i() for address in current_location: Say.phrase(address) elif response == Responses.ocr_on: OcrObject.flag = True Say.phrase(Responses.say_ocr_mode_on) OcrObject.ocr_thread = Ocr() OcrObject.ocr_thread.start() elif response == Responses.stop_ocr: OcrObject.flag = False OcrObject.ocr_thread.make_scan_page() OcrObject.ocr_thread.join() elif response == Responses.scan_page: if OcrObject.flag: Say.phrase(Responses.say_scan_page) OcrObject.ocr_thread.make_scan_page() ocr_text = OcrObject.ocr_thread.join() Say.phrase(ocr_text) response_select(Responses.ocr_on) elif response == Responses.get_nearest_bus_stop: stop_name, directions = Map.get_nearest_bus_stop() Say.phrase(Responses.bus_stop_name(stop_name)) Say.phrase(Responses.directions_intent()) for direction in directions: Say.phrase(direction) elif response == Responses.current_time: Say.phrase(get_current_time()) elif response == Responses.name: Say.phrase(Responses.name) elif response == Responses.hello: Say.phrase(Responses.hello) else: Say.phrase(Responses.not_understand)
def _init_map_and_cm(self, mapName): if mapName == "srandom" or mapName == "sRandom" or mapName == "sr" or mapName == "sR": # Single player random -> adds AI self.mapName = str(random.randint(100, 10000)) m = Map("random", numPlayers=2, AIPlayers=["1"], seed=int(self.mapName)) elif mapName == "random" or mapName == "Random" or mapName == "r" or mapName == "R": # Multi player random -> doesn't add AI self.mapName = str(random.randint(100, 10000)) m = Map("random", numPlayers=2, seed=int(self.mapName)) elif mapName.isdigit(): m = Map("random", numPlayers=2, seed=int(mapName)) self.mapName = mapName else: m = Map(os.path.join("maps", mapName + ".map")) self.mapName = mapName # self.map = Map(os.path.join("maps", "random", "random487.map")) self.cm = collision_model.CollisionManagerGrid( -BLEED, m.w * CELL_SIZE + BLEED, -BLEED, m.h * CELL_SIZE + BLEED, CELL_SIZE / 2, CELL_SIZE / 2) m.cm = self.cm self.scroller = ScrollingManager(viewport=director.window) self.scroller.add(m) self.h = CELL_SIZE * m.h if self.h < WINDOW_HEIGHT: self.h = WINDOW_HEIGHT self.w = CELL_SIZE * m.w if self.w < WINDOW_WIDTH: self.w = WINDOW_WIDTH return m
def build_map_from_ascii(self, ascii_file): map = Map() map.n_cols = int(ascii_file.readline().replace('ncols', '').replace('\n', '')) map.n_rows = int(ascii_file.readline().replace('nrows', '').replace('\n', '')) map.xll_corner = float(ascii_file.readline().replace('xllcorner', '').replace( '\n', '')) map.yll_corner = float(ascii_file.readline().replace('yllcorner', '').replace( '\n', '')) map.cell_size = int(ascii_file.readline().replace('cellsize', '').replace( '\n', '')) map.no_data_value = int(ascii_file.readline().replace( 'NODATA_value', '').replace('\n', '')) # map.matrix = [] for i in range(map.n_rows): line_str = ascii_file.readline() line_list = line_str.split(' ') line_list = line_list[:len(line_list) - 1] for j in range(len(line_list)): line_list[j] = float(line_list[j]) if len(line_list) > map.n_cols: line_list = line_list[:map.n_cols] elif len(line_list) < map.n_cols: for j in range(map.n_cols - len(line_list)): line_list.append(map.no_data_value) map.matrix.append(line_list) return map
def clear(self): self.final_price = 0 self.price_for_sub = {} self.priority_pixels_for_sub = {} self.sub = {} self.priorities = {} self.config_map = Map() self.config_map = Map() self.output_map = Map() self.extra_volume_left = 0 self.as_extra_volume_left = 0
def test_get_fail(self): #Arrange m = Map("mappy", "somefilepath") n = Map("flappy", "anotherfilepath") mStore = MapStore() mStore.add(m) mStore.add(n) #Act and Assert self.assertIsNone(mStore.get("tappy"))
def test_get(self): #Arrange m = Map("mappy", "somefilepath") n = Map("flappy", "anotherfilepath") mStore = MapStore() mStore.add(m) mStore.add(n) #Act and Assert self.assertEquals(m, mStore.get("mappy"))
def game_update(self, data, *args): """ Update """ self.update_count += 1 if not self.map: self.map = Map(data, self.player_index) return self.map.update(data) # Source. largest_army = self.map.get_largest_owned_army() source = largest_army # Destination. dest = None if (self.map.general_tiles): dest = self.map.get_closest_enemy_general_tile(largest_army) elif (self.map.enemy_tiles): dest = self.map.get_closest_enemy_tile(largest_army) elif (self.map.empty_tiles): dest = self.map.get_closest_empty_tile(largest_army) # Next attack. path = self.map.construct_path(largest_army, dest) attack_dest = None if path: attack_dest = path[0] # Send attack command. self.attack(self.map.coord_to_index(source, self.map.width), self.map.coord_to_index(attack_dest, self.map.width), False) #Print to console. self.map.print_everything() if path: print("Moving from " + str(source) + " to " + str(attack_dest) + " towards " + str(dest)) else: print("Moving from " + str(source) + " towards " + str(dest)) print("Path: " + str(path)) print("Generals: " + str(self.map.generals)) # Log to file. self.file.write("Turn " + str(self.update_count) + "\n") if path: self.file.write("Path: " + str(path)) self.file.write("Source: " + str(source) + ", To: " + str(attack_dest) + "\n") self.file.write("Moving toward: " + str(dest) + "\n") else: self.file.write("THERE ARE NO PATH PLEASE TAKE A LOOK") self.file.write("Source: " + str(source) + ", Dest: " + str(dest) + "\n") self.file.write("\n-------------------\n")
def init(self, sub, priorities): self.final_price = 0 self.price_for_sub = {} self.priority_pixels_for_sub = {} self.sub = sub self.priorities = priorities self.config_map = Map() self.output_map = Map() print("sub:", self.sub) self.config_map = self.sub[SubConsts.BASIC_LANDUSE_MAP].map self.build_basic_map_for_output_map() self.extra_volume_left = self.sub[SubConsts.EXTRA_VOLUME] self.as_extra_volume_left = 0
def test_list_all(self): # Arrange mp1 = Map("Test map 1", "") mp2 = Map("Test map 2", "") store = MapStore() store.add(mp1) store.add(mp2) # Act act = store.list_all() #Assert self.assertEqual(act, ["Test map 1", "Test map 2"])
def setup_spritemap(self): sheet = SpriteSheet("img/magecity_64p.png", 64, (0,0), (8,44)) self.men_list = sum(sheet.image_list, []) length = len(self.men_list) size = (10, int(length/10)) menu = Map("Palette", self, self.size, size, self.block, self.empty_tile) menu.setup(WHITE) for i, tile in enumerate(menu.group): tile.filename = "{}".format(i) tile.image = self.men_list[i] if i+1 >= length: break return menu
def setup(): global screen, game_controller, input_controller, main_tileset, map_level_1, player # Initializes pygame pygame.init() # Initializes the screen screen = pygame.display.set_mode(constants.SCREEN_SIZE, pygame.DOUBLEBUF) # Initializes the game controllers game_controller = GameController() input_controller = InputController() # Load the sprites main_tileset = Tileset(constants.FILEPATH_TILESET_MAIN, constants.TILESIZE) # Load the maps map_level_1 = Map() map_level_1.load_background(constants.FILEPATH_LEVEL1_BACKGROUND, main_tileset) map_level_1.load_foreground(constants.FILEPATH_LEVEL1_FOREGROUND, main_tileset) map_level_1.load_colliders(constants.FILEPATH_LEVEL1_COLLIDERS, main_tileset) # Load the player player = Player(constants.FILEPATH_CHARSET)
def generate_map(cls, taken_spaces_map, room_positions, height, width): res = Map(height, width) for coordinates, room in room_positions: MapGen.place_room(res, room, coordinates) for x, line in enumerate(taken_spaces_map): for y, space_type in enumerate(line): if space_type == 3: res.tile_map[x][y].terrain = ASSETS.get_asset( 'tiles', 'base_floor') elif space_type in [0, 2, 4]: res.tile_map[x][y].terrain = ASSETS.get_asset( 'tiles', 'base_wall') res.reload_fov_map() return res
def test_remove_map_exception(self): #Arrange m = Map("mappy", "somefilepath") n = Map("flappy", "anotherfilepath") mStore = MapStore() mStore.add(m) mStore.add(n) mStore.remove(m) #Act and Assert with self.assertRaises(Exception): mStore.remove(m)
def __init__(self, size): Template.__init__(self, size) self.name = "World Editor 1.1" self.size = size self.block = 32 self.dt = 0. self.empty_tile = pg.image.load("./tiles/Empty_tile_32p.png").convert_alpha() self.map_bg = Map("Background", self, self.size, (120,80), self.block, self.empty_tile) self.map_mg = Map("Middleground", self, self.size, (120,80), self.block, self.empty_tile) self.map_fg = Map("Foreground", self, self.size, (120,80), self.block, self.empty_tile) self.poi_map = Map("POI Map", self, self.size, (120,80), self.block, self.empty_tile) self.poi_menu = Map("POI Menu", self, self.size, (4,1), self.block, self.empty_tile) self.menus = [Map("Menu", self, self.size, (2,14), self.block, self.empty_tile)] self.pal_menu = Menu((128, 40), (0,21)) self.pal_menu.add_buttons(2, ["New", "Pal-1"]) self.pal_menu.set_bg_color(SUBBUTTON_COLOR) self.menu = self.menus[0] self.menu.xy[1] += 20 self.men_list = [] self.sprite_map = self.setup_spritemap() self.sprite_map.xy = [250,0] self.clip = pg.Rect(0,0, self.size[0],self.size[1]) self.c_pos = self.clip.topleft self.show_full_map = False self.show_poi = False self.full_map = None self.current_tile = None self.current_menu = None self.ground_state = None self.right_m_pos = None self.right_m_button = False self.fill = False self.m_pos = None self.m_select_rect = pg.Rect(1,1,1,1) self.menu_button = Button((120, 20), (129,1), "Menu") self.pal_button = Button((128,20), (0,0), "Palette") self.drop_menu = Menu((120, 160), (129, 21)) self.drop_menu.add_buttons(5, ["Save", "Load", "Sprites", "See Map", "Info"]) self.drop_menu.set_bg_color(SUBBUTTON_COLOR) self.load_menu = self.setup_loadmenu() self.floating_text = FloatingText("no text", self.size) self.info_panel = Panel((self.size[0] - self.size[0]/3, self.size[1] - self.size[1]/3), (self.size[0]/6, self.size[1]/6)) self.info_panel.setup_text([self.name, "Made by Aurelio Aguirre", "", "Use WASD to move around.", "Use E to toggle the Foreground.", "Use R to toggle the Middleground.", "Use Q to toggle the Point of Interest map."]) self.setup() self.setup_poi() self.selected_map = self.map_bg self.alternative = ALTERNATIVE_MODE self.enable_alternative_mode()
def reset(keep_player=False): global SCREEN_SIZE, RANDOM_SEED, MAP, PLAYER RANDOM_SEED += 1 UI.clear_all() TurnTaker.clear_all() if keep_player: PLAYER.refresh_turntaker() PLAYER.levels_seen += 1 else: if not PLAYER is None: print("Game Over") print("%d evidence in %d turns; %d levels seen" %(len(PLAYER.evidence),PLAYER.turns,PLAYER.levels_seen)) PLAYER = Player() if not MAP is None: MAP.close() del MAP MAP = Map.random(RANDOM_SEED,SCREEN_SIZE-(0,4),PLAYER) MAP.generate()
def hydrology(self, **runoff_landa): self.output_hyrology = Map() if (runoff_landa.get("runoff_co_map", default=None) is None & runoff_landa.get("landa_map", default=None) is None): print("you have to give at least 1 map from runoff or landa !") else: if (runoff_landa.get("runoff_co_map", default=None) is not None) and ( runoff_landa.get("landa_map", default=None) is not None): runoff_coefficient_map_ascii = runoff_landa.get("runoff_co_map") self.landa_map = runoff_landa.get("landa_map") self.runoff_coefficient_map = map_loader.load_map(RunoffCoefficient, runoff_coefficient_map_ascii) runoff_coefficient_map = self.runoff_coefficient_map.map for i in range(len(self.runoff_coefficient_map.matrix)): self.output_hyrology.matrix.append([]) for j in range(len(self.runoff_coefficient_map.matrix[i])): if self.runoff_coefficient_map.matrix[i][j] != runoff_coefficient_map.no_data_value: self.output_hyrology.matrix[i].append( self.runoff_coefficient_map.matrix[i][j] + self.landa_map.matrix[i][j]) else: self.output_hyrology.matrix[i].append(runoff_coefficient_map.no_data_value) else: if runoff_landa.get("runoff_co_map", default=None) is not None: self.output_hyrology = self.runoff_coefficient_map if runoff_landa.get("landa_map", default=None) is not None: self.output_hyrology = self.landa_map return self.output_hyrology
def reset(keep_player=False): global SCREEN_SIZE, RANDOM_SEED, MAP, PLAYER RANDOM_SEED += 1 UI.clear_all() TurnTaker.clear_all() if keep_player: PLAYER.refresh_turntaker() PLAYER.levels_seen += 1 else: if not PLAYER is None: print("Game Over") print("%d evidence in %d turns; %d levels seen" % (len(PLAYER.evidence), PLAYER.turns, PLAYER.levels_seen)) PLAYER = Player() if not MAP is None: MAP.close() del MAP MAP = Map.random(RANDOM_SEED, SCREEN_SIZE - (0, 4), PLAYER) MAP.generate()
def test_list_all(self): #Arrange m = Map("mappy", "somefilepath") n = Map("flappy", "anotherfilepath") mStore = MapStore() mStore.add(m) mStore.add(n) #Act and Assert listy = [] for i in mStore.list_all(): listy.append(mStore.get(i)) self.assertIn(m, listy) self.assertIn(n, listy)
def init_map(map_name): """Initialize map Creates Map object, game window, sets references and globals and adds character. """ global screen global tile_size global diagonal_move map = Map(map_name, tile_size, menu_height, diagonal_movement=diagonal_move) map_size = map.get_size() create_screen(map_size) map.set_screen(screen) set_current_map(map) add_character()
def loadmap(self, filename): load = LoadMap(filename) maplist = [] for m in load.maps.values(): a_map = Map(m["info"]["name"], self, m["info"]["size"], m["info"]["grid"], m["info"]["block"], self.empty_tile) if m["info"]["name"] == "Foreground" or m["info"]["name"] == "Middleground": a_map.setup(m["info"]["color"], 200) elif m["info"]["name"] == "POI Map": a_map.setup(m["info"]["color"], 150) else: a_map.setup(m["info"]["color"]) for t in a_map.group: for i in m["tiles"]: if list(t.rect.topleft) in m["tiles"][i]: t.filename = i if i[0] == "P": t.image = self.poi_dict[i] t.dirty = 1 else: t.image = self.men_list[int(i)] t.dirty = 1 maplist.append(a_map) for j in maplist: if j.name == "Background": self.map_bg = j if j.name == "Middleground": self.map_mg = j if j.name == "Foreground": self.map_fg = j if j.name == "POI Map": self.poi_map = j print("Loading from file...")
def next_map(self): maps = glob('maps/*json') try: selected = maps[maps.index(self.selected_map) + 1] except (IndexError, ValueError): selected = maps[0] self.selected_map = selected settings.setValue('map', self.selected_map) return Map.read_spec(selected)['title']
def loadmaps(self): f = open('data/justrightmaps.yaml', 'r') dirtymaps = yaml.load(f, Loader=yaml.FullLoader)['Maps'] pprint(dirtymaps) f.close() self.maps = {} for M in dirtymaps: MP = Map(M, dirtymaps[M]) self.maps[M] = MP
def test_add_success(self): # Arrange mp = Map("Test map", "") store = MapStore() # Act store.add(mp) # Assert self.assertEqual(store.get("Test map"), mp)
def test_add_map_exception(self): #Arrange m = Map("mappy", "somefilepath") mStore = MapStore() mStore.add(m) #Act and Assert with self.assertRaises(Exception): mStore.add(m)
def get(self): mid = long(self.request.get('mid')) m = Map.get_by_id(mid) g = Game(mid=mid) g.put() gid = g.key().id() result = m.populate(gid) self.response.out.write(str(gid))
def test_get_success(self): # Arrange mp = Map("Test map", "") store = MapStore() store.add(mp) # Act act = store.get("Test map") # Assert self.assertEqual(act, mp)
def __init__(self, *args, **kwargs): QDeclarativeView.__init__(self, *args, **kwargs) context = self.rootContext() context.setContextProperty('menu', self) map_file = settings.value('map') if not map_file: map_file = glob('maps/*json')[0] self.selected_map = map_file self.setSource('menu.qml') self.setResizeMode(QDeclarativeView.SizeRootObjectToView) self.rootObject().initial_map(Map.read_spec(map_file)['title'])
def main(screen): init_curses(screen) game_map = Map("map1") player = Player(game_map) textures = ["wall1", "wall2", "dragon", "tree"] Controller(Renderer(screen, player, textures)).start() curses.flushinp() curses.endwin()
def test_remove_success(self): # Arrange mp = Map("Test map", "") store = MapStore() store.add(mp) # Act store.remove(mp) # Assert self.assertEqual(store.list_all(), [])
class TestMaps(unittest.TestCase): def setUp(self): Map.json_file = 'test_maps.json' self.test_data = Map('test_map', 32, 32) def test_load_map_from_json(self): loaded_test_map = self.test_data.load_map_from_json() self.assertEqual((16 * 16), len(loaded_test_map) * len(loaded_test_map[0])) self.assertEqual(loaded_test_map[0][0].movement_cost, 0) self.assertEqual(loaded_test_map[10][8].movement_cost, 10)
def add_map(self, model, subject): m = Map(subject.uri) statement = RDF.Statement(subject, RDF.Uri("http://www.w3.org/2000/01/rdf-schema#domain"), None) for s in model.find_statements(statement): if s.object.is_resource(): m.domain = str(s.object.uri) statement = RDF.Statement(subject, RDF.Uri("http://www.w3.org/2000/01/rdf-schema#range"), None) for s in model.find_statements(statement): if s.object.is_resource(): m.range = str(s.object.uri) statement = RDF.Statement(subject, RDF.Uri("http://okfnpad.org/flow/0.1/sparql"), None) for s in model.find_statements(statement): if s.object.is_literal(): m.sparql = s.object.literal_value['string'] statement = RDF.Statement(subject, RDF.Uri("http://okfnpad.org/flow/0.1/sparql-not"), None) for s in model.find_statements(statement): if s.object.is_literal(): m.sparql = s.object.literal_value['string'] m.sparql_negate = 1 statement = RDF.Statement(subject, RDF.Uri("http://okfnpad.org/flow/0.1/assumption"), None) for s in model.find_statements(statement): if s.object.is_literal(): m.assumption = s.object.literal_value['string'] # Add it in the list only if completed if m.is_completed(): self.maps.append(m)
def __init__(self): super(GameController, self).__init__() self.selectedUnits = [] # Stores units that have been selected self.map = Map(os.path.join("maps", "level1.map")) self.map.draw_map() self.cm = collision_model.CollisionManagerGrid( 0.0, self.map.w * CELL_SIZE, 0.0, self.map.h * CELL_SIZE, 32.0, 32.0) self.map.cm = self.cm self.scroller = ScrollingManager(viewport=director.window) self.scroller.add(self.map) # Arbitrary starting location. I suggest this is info be stored in each map file. self.scroller.set_focus((self.map.w * CELL_SIZE) / 16, (self.map.h * CELL_SIZE) / 16) self.infoLayer = InfoLayer(self.map, self.scroller, None) self.statusMenu = StatusMenu() self.add(self.infoLayer) self.curAction = None self.level = 1 self.tutorial = Tutorial(self.level, self) self.horizontalSize = CELL_SIZE * self.map.w self.verticalSize = CELL_SIZE * self.map.h # self.mouseClickGraphic = Sprite(os.path.join("images", "menus", # "mouse_click_graphic.png")) #Handshake self.is_shake_selected = False self.source_handshake = None self.handshake_units_selected = [] if self.horizontalSize < WINDOW_WIDTH: self.horizontalSize = WINDOW_WIDTH if self.verticalSize < WINDOW_HEIGHT: self.verticalSize = WINDOW_HEIGHT
def set_map(self, map_path): self.map_path = map_path self.old_cp = None self.game = Game(self) self.map = Map(self.game, map_path) self.map.failed.connect(self.sound.boom) self.map.failed.connect(self.failed) self.map.finished.connect(self.sound.win) self.rootObject().set_map_name(self.map.title) if hasattr(self, 'robot'): self.rootObject().robot_to_active_pos(*self.robot.position) self.draw_map() if self.map.background: self.rootObject().set_custom_background(self.map.background) self.map.finished.connect(self.win) if getattr(self, 'rt', None): self.rt.quit() try: self.robot.stop = True except AttributeError: pass self.rt = RoboThread() self.rt_pool.append(self.rt)
class GameApp(QDeclarativeView): block_tpls = { Block: 'blocks/block.qml', Bomb: 'blocks/bomb.qml', Space: 'blocks/space.qml', } #current = 'blocks/active.qml' mega_start = Signal() def __init__(self, menu, settings, *args, **kwargs): QDeclarativeView.__init__(self, *args, **kwargs) self.exception = None self.sound = Sounder() self.menu = menu self.settings = settings self.rt_pool = []#fix fault self.setWindowTitle('findZbomb!') self.setSource('interface.qml') self.set_map(None) self.redraw() context = self.rootContext() context.setContextProperty('obj', self) self.mega_start.connect(self._mega_start) self.setResizeMode(QDeclarativeView.SizeRootObjectToView) code = self.settings.value('code') if code: self.rootObject().set_code(code) def set_map(self, map_path): self.map_path = map_path self.old_cp = None self.game = Game(self) self.map = Map(self.game, map_path) self.map.failed.connect(self.sound.boom) self.map.failed.connect(self.failed) self.map.finished.connect(self.sound.win) self.rootObject().set_map_name(self.map.title) if hasattr(self, 'robot'): self.rootObject().robot_to_active_pos(*self.robot.position) self.draw_map() if self.map.background: self.rootObject().set_custom_background(self.map.background) self.map.finished.connect(self.win) if getattr(self, 'rt', None): self.rt.quit() try: self.robot.stop = True except AttributeError: pass self.rt = RoboThread() self.rt_pool.append(self.rt) def draw_map(self): #grid = self.rootContext().contextProperty('mapGrid') root = self.rootObject() prepared_map = map(lambda items: map(lambda item: self.block_tpls[type(item)], items), self.map.map) root.draw_map(prepared_map) self.rootObject().robot_to_active_pos(*self.map.position) #print grid def redraw(self): if self.old_cp != self.map.cur_position: #self.draw_map() self.old_cp = self.map.cur_position if hasattr(self, 'robot'): self.rootObject().set_map_count(self.robot.moves) self.rootObject().robot_to_active_pos(*self.robot.position) if self.exception: if hasattr(self, 'robot'): self.robot.stop = True self.rootObject().show_exception(unicode(self.exception)) self.exception = None QTimer.singleShot(300, self.redraw) @Slot(result=int) def start(self): self.set_map(self.map_path) self.rootObject().remove_notify() self.code = 'class Robot(BaseRobot):\n%s' % self.rootObject().get_code() self.mega_start.emit() return 0 @Slot() def _mega_start(self): self.rt.start() def _start(self): Robot = BaseRobot#fix code highlighting self.exception = None try: exec(self.code) self.robot = Robot(self.map) self.map.put_robot(self.robot) self.rootObject().robot_to_active_pos(*self.robot.position) except Exception, e: self.exception = e
from player import * # Constants TILE_SIZE = 32 INCREMENT_DISTANCE = 4 # By how much the coordinates change every frame. # Runtime variables clock = pygame.time.Clock() # Resource variables FPS = 20 x_size = 9 # Should always be odd, so that the player is in the dead middle y_size = 9 screen = pygame.display.set_mode((x_size * TILE_SIZE, y_size * TILE_SIZE)) player_coords = (x_size / 2 * TILE_SIZE, y_size / 2 * TILE_SIZE) grid = Map("map", (x_size, y_size)) grid.display(screen) pygame.display.update() p = Player() p.initialize_frames() pressed = {} pressed["up"] = False pressed["down"] = False pressed["left"] = False pressed["right"] = False locked = False
class GameController(Layer, EventDispatcher): is_event_handler = True def __init__(self): super(GameController, self).__init__() self.selectedUnits = [] # Stores units that have been selected self.map = Map(os.path.join("maps", "level1.map")) self.map.draw_map() self.cm = collision_model.CollisionManagerGrid( 0.0, self.map.w * CELL_SIZE, 0.0, self.map.h * CELL_SIZE, 32.0, 32.0) self.map.cm = self.cm self.scroller = ScrollingManager(viewport=director.window) self.scroller.add(self.map) # Arbitrary starting location. I suggest this is info be stored in each map file. self.scroller.set_focus((self.map.w * CELL_SIZE) / 16, (self.map.h * CELL_SIZE) / 16) self.infoLayer = InfoLayer(self.map, self.scroller, None) self.statusMenu = StatusMenu() self.add(self.infoLayer) self.curAction = None self.level = 1 self.tutorial = Tutorial(self.level, self) self.horizontalSize = CELL_SIZE * self.map.w self.verticalSize = CELL_SIZE * self.map.h # self.mouseClickGraphic = Sprite(os.path.join("images", "menus", # "mouse_click_graphic.png")) #Handshake self.is_shake_selected = False self.source_handshake = None self.handshake_units_selected = [] if self.horizontalSize < WINDOW_WIDTH: self.horizontalSize = WINDOW_WIDTH if self.verticalSize < WINDOW_HEIGHT: self.verticalSize = WINDOW_HEIGHT def on_enter(self): super(GameController, self).on_enter() # TODO: this will at somepoint be an array of players # but it will go in the server code for multiplayer self.player = Player(0, self.map, self.cm, PLAYER_COLORS[0]) self.player.setup( ) # Adds starting troops/buildings/research from the map file. self.ai = ComputerPlayer( 1, self.map, self.cm, PLAYER_COLORS[1], self.player) self.ai.setup( ) # Adds starting troops/buildings/research from the map file. self.players = [self.player, self.ai] self.infoLayer.player = self.player.ID self.ai.run_basic_ai() # tutorial stuff if SHOW_TUTORIAL: self.tutorial.first_prompt("on_enter") self.player.push_handlers( self.tutorial.player_add_troop, self.tutorial.player_unit_attack, self.tutorial.player_add_building) self.push_handlers( self.tutorial.click_on_move, self.tutorial.click_on_action) self.player.push_handlers(self.on_loss) self.ai.push_handlers(self.on_loss) for player in self.players: self.schedule(player.step) self.schedule(self.step) self.bindings = { # key constant : button name key.LEFT: 'left', key.RIGHT: 'right', key.UP: 'up', key.DOWN: 'down' } self.buttons = { # button name : current value, 0 not pressed, 1 pressed 'left': 0, 'right': 0, 'up': 0, 'down': 0 } self.mouse_flag = { 'x': 0, 'y': 0 } def on_loss(self, loser): if loser.ID == 0: director.push(Scene(self.lost)) else: director.push(Scene(self.won)) def step(self, dt): # step is called every frame if self.mouse_flag["x"] == 0 and self.mouse_flag["y"] == 0: # keyboard scrolling buttons = self.buttons move_dir = eu.Vector2(buttons['right'] - buttons['left'], buttons['up'] - buttons['down']) else: # mouse scrolling move_dir = eu.Vector2(self.mouse_flag['x'], self.mouse_flag['y']) newPos = move_dir.normalize() * dt * MAP_SCROLL_SPEED newx, newy = self.clamp(newPos) self.scroller.set_focus(newx, newy) def clamp(self, pos): x, y = pos newx = self.scroller.fx + x newy = self.scroller.fy + y if newx <= 1: newx = 1.0 elif newx >= self.horizontalSize - WINDOW_WIDTH: newx = self.horizontalSize - WINDOW_WIDTH + 1.0 if newy <= 1: newy = 1.0 elif newy >= self.verticalSize - WINDOW_HEIGHT: newy = self.verticalSize - WINDOW_HEIGHT + 1.0 return newx, newy def on_mouse_motion(self, x, y, dx, dy): # x,y = self.scroller.pixel_from_screen(x,y) if x == 0: self.mouse_flag["x"] = -1.0 self.mouse_flag["y"] = float(y - (WINDOW_HEIGHT / 2)) / WINDOW_HEIGHT elif x == WINDOW_WIDTH or x == WINDOW_WIDTH - 1: self.mouse_flag["x"] = 1.0 self.mouse_flag["y"] = float(y - (WINDOW_HEIGHT / 2)) / WINDOW_HEIGHT elif y == 0: self.mouse_flag["y"] = -1.0 self.mouse_flag["x"] = float(x - (WINDOW_WIDTH / 2)) / WINDOW_WIDTH elif y == WINDOW_HEIGHT or y == WINDOW_HEIGHT - 1: self.mouse_flag["y"] = 1.0 self.mouse_flag["x"] = float(x - (WINDOW_WIDTH / 2)) / WINDOW_WIDTH else: self.mouse_flag["x"] = 0 self.mouse_flag["y"] = 0 def on_key_press(self, k, modifiers): if k == key.ESCAPE: theme_player.fadeout() binds = self.bindings if k in binds: self.buttons[binds[k]] = 1 return True return False def on_key_release(self, k, m): # Determine the type of units we've selected so we can assign hotkeys # appropriately selType = None if len(self.selectedUnits) > 0: selType = type(self.selectedUnits[0]) actNum = None if selType != None and issubclass(selType, Troop): actNum = { key.A: 0, # A key.S: 1, # S key.D: 2 # D }.get(k, None) elif selType != None and issubclass(selType, Building): actNum = { key.Q: 7, # Q key.W: 3, # W key.E: 5, # E key.A: 1, # A key.D: 0, # D key.Z: 6, # Z key.X: 2, # X key.C: 4, # C }.get(k, None) if actNum != None: # Loop through selected units and execute action associated with # hotkey. for unit in self.selectedUnits: # Make sure this unit has the action we're trying to execute # with the hotkey if actNum < len(unit.actionList): # Execute the action. Also deselects the unit (all actions # automatically deselect) self.execute_action(unit.actionList[actNum], unit) # scrolling logic binds = self.bindings if k in binds: self.buttons[binds[k]] = 0 return True return False # def on_mouse_press(self, x, y, buttons, modifiers): # # Add the mouse down sprite to the map where the mouse was pressed. # x, y = self.scroller.pixel_from_screen(x, y) # self.mouseClickGraphic.position = euclid.Vector2(x, y) # self.map.add(self.mouseClickGraphic, z = 10) def on_mouse_release(self, x, y, buttons, modifiers): # Mouse clicked. Perform unit selection, check for button presses, and executes actions. # Check if we clicked the minimap - if so, don't perform any selection logic on units behind the map. # for i in range(1000,1,-0.25): # self.mouseClickGraphic.scale = 0.001 * i # self.map.remove(self.mouseClickGraphic) if self.statusMenu.cm.objs_touching_point(x,y): director.pop() if self.infoLayer.miniMapToggled: # First check to see if the minimap is toggled to save our CM from # checking collisions if the minimap isn't up. minimap = self.infoLayer.cm.objs_touching_point( x - self.infoLayer.position[0], y - self.infoLayer.position[1]) if self.infoLayer.miniMap in minimap: return x, y = self.scroller.pixel_from_screen(x, y) clicked_units = self.cm.objs_touching_point(x, y) for unit in clicked_units: if type(unit) == SurrenderButton: director.push(Scene(self.lost)) # Set selectedUnits. If a vertex is clicked on, all troops in the # vertex are selected/unselected if buttons == 1: # Left button clicked # Did we click on an action button? actionButton = get_action_button_clicked(clicked_units) if actionButton: # Clicked on an action button. Execute the action. self.execute_action(actionButton.name, actionButton.unitParent) elif clicked_units: if self.curAction: # Attack self.player.unit_attack(self.selectedUnits, clicked_units) self.curAction = None else: # If clicked on vertex or clicked on a single unit, switch # select state of all units in vertex self.select_units(clicked_units) if constants.SOUND: self.play_sound("click_troop.wav") # Move if clicked_units != set([]) and self.selectedUnits != []: if buttons == 4: # Button == 4 means right click # Perform move action. self.execute_move(clicked_units) return True def __deselect_units_of_type(self, units, unitType): # Deselect buildings if we're selecting Troops. unitsToDeselect = [] for unit in self.selectedUnits: if issubclass(type(unit), unitType): unitsToDeselect.append(unit) if unitsToDeselect != []: self.player.switch_units_select_state( unitsToDeselect, self.selectedUnits) def select_units(self, clicked_units): # Performs all selection logic. Sets the select state (inverts it) of # units that were just clicked on. if len(clicked_units) >= 1: clicked = None for item in clicked_units: if type(item) == Vertex: clicked = item break else: clicked = item #Handshake if type(clicked) == Handshake: #seeing if the shake action is enabled if(self.source_handshake != None): if self.source_handshake == clicked: self.is_shake_selected = False if self.is_shake_selected: #constructing a list of vids adjacency_vid_list = [] for vertex in self.source_handshake.curVertex.adjacentVertices: adjacency_vid_list.append(vertex.vid) #checking to see if edge exists already if clicked.curVertex.vid not in adjacency_vid_list: dest_handshake = clicked edge = self.source_handshake.shake(dest_handshake, self.map) self.cm.remove_tricky(self.source_handshake) self.cm.remove_tricky(dest_handshake) self.is_shake_selected = False self.source_handshake = None else: utils.play_sound("error.wav") self.player.switch_units_select_state( [clicked], self.selectedUnits) self.is_shake_selected = False pass else: self.is_shake_selected = False self.source_handshake = None if type(clicked) == Vertex: # Deselect all buildings if we're selecting troops. self.__deselect_units_of_type(self.selectedUnits, Building) self.player.switch_units_select_state( clicked.troops, self.selectedUnits) elif issubclass(type(clicked), Unit) and clicked.pid == 0: # Deselect all troops if we're selecting a building, and vice # versa. #TODO: use Dave's player building and troop action list instead if issubclass(type(clicked), Building): if type(clicked) == SoftwareUpdater: self.player.update_research_action_button(clicked) if type(clicked) == AlgorithmFactory: self.player.update_troop_action_button(clicked) self.__deselect_units_of_type(self.selectedUnits, Troop) elif issubclass(type(clicked), Troop): self.__deselect_units_of_type(self.selectedUnits, Building) self.player.switch_units_select_state( [clicked], self.selectedUnits) else: # More than one thing clicked on. Switch select state of all of # them. self.player.switch_units_select_state( clicked_units, self.selectedUnits) # We COULD change this so only the unit with the higehst Z value get selected. def execute_move(self, clickedUnits): # Moves the selected troops (self.selectedUnits) to the destination # vertex (which is in clickedUnits) dest = None while type(dest) != Vertex and clickedUnits != (): dest = clickedUnits.pop() if type(dest) == Vertex: for selectedUnit in self.selectedUnits: if issubclass(type(selectedUnit), Troop): if selectedUnit.player_move(dest, self.map, self.cm) == True and constants.SOUND: # If we successfully moved, play the move sound. self.play_sound("Move.wav") selectedUnit.set_is_selected(False, self.map, self.cm, self.player) self.selectedUnits = [] self.dispatch_event("click_on_move", type(selectedUnit), dest.vid) def execute_action(self, actionName, unit): # ActionButton <actionButton> clicked. Execute the action associated # with the button/building/vertex self.curAction = None # Need to add conditional to account for resource availability. self.player.switch_units_select_state([unit], self.selectedUnits) if actionName[0] == "B": # BUILD A BUILDING (also deselects the troop) if self.player.execute_build_building(actionName[1:], unit, self.selectedUnits) and constants.SOUND: self.play_sound("Clock.wav") elif actionName[0] == "T": # BUILD A TROOP (also deselects the building) if self.player.execute_build_troop(actionName[1:], unit, self.selectedUnits) and constants.SOUND: self.play_sound("Clock.wav") elif actionName[0] == "R": # RESEARCH if self.player.perform_research(actionName, unit, self.cm) and constants.SOUND: self.play_sound("Clock.wav") # BEGIN UPGRADES elif actionName == "USinkhole": unit.upgrade_to_sinkhole(self.player) elif actionName == "UPingOfDeath": unit.upgrade_to_pod(self.player) elif actionName == "UNMap": unit.upgrade_to_nmap(self.player) # BEGIN UTILITY #Handshake elif actionName == "Shake": self.is_shake_selected = True self.source_handshake = unit #if type(troop) == Handshake and troop != unit: #self.source_handshake = troop #print "GOT ME A TROOP TO SELECT" # Got the other selected handshake to shake with #self.source_handshake = troop #print self.source_handshake.pid #print "MY SELECTED HANDSHAKE",troop #unit.shake(troop) # PLAY HANDSHAKE SOUND #break elif actionName == "DEL": # TODO: we could have multple servers if issubclass(type(unit), Server): if self.player.numServers == 1: self.add_surrender_button(unit) if constants.SOUND: self.play_sound("Eraser.wav") self.player.on_destruction(unit, self.selectedUnits) elif actionName == "CANCEL": self.player.cancel_cpu(unit) elif actionName == "Encrypt": unit.encrypt(unit.curVertex.troops, self.player) elif actionName == "Decrypt": unit.decrypt(self.player) elif actionName == "Ping": unit.ping(self.player.on_destruction, self.map, self.cm) else: self.curAction = actionName # dummy array, because we don't want to change self.selectedUnit self.dispatch_event("click_on_action", actionName) def play_sound(self, filename): sound = pyglet.resource.media('sounds/' + filename, streaming=False) sound.play() # No image, crash game def add_surrender_button(self, actionButton): self.player.has_server = False x = actionButton.position[0] y = actionButton.position[1] surrender = SurrenderButton(x, y) self.map.add(surrender, z=10) self.cm.add(surrender)
from PySide.QtCore import QCoreApplication from maps import Map from robot import BaseRobot from game import Game import unittest import sys class Robot(BaseRobot): def on_start(self): self.go(self.RIGHT) def on_move(self, status): if status: self.go(self.RIGHT) print self.watch(self.RIGHT) if __name__ == "__main__": app = QCoreApplication(sys.argv) g = Game() m = Map(g) r = Robot(m) m.put_robot(r)
class Main(Template): def __init__(self, size): Template.__init__(self, size) self.name = "World Editor 1.1" self.size = size self.block = 32 self.dt = 0. self.empty_tile = pg.image.load("./tiles/Empty_tile_32p.png").convert_alpha() self.map_bg = Map("Background", self, self.size, (120,80), self.block, self.empty_tile) self.map_mg = Map("Middleground", self, self.size, (120,80), self.block, self.empty_tile) self.map_fg = Map("Foreground", self, self.size, (120,80), self.block, self.empty_tile) self.poi_map = Map("POI Map", self, self.size, (120,80), self.block, self.empty_tile) self.poi_menu = Map("POI Menu", self, self.size, (4,1), self.block, self.empty_tile) self.menus = [Map("Menu", self, self.size, (2,14), self.block, self.empty_tile)] self.pal_menu = Menu((128, 40), (0,21)) self.pal_menu.add_buttons(2, ["New", "Pal-1"]) self.pal_menu.set_bg_color(SUBBUTTON_COLOR) self.menu = self.menus[0] self.menu.xy[1] += 20 self.men_list = [] self.sprite_map = self.setup_spritemap() self.sprite_map.xy = [250,0] self.clip = pg.Rect(0,0, self.size[0],self.size[1]) self.c_pos = self.clip.topleft self.show_full_map = False self.show_poi = False self.full_map = None self.current_tile = None self.current_menu = None self.ground_state = None self.right_m_pos = None self.right_m_button = False self.fill = False self.m_pos = None self.m_select_rect = pg.Rect(1,1,1,1) self.menu_button = Button((120, 20), (129,1), "Menu") self.pal_button = Button((128,20), (0,0), "Palette") self.drop_menu = Menu((120, 160), (129, 21)) self.drop_menu.add_buttons(5, ["Save", "Load", "Sprites", "See Map", "Info"]) self.drop_menu.set_bg_color(SUBBUTTON_COLOR) self.load_menu = self.setup_loadmenu() self.floating_text = FloatingText("no text", self.size) self.info_panel = Panel((self.size[0] - self.size[0]/3, self.size[1] - self.size[1]/3), (self.size[0]/6, self.size[1]/6)) self.info_panel.setup_text([self.name, "Made by Aurelio Aguirre", "", "Use WASD to move around.", "Use E to toggle the Foreground.", "Use R to toggle the Middleground.", "Use Q to toggle the Point of Interest map."]) self.setup() self.setup_poi() self.selected_map = self.map_bg self.alternative = ALTERNATIVE_MODE self.enable_alternative_mode() def update(self, dt): self.dt = dt self.map_bg.update(dt) if not self.alternative: self.map_fg.update(dt) self.map_mg.update(dt) self.sprite_map.update(dt) self.menu.update(dt) self.poi_map.update(dt) self.poi_menu.update(dt) self.floating_text.update(dt) if self.drop_menu.buttons[0].active: self.savemap() self.drop_menu.buttons[0].active = False if self.drop_menu.buttons[2].active: self.selected_map = self.sprite_map else: self.selected_map = self.map_bg if not self.alternative: if self.pal_button.active: if self.pal_menu.clickinfo != None: if self.pal_menu.clickinfo == "New": self.new_palette() else: self.switch_palette(text=self.pal_menu.clickinfo) self.pal_menu.clickinfo = None if self.map_bg.clipped: self.map_fg.map.set_clip() self.map_mg.map.set_clip() self.poi_map.map.set_clip() self.map_bg.clipped = False if self.c_pos != self.clip.topleft: self.c_pos = (self.c_pos[0] - self.map_bg.xy[0], self.c_pos[1] - self.map_bg.xy[1]) self.clip.topleft = self.c_pos self.menu_button.update(self.dt) self.mouse_select() def draw(self): self.screen.fill(BLACK) # MAPs # Background self.map_bg.draw(self.screen, self.clip) if not self.alternative: # Middleground if self.ground_state == "MG": self.map_mg.xy = self.map_bg.xy self.map_mg.draw(self.screen, self.clip) # Foreground if self.ground_state == "FG": self.map_fg.xy = self.map_bg.xy self.map_fg.draw(self.screen, self.clip) # POI Map if self.show_poi: self.poi_map.xy = self.map_bg.xy self.poi_map.draw(self.screen, self.clip) # GUI if not self.alternative: self.menu.draw(self.screen) if self.show_poi: self.poi_menu.draw(self.screen) self.menu_button.draw(self.screen) if not self.alternative: self.pal_button.draw(self.screen) if self.menu_button.active: self.drop_menu.draw(self.screen) if self.pal_button.active: self.pal_menu.draw(self.screen) if self.drop_menu.buttons[1].active: self.load_menu.draw(self.screen) if self.drop_menu.buttons[2].active: self.sprite_map.draw(self.screen) if self.right_m_button: screen_rect = self.m_select_rect.copy() screen_rect.x += self.map_bg.xy[0] screen_rect.y += self.map_bg.xy[1] pg.draw.rect(self.screen, WHITE, screen_rect, 1) if self.show_full_map: if self.full_map: self.screen.blit(self.full_map, (0,0)) self.info_panel.draw(self.screen) self.floating_text.draw(self.screen) ########################## Setup methods ####################################### def enable_alternative_mode(self): if self.alternative: bgimage = pg.image.load("./img/CI Main 128.png").convert_alpha() self.map_bg = Map("Static Image", self, self.size, (120,80), 128, bgimage) self.map_bg.setup(BG_COLOR, alt=True) self.alternative = True def setup_loadmenu(self): folder = Path("./save") filelist = [f.basename() for f in folder.files("*.sav")] amount = len(filelist) menu = Menu((240, amount*21), (250, 21)) menu.add_buttons(amount, filelist) menu.set_bg_color(WHITE) return menu def setup(self): self.map_bg.setup(BG_COLOR) self.map_fg.setup(FG_COLOR, 200) self.map_mg.setup(MG_COLOR, 200) self.menu.setup(PAL_COLOR) self.poi_map.setup(POI_MAP, alpha=150) self.poi_menu.setup(POI_MENU) def setup_poi(self): wall = pg.image.load("./tiles/Wall32.png").convert_alpha() door = pg.image.load("./tiles/Door32.png").convert_alpha() poi = pg.image.load("./tiles/POI32.png").convert_alpha() delete = pg.image.load("./tiles/Eliminate32.png").convert_alpha() self.poi_dict = OrderedDict((("Poi Wall", wall), ("Poi Door", door), ("Poi Symbol", poi), ("Delete", delete))) p = [i for i in self.poi_dict.keys()] for num, tile in enumerate(self.poi_menu.group): tile.image = self.poi_dict[p[num]] tile.rect = tile.image.get_rect() tile.rect.topleft = ((self.block*num), 1) tile.filename = p[num] tile.dirty = 1 xplace = self.size[0] - self.block*4 self.poi_menu.xy = [xplace, 1] def setup_spritemap(self): sheet = SpriteSheet("img/magecity_64p.png", 64, (0,0), (8,44)) self.men_list = sum(sheet.image_list, []) length = len(self.men_list) size = (10, int(length/10)) menu = Map("Palette", self, self.size, size, self.block, self.empty_tile) menu.setup(WHITE) for i, tile in enumerate(menu.group): tile.filename = "{}".format(i) tile.image = self.men_list[i] if i+1 >= length: break return menu #################### Key and Mouse Methods ##################################### def key_down(self, key): if key == K_ESCAPE: print("Quitting...") self.game_on == False self.end_game() if key == K_e: if self.ground_state == None or self.ground_state == "MG": self.ground_state = "FG" else: self.ground_state = None if key == K_r: if self.ground_state == None or self.ground_state == "FG": self.ground_state = "MG" else: self.ground_state = None if key == K_q: self.show_poi = not self.show_poi self.current_tile = None if key in (K_w, K_UP): self.selected_map.move["up"] = True if key in (K_a, K_LEFT): self.selected_map.move["left"] = True if key in (K_s, K_DOWN): self.selected_map.move["down"] = True if key in (K_d, K_RIGHT): self.selected_map.move["right"] = True def key_up(self, key): if key in (K_w, K_UP): self.selected_map.move["up"] = False if key in (K_a, K_LEFT): self.selected_map.move["left"] = False if key in (K_s, K_DOWN): self.selected_map.move["down"] = False if key in (K_d, K_RIGHT): self.selected_map.move["right"] = False def mouse_down(self, button, pos): not_menu = True if button == 1: # First we check for the unique states, Info Panel and Full Map. if not self.info_panel.display: if not self.show_full_map: # Now we check for menu buttons being clicked, and switch our # not_menu switch if they are. From here the rest is handled by update. if self.menu_button.click(pos): not_menu = False elif self.pal_button.click(pos): not_menu = False if self.menu_button.active: if self.drop_menu.click(pos): not_menu = False if self.pal_button.active: if self.pal_menu.click(pos): not_menu = False # Assuming we are in our main menu we check for the the buttons being clicked. # This part is allowed to happen WHILE maps are also being manipulated. (not_menu is not switched) if self.drop_menu.buttons[1].active: if self.load_menu.click(pos): self.loadmap(self.load_menu.clickinfo) elif self.drop_menu.buttons[3].active: self.show_map() self.drop_menu.buttons[3].active = False elif self.drop_menu.buttons[4].active: self.info_panel.display_panel() self.drop_menu.buttons[4].active = False # Here we look for our Maps. Basically we are moving a tile from one map to another. # We just need to pick the right one, and they should all overwrite each other. # In other words, only one map is active at a time. if not_menu: if self.drop_menu.buttons[2].active: # Tiles are showing. self.find_tile(pos, self.sprite_map, self.menu) elif self.show_poi: # POI Map is up. self.find_tile(pos, self.poi_menu, self.poi_map) elif self.ground_state == "FG": # we are on the Foreground map. self.find_tile(pos, self.menu, self.map_fg) elif self.ground_state == "MG": # We are on the middleground map. self.find_tile(pos, self.menu, self.map_mg) else: # We default to the Background map. self.find_tile(pos, self.menu, self.map_bg) else: # While the full map is up, any left mouse click will deactivate it. self.show_full_map = False else: self.info_panel.click(pos) if button == 3: if not self.show_full_map: self.right_m_button = True self.right_m_pos = pos else: self.take_image(self.full_map) def mouse_up(self, button, pos): if button == 3: self.right_m_button = False self.right_m_pos = pos new_rect = self._invert_rect(self.m_select_rect) if self.show_poi: self.group_select(new_rect, self.poi_map.group) elif self.ground_state == "FG": self.group_select(new_rect, self.map_fg.group) elif self.ground_state == "MG": self.group_select(new_rect, self.map_mg.group) else: self.group_select(new_rect, self.map_bg.group) def mouse_motion(self, button, pos, rel): self.m_pos = pos def mouse_select(self): if self.right_m_button: old_pos = (self.right_m_pos[0] - self.map_bg.xy[0], self.right_m_pos[1] - self.map_bg.xy[1]) new_pos = (self.m_pos[0] - self.map_bg.xy[0], self.m_pos[1] - self.map_bg.xy[1]) self.m_select_rect = pg.Rect(1,1,1,1) xoff, yoff = new_pos[0] - old_pos[0], new_pos[1] - old_pos[1] self.m_select_rect.inflate_ip(xoff, yoff) self.m_select_rect.topleft = old_pos def _invert_rect(self, rect): new_rect = pg.Rect(1,1,1,1) new_rect.size = rect.size if rect.width < 0: new_rect.width *= -1 if rect.height < 0: new_rect.height *= -1 if rect.left > rect.right: new_rect.left = rect.right else: new_rect.left = rect.left if rect.top > rect.bottom: new_rect.top = rect.bottom else: new_rect.top = rect.top return new_rect ###################### Button Activated Methods ################################ def group_select(self, rect, group): for sprite in group: if sprite.rect.colliderect(rect): self.change_tile(sprite) def find_tile(self, pos, menu, bg_map): found = False for tile in menu.group: map_pos = (pos[0] - menu.xy[0], pos[1] - menu.xy[1]) if tile.rect.collidepoint(map_pos): found = True menu.fill = True menu.select_rect(tile.rect) menu.draw_border = True self.current_tile = tile self.current_menu = menu.name if found: break if not found: for tile in bg_map.group: map_pos = (pos[0] - bg_map.xy[0], pos[1] - bg_map.xy[1]) if tile.rect.collidepoint(map_pos): self.change_tile(tile) bg_map.clear_map() return found def change_tile(self, tile): if self.current_tile != None: if self.current_tile.filename != "Delete": tile.filename = self.current_tile.filename tile.image = self.current_tile.image tile.dirty = 1 else: print("Removing Tile!") tile.filename = "Empty_tile" tile.image = self.empty_tile tile.dirty = 1 def new_palette(self): self.menus.append(Map("Menu", self, self.size, (2,14), self.block, self.empty_tile)) self.menus[-1].setup(WHITE) size = self.pal_menu.size self.pal_menu.change_size((size[0], size[1]+20)) num = len(self.menus) self.pal_menu.add_buttons(1, ["Pal-{}".format(num)]) self.switch_palette(ind=-1) def switch_palette(self, ind=None, text=None): if ind: self.menu = self.menus[ind] elif text: self.menu = self.menus[int(text[-1])-1] # <-------This Needs adjustment, needs to differentiate between Layers--------> def show_map(self): full_map = pg.Surface((40*64, 40*64)) for tile in self.map_bg.group: full_map.blit(tile.image, tile.rect.topleft) for tile in self.map_mg.group: if tile.filename != "Empty_tile": full_map.blit(tile.image, tile.rect.topleft) for tile in self.map_fg.group: if tile.filename != "Empty_tile": full_map.blit(tile.image, tile.rect.topleft) self.full_map = pg.transform.smoothscale(full_map, self.size) self.show_full_map = True def take_image(self, surf): folder = Path("./image") amount = len(folder.files("*.jpg")) filename = "{}{}{}{}".format(folder, "/map", amount, ".jpg") pg.image.save(surf, filename) def savemap(self): if not self.alternative: saving = SaveMap() saving.add_map(self.map_bg) saving.add_map(self.map_mg) saving.add_map(self.map_fg) saving.add_map(self.poi_map) saving.write_to_file() else: saving = SaveMap() saving.add_map(self.poi_map) saving.write_to_file() def loadmap(self, filename): load = LoadMap(filename) maplist = [] for m in load.maps.values(): a_map = Map(m["info"]["name"], self, m["info"]["size"], m["info"]["grid"], m["info"]["block"], self.empty_tile) if m["info"]["name"] == "Foreground" or m["info"]["name"] == "Middleground": a_map.setup(m["info"]["color"], 200) elif m["info"]["name"] == "POI Map": a_map.setup(m["info"]["color"], 150) else: a_map.setup(m["info"]["color"]) for t in a_map.group: for i in m["tiles"]: if list(t.rect.topleft) in m["tiles"][i]: t.filename = i if i[0] == "P": t.image = self.poi_dict[i] t.dirty = 1 else: t.image = self.men_list[int(i)] t.dirty = 1 maplist.append(a_map) for j in maplist: if j.name == "Background": self.map_bg = j if j.name == "Middleground": self.map_mg = j if j.name == "Foreground": self.map_fg = j if j.name == "POI Map": self.poi_map = j print("Loading from file...")
class Interface(): """ """ def __init__(self, level, bg_color, pygame): """ Initialize the game's interface """ # Setup variables self._level = level self._pygame = pygame self._bg_color = bg_color #Start in player 1 move mode self.mode = Modes.Move # Load the level information # This method also initialize the screen size # according to the map size self._loadLevel() #Load all the sounds self.sound_controller = SoundsController() # The status bar self.status_bar = pygame.Rect(0, self._map_resolution[1], self._screen_resolution[0], STATUS_BAR_HEIGHT) # The power bar self.power_bar = pygame.Rect(COLUMN_WIDTH + (COLUMN_WIDTH - 100)/2 , self._map_resolution[1] + 80, 100, POWER_BAR_HEIGHT) self.power_outline = self.power_bar.copy() self.power_outline.w -= 1 self.power_outline.h -= 1 #Set friendly fire self.friendly_fire = True # Current power self.current_power = 20 self.current_power_increasing = True #Initialize tanks self.p1_tank = Tank([70, 560], 1) self.p2_tank = Tank([1110, 560], 2) #Initilize turn number self.turn = 1 #The first one to play is random (not always player 1) self.players_turn = randrange(2)+1 #Set the number of turns self.num_teams = 2 #Load the map information self._map = Map(level, bg_color) #Initialize the screen self._windowSurfaceObj = pygame.display.set_mode(self._screen_resolution) self._windowSurfaceObj.fill(bg_color) self._map.paintMountain(self._windowSurfaceObj) self.draw_bar() self.draw_tank(self.p1_tank) self.draw_tank(self.p2_tank) def _loadLevel(self): """ Load the level information """ #gets the filename filename = "maps/" + self._level + ".lvl" map_file = open(filename, 'r') # Move up to the line with the size of the map line = map_file.readline() while line.find("Size: ") < 0: line = map_file.readline() if line == "": raise Exception ("Expected Map Size.") # Get the size of the map line = line.lstrip("Size: ") line = line.strip() size = line.split('x') map_width, map_height = size map_width = int(map_width) map_height = int(map_height) # Move up to the line with the tank area line = map_file.readline() while line.find("TankArea: ") < 0: line = map_file.readline() if line == "": raise Exception ("Expected Tank Area.") # Get the size of the map line = line.lstrip("TankArea: ") self._tank_area = line.strip() self._map_resolution = (map_width, map_height) self._screen_resolution = (map_width, map_height+STATUS_BAR_HEIGHT) def update(self): """ Update the interface. This method is called on every frame. """ #Update the display self._pygame.display.update() # draw the bar self.draw_bar() #Check if we are supposed to draw the shot if self.mode == Modes.Draw_Shot: if self.shot_path_index < len(self.shot_path): #Erase old bullet if self.shot_path_index > 0: pos = self.shot_path[self.shot_path_index-1] x = pos[0] y = pos[1] self.erase_shot(x,y) #Draw current shot position pos = self.shot_path[self.shot_path_index] x = pos[0] y = pos[1] #Check for bounds if x >= 0 and y >= 0 and x < self._map_resolution[0] and y < self._map_resolution[1]: #Get the circle inside the rectangle circle_rect = self.draw_shot(x,y) #Check if the shot hit an obstacle # For example: if it hit the mountain or a tank if self.shot_path_index > 2 and circle_rect.colliderect(self.p1_tank.get_rect()): self.erase_shot(x,y) self.finish_shot_firing(False, did_hit_team=1) elif self.shot_path_index > 2 and circle_rect.colliderect(self.p2_tank.get_rect()): self.erase_shot(x,y) self.finish_shot_firing(False, did_hit_team=2) elif self._map.didShotHitMountain(circle_rect, self.current_power, self._windowSurfaceObj): self.erase_shot(x,y) self.finish_shot_firing(True, pos=(x,y)) #Increase the index self.shot_path_index += 1 #If this is the last time, erase the shot elif self.shot_path_index == len(self.shot_path) and self.shot_path_index > 0: pos = self.shot_path[self.shot_path_index-1] x = pos[0] y = pos[1] self.erase_shot(x,y) self.finish_shot_firing(False) #Redraw both tanks (just in case the shot hit the tank) self.erase_tank(self.p1_tank) self.draw_tank(self.p1_tank) self.erase_tank(self.p2_tank) self.draw_tank(self.p2_tank) #If game over if self.mode == Modes.GameOver: #Call animation to destroy the tank self.explode_tank(self.enemy_team) def draw_bar(self): """ Draws the info bar on the bottom of the screen. """ #draw the background of the bar pygame.draw.rect(self._windowSurfaceObj, STATUS_BAR_COLOR, self.status_bar) #draw the outline of the bar outlineRect = self.status_bar.copy() outlineRect.w -= 1 outlineRect.h -= 1 pygame.draw.rect(self._windowSurfaceObj, OUTLINE_COLOR, outlineRect, 2) #draw lines between players information pygame.draw.line( self._windowSurfaceObj, OUTLINE_COLOR, (COLUMN_WIDTH, self._map_resolution[1]), (COLUMN_WIDTH, self._map_resolution[1]+STATUS_BAR_HEIGHT)) pygame.draw.line( self._windowSurfaceObj, OUTLINE_COLOR, (2*COLUMN_WIDTH, self._map_resolution[1]), (2*COLUMN_WIDTH, self._map_resolution[1]+STATUS_BAR_HEIGHT)) #draw player 1's information y = 0 y += 5 + self.draw_info_text('Player 1', MEDIUM_FONT, MEDIUM_FONT_SIZE, y, 0) y += self.draw_info_text('HP: {:10.1f}%'.format(self.p1_tank.get_hp_as_percentage()), FONT, FONT_SIZE, y, 0) y += self.draw_info_text('Angle: {:10.1f}°'.format(self.p1_tank.get_angle()), FONT, FONT_SIZE, y, 0) self.draw_info_text('Power: {:10.1f}%'.format(self.p1_tank.get_power_as_percentage()), FONT, FONT_SIZE, y, 0) #draw game information y = 0 if self.mode == Modes.GameOver: y += 5 + self.draw_info_text('Game Over!', BIG_FONT, BIG_FONT_SIZE, y, 1) y += self.draw_info_text('Player {} won!'.format(self.players_turn), MEDIUM_FONT, MEDIUM_FONT_SIZE, y, 1) else: y += 5 + self.draw_info_text('Day {}'.format(self.turn), BIG_FONT, BIG_FONT_SIZE, y, 1) y += self.draw_info_text('Player {}\'s turn'.format(self.players_turn), FONT, FONT_SIZE, y, 1) #If we are firing, draw the power bar if self.mode == Modes.Firing: self.calculate_power() self.power_bar.w = self.current_power pygame.draw.rect(self._windowSurfaceObj, (POWER_BAR_COLOR[0]+self.current_power,POWER_BAR_COLOR[1]-self.current_power,POWER_BAR_COLOR[2]) , self.power_bar) pygame.draw.rect(self._windowSurfaceObj, OUTLINE_COLOR, self.power_outline, 2) #draw player 2's information y = 0 y += 5 + self.draw_info_text('Player 2', MEDIUM_FONT, MEDIUM_FONT_SIZE, y, 2) y += self.draw_info_text('HP: {:10.1f}%'.format(self.p2_tank.get_hp_as_percentage()), FONT, FONT_SIZE, y, 2) y += self.draw_info_text('Angle: {:10.1f}°'.format(abs(self.p2_tank.get_angle())), FONT, FONT_SIZE, y, 2) self.draw_info_text('Power: {:10.1f}%'.format(self.p2_tank.get_power_as_percentage()), FONT, FONT_SIZE, y, 2) def draw_info_text(self, text, font, font_size, y, column): """ Draws given text with given information. """ line_text = font.render(text, True, FONT_COLOR) self._windowSurfaceObj.blit( line_text, (column*COLUMN_WIDTH + PAD, self._map_resolution[1] + y + PAD)) return font_size + PAD def draw_tank(self, tank): """ Draws given tank """ pos = tank.get_position() barrel_pos = tank.get_barrel_position() #Rotate the barrel image barrel_img = pygame.transform.rotate(tank.image_barrel, tank.get_angle()) #Calculate the barrel's fixed position - because of the rotation y = math.sin(math.radians(abs(tank.get_angle())))*44 #Defines the x according to the tank and update the initial shot position if tank.team == 1: x = 0 tank.set_shot_start_position(barrel_pos[0] + barrel_img.get_width(), barrel_pos[1]-y) else: x = 56 - barrel_img.get_width() tank.set_shot_start_position(barrel_pos[0] + x, barrel_pos[1]-y) #Draw the tank and the barrel self._windowSurfaceObj.blit(tank.image, (pos[0],pos[1])) self._windowSurfaceObj.blit(barrel_img, (barrel_pos[0] + x,barrel_pos[1]-y)) pygame.display.flip() def draw_shot(self, x,y): """ Draw a shot on given positon """ return pygame.draw.circle(self._windowSurfaceObj, SHOT_COLOR, (x,y), SHOT_RADIUS) def erase_shot(self, x,y): """ Erase a shot on given position """ pygame.draw.circle(self._windowSurfaceObj, self._bg_color, (x,y), SHOT_RADIUS) def calculate_power(self): """ Calculates the new power. It should increase every frame until it reaches 100. After, it decreases until 20 - and keeps going like this until the user hits space again """ if self.current_power > 80: rate = 3.5 elif self.current_power > 60: rate = 2.3 elif self.current_power > 40: rate = 1.8 elif self.current_power > 20: rate = 1.1 else: rate = 0.5 if self.current_power_increasing: self.current_power += rate if self.current_power >= 100: self.current_power = 100 self.current_power_increasing = False else: self.current_power -= rate if self.current_power <= 0: self.current_power = 0 self.current_power_increasing = True self.cur_team.update_power(self.current_power) def erase_tank(self, tank): """ Erases tank """ pygame.draw.rect(self._windowSurfaceObj, self._bg_color, (tank.position[0],tank.position[1]-45,103,85)) #pygame.draw.rect(self._windowSurfaceObj, self._bg_color, tank.get_rect()) def explode_tank(self, tank): """ Animation to destroy tank """ self.erase_tank(tank) @property def cur_team(self): """ Returns the string name of the tank who's turn it currently is. """ if self.players_turn == 1: return self.p1_tank else: return self.p2_tank @property def enemy_team(self): """ Returns the string name of the tank who's turn it currently is. """ if self.players_turn == 1: return self.p2_tank else: return self.p1_tank def move_tank(self, value): """ Move the tank according to if the left or right arrow was pressed """ if self.mode != Modes.Move: return #Get the current tank current_tank = self.cur_team #Erase it self.erase_tank(current_tank) #Move it accordingly if value == "left": current_tank.move_tank([-3,0]) else: current_tank.move_tank([3,0]) #Redraw it self.draw_tank(current_tank) def change_angle(self, value): """ Change the angle of the tank barrel according to if the up or down arrow key was pressed """ if self.mode != Modes.Move: return #Get the current tank current_tank = self.cur_team #Erase it self.erase_tank(current_tank) #Change the angle accordingly if value == "up": current_tank.change_barrel_angle(1) else: current_tank.change_barrel_angle(-1) #Redraw the tank self.draw_tank(current_tank) def select_power(self): """ After hitting space to fire, we need to use a timer or somthing between events to calculate how hard the shot should be. This will eventually read from the arduino potentiometer value and pass that to the shot class. So maybe for now we will hard code it to be (0-100) """ if self.mode != Modes.Move: return self.change_mode(Modes.Firing) #self.draw_power_bar() #self. def release_power(self): if self.mode != Modes.Firing: return self.fire_shot() self.current_power = 20 self.current_power_increasing = True def fire_shot(self): """ Creates a shot according toa power value given Then creates the effects that follow a shot being fired """ self.change_mode(Modes.Draw_Shot) enemy_tank = self.enemy_team current_tank = self.cur_team self.current_shot = Shot(self.current_power, current_tank.get_angle(), current_tank, enemy_tank, self._map_resolution[1], self._map_resolution[0]) self.shot_path = self.current_shot.get_path() self.shot_path_index = 0 #play shot sound self.sound_controller.play("TankFire"); #self.sound_controller.play("BombDrop"); def finish_shot_firing(self, didHitMountain, did_hit_team=0, pos=None): """ This method is called after we finish drawing the shot and need to finish the player's turn """ enemy_tank = self.enemy_team current_tank = self.cur_team if self.players_turn == 1: enemy_team_number = 2 else: enemy_team_number = 1 if pos: self.explosion(pos[0], pos[1], 15) elif did_hit_team != 0: if did_hit_team == 1: pos = [(self.p1_tank.get_rect().x + (self.p1_tank.get_rect().w/2)),(self.p1_tank.get_rect().y + (self.p1_tank.get_rect().h/2))] elif did_hit_team == 2: pos = [(self.p2_tank.get_rect().x + (self.p2_tank.get_rect().w/2)),(self.p2_tank.get_rect().y + (self.p2_tank.get_rect().h/2))] self.explosion(pos[0], pos[1], 25) #If we didn't hit the mountain and did hit the other tank, decrease his hp if not didHitMountain and did_hit_team == enemy_team_number: enemy_tank.take_damage(self.current_power*HIT_PERCENTAGE) #If the enemy was killed, game over! if not enemy_tank.active: self.change_mode(Modes.GameOver) self.erase_tank(enemy_tank) return #If we didn't hit the mountain, friendly fire is on and we did hit ourselves if not didHitMountain and self.friendly_fire and did_hit_team == self.players_turn: current_tank.take_damage(self.current_power*HIT_PERCENTAGE) #If the played killed himself, game over! if not current_tank.active: if self.players_turn == 1: self.players_turn = 2 else: self.players_turn = 1 self.change_mode(Modes.GameOver) self.erase_tank(current_tank) return self.change_mode(Modes.Move) self.next_turn() def next_turn(self): self.turn +=1 #Updates the the player's turn variable # Which is, whoever turn is it if self.players_turn == 1: self.players_turn = 2 else: self.players_turn = 1 def change_mode(self, mode): if self.mode == mode: return self.mode = mode def explosion(self, x, y, radius): """ Creates an explosion animation centered at x,y with a radius Note: the animation is poorly done, but it's better than nothing. and there's no time to improve it, unfortunatelly """ self.sound_controller.play("Explosion") for i in range(1,10): pygame.draw.circle(self._windowSurfaceObj, ( round(100+(i*10)),round(100-(i*10)),0) , (round(x),round(y)), round((radius/10)*i)) self._pygame.display.update() for i in range(10,1): pygame.draw.circle(self._windowSurfaceObj, ( round(100+(i*10)),round(100-(i*10)),0) , (round(x),round(y)), round((radius/10)*i)) self._pygame.display.update() pygame.draw.circle(self._windowSurfaceObj, self._bg_color, (round(x),round(y)), round(radius))
def enable_alternative_mode(self): if self.alternative: bgimage = pg.image.load("./img/CI Main 128.png").convert_alpha() self.map_bg = Map("Static Image", self, self.size, (120,80), 128, bgimage) self.map_bg.setup(BG_COLOR, alt=True) self.alternative = True
def __init__(self, level, bg_color, pygame): """ Initialize the game's interface """ # Setup variables self._level = level self._pygame = pygame self._bg_color = bg_color #Start in player 1 move mode self.mode = Modes.Move # Load the level information # This method also initialize the screen size # according to the map size self._loadLevel() #Load all the sounds self.sound_controller = SoundsController() # The status bar self.status_bar = pygame.Rect(0, self._map_resolution[1], self._screen_resolution[0], STATUS_BAR_HEIGHT) # The power bar self.power_bar = pygame.Rect(COLUMN_WIDTH + (COLUMN_WIDTH - 100)/2 , self._map_resolution[1] + 80, 100, POWER_BAR_HEIGHT) self.power_outline = self.power_bar.copy() self.power_outline.w -= 1 self.power_outline.h -= 1 #Set friendly fire self.friendly_fire = True # Current power self.current_power = 20 self.current_power_increasing = True #Initialize tanks self.p1_tank = Tank([70, 560], 1) self.p2_tank = Tank([1110, 560], 2) #Initilize turn number self.turn = 1 #The first one to play is random (not always player 1) self.players_turn = randrange(2)+1 #Set the number of turns self.num_teams = 2 #Load the map information self._map = Map(level, bg_color) #Initialize the screen self._windowSurfaceObj = pygame.display.set_mode(self._screen_resolution) self._windowSurfaceObj.fill(bg_color) self._map.paintMountain(self._windowSurfaceObj) self.draw_bar() self.draw_tank(self.p1_tank) self.draw_tank(self.p2_tank)