def event_check(self, event): ''' Event checker. Checks if the event is a key press or release on the arrow keys. ''' if event.key == g.key_dict["move_up"][0]: self.y_minus = if_down(event.type) elif event.key == g.key_dict["move_down"][0]: self.y_plus = if_down(event.type) elif event.key == g.key_dict["move_left"][0]: self.x_minus = if_down(event.type) elif event.key == g.key_dict["move_right"][0]: self.x_plus = if_down(event.type) elif event.key == g.key_dict["place_tile"][0]: self.placing_tile = if_down(event.type) elif event.key == g.key_dict["remove_tile"][0]: self.removing_tile = if_down(event.type) elif (event.key == g.key_dict["pick_up_tile"][0] and event.type == pgl.KEYDOWN): self.toggle_grab = True elif (event.key == g.key_dict["plant_megatree"][0]): x, y = self.get_tile() width, height = c.IMAGES["megatree"].multi_tile if tiles.area_is_free(x, y + 2, width, height): tiles.make_tile("megatree", x, y + 2) print "Tried making megatree" elif event.key == g.key_dict["build_structure"][0]: pass
def check_tile(self, z, x, y): returned = json.loads( self.client.get('/api/v1/tiles/?d={uuid}.{z}.{x}.{y}'.format( uuid=self.cooler.uuid, x=x, y=y, z=z)).content) r = base64.decodestring(returned[returned.keys()[0]]['dense']) q = np.frombuffer(r, dtype=np.float32) with h5py.File(self.cooler.datafile.url) as f: mat = [f, cch.get_info(self.cooler.datafile.url)] t = tiles.make_tile(z, x, y, mat) # test the base64 encoding self.assertTrue(np.isclose(sum(q), sum(t))) # make sure we're returning actual data self.assertGreater(sum(q), 0)
def generate_map(): ''' Function that loads a PIL image and reads it, pixel by pixel, to decode it into a tile map. Gets the map from the c.IMAGES["map"] object. Sets a map (two-dimensional list of Tiles), the width and height of the image loaded and the player starting point, x and y, from the file as variables in the g module. (5 items) If no starting point is found, return 0, 0 as the starting point. ''' # Load the image map_image = pygame.image.load("res\\" + c.IMAGES["map"].png) g.map = [] # Variable for holding multi_tiles until after the primary generation, because multi_tiles = [] width, height = map_image.get_size() player_start_x = 0 player_start_y = 0 for x in range(width): # Create a new vertical column for every pixel the image is wide. g.map.append([]) for y in range(height): # The pixel variable is the pixel we're currently checking. pixel = map_image.get_at((x, y))[:3] type = pixel_type(pixel, x, y) # If the pixel is the player start tile, save the location of that pixel. if type == "start_tile": player_start_x = x * c.TILE_SIZE player_start_y = y * c.TILE_SIZE type = c.DEFAULT_TILE # Check to see if it's a multi-tile and, if so, store that in a variable to be done last g.map[x].append(None) if c.IMAGES[type].multi_tile: multi_tiles.append([type, x, y]) tiles.make_tile(c.DEFAULT_TILE, x, y) else: # Make a new tile and add it to the map tiles.make_tile(type, x, y) # Sets the values to the global values g.width = width g.height = height g.player_start_x = player_start_x g.player_start_y = player_start_y # Create the multi-tiles for multi_tile in multi_tiles: type, x, y = multi_tile width, height = c.IMAGES[type].multi_tile if (g.map[x][y] and g.map[x][y].type == c.DEFAULT_TILE and tiles.area_is_free(x, y, width, height)): tiles.make_tile(type, x, y)
def update(self, time_diff): ''' Calls the super update function as well as check for if the package should be turned into a tile. ''' if self.target_coords and not self.had_target_coords: self.had_target_coords = True self.target_coords[0] = self.target_coords[0] + (c.TILE_SIZE - self.width) / 2 self.target_coords[1] = self.target_coords[1] + (c.TILE_SIZE - self.height) / 2 if self.target_coords == [int(self.x), int(self.y)]: x, y = self.get_tile() g.map[x][y] = tiles.make_tile(self.tile, x, y) g.update_map = True if self.attached_entity != None: g.special_entity_list[self.attached_entity].following_entity = None del g.special_entity_list[self.attached_entity + "-" + self.image] return "deleted" super(Package, self).update(time_diff)
def make_cooler_tile(cooler_filepath, tile_position): '''Create a tile from a cooler file. Args: cooler_filepath (str): The location of the cooler file that we'll that we'll extract the tile data from. tile_position (list): The position of the tile ([z,x,y]) Returns: dict: The tile data consisting of a 'dense' member containing the data array as well as 'min_value' and 'max_value' which contain the minimum and maximum values in the 'dense' array. ''' tile_data = {} if cooler_filepath not in mats: make_mats(cooler_filepath) tileset_file_and_info = mats[cooler_filepath] if tile_position[0] > tileset_file_and_info[1]['max_zoom']: # we don't have enough zoom levels return None if tile_position[1] >= 2 ** tile_position[0]: # tile is out of bounds return None if tile_position[2] >= 2 ** tile_position[0]: # tile is out of bounds return None tile = make_tile( tile_position[0], tile_position[1], tile_position[2], mats[cooler_filepath] ) tile_data["min_value"] = float(np.min(tile)) tile_data["max_value"] = float(np.max(tile)) tile_data['dense'] = base64.b64encode(tile) return tile_data
def update(self, time_diff): ''' Calls the superclass update and updates the state of the aim marker. Manages if the player is placing or destroying a block. ''' super(Player, self).update(time_diff) # Update screen whenever aim marker changes states if self.removing_tile != self.last_removing_tile: self.last_removing_tile = self.removing_tile g.force_update = True # Get which tile the player is looking at aim_tile = self.get_aim_tile() x, y = aim_tile # If the aim tile has changed if aim_tile != self.last_aim_tile or self.update_aim_tile: self.update_aim_tile = False # Checks if the aim tile has a remove time (can be destroyed). # If so, assign that value to self.remove_timer. try: if c.IMAGES[g.map[x][y].type].destroy != None: # print "Standard timer set" self.remove_timer = c.IMAGES[g.map[x][y].type].destroy[0] elif type(g.map[x][y]) == tiles.MultiTilePointer: # print "Pointer timer set" # Finding out which tile the pointer is pointing to, and if that has a destroy value head_x, head_y = g.map[x][y].target multi_tile_head = g.map[head_x][head_y] if c.IMAGES[multi_tile_head.type].destroy != None: self.remove_timer = c.IMAGES[multi_tile_head.type].destroy[0] else: self.remove_timer = None else: # print "Indestructible tile" self.remove_timer = None except IndexError: # print "IndexError" self.remove_timer = None except: raise self.last_aim_tile = aim_tile # Placing tile if self.placing_tile and not self.removing_tile: try: if c.IMAGES[g.map[x][y].type].placeable: # If there is a special case for placing tiles, use that. Otherwise, use the default if g.map[x][y].type in c.SPECIAL_PLACE_TILES.keys(): tiles.make_tile(c.SPECIAL_PLACE_TILES[g.map[x][y].type], x, y) else: tiles.make_tile(c.DEFAULT_PLACE_TILE, x, y) # Ignore IndexErrors because the indices might be outside of the map except IndexError: pass except: raise # Removing tile if self.removing_tile and not self.placing_tile: # If the timer isn't None (is removable) if self.remove_timer != None: # If remove_timer has reached 0 which means the countdown is done if self.remove_timer < 1: tiles.destroy_tile(x, y) self.update_aim_tile = True self.remove_timer = None return # Grabbing tile if self.toggle_grab: # If the grab button is pressed self.toggle_grab = False if self.following_entity != None: x, y = g.special_entity_list[self.following_entity].get_tile() if c.IMAGES[g.map[x][y].type].placeable: g.special_entity_list[self.following_entity].target_coords = [x*c.TILE_SIZE, y*c.TILE_SIZE] else: if g.map[x][y].type == c.PACKAGE_TILE_NAME: g.map[x][y] = tiles.make_tile(c.DEFAULT_TILE, x, y) g.update_map = True units.Package(x*c.TILE_SIZE, y*c.TILE_SIZE, "player")