def tentative_move(self, world, old_pos, index): self.pos[index] += self.vel[index] if index == 0: self.bounding_box.x = Convert.world_to_pixel(self.pos[index]) else: self.bounding_box.y = Convert.world_to_pixel(self.pos[index]) block_left = int(Convert.world_to_chunk(self.pos[0])[0]) chunk_left = Convert.world_to_chunk(self.pos[0])[1] block_right = math.ceil(Convert.world_to_chunk(self.pos[0] + self.width)[0]) chunk_right = Convert.world_to_chunk(self.pos[0] + self.width)[1] block_top = int(self.pos[1]) block_bottom = math.ceil(self.pos[1] + self.height) col1 = col2 = col3 = col4 = False if chunk_left == chunk_right: chunk = world.loaded_chunks.get(chunk_left) col1 = self.check_collision(chunk, block_left, block_right, block_top, block_bottom, old_pos, index) else: #need to check from block_left in chunk_left to block_right in chunk_right and all the blocks in any chunks between them chunk = world.loaded_chunks.get(chunk_left) col2 = self.check_collision(chunk, block_left, Chunk.WIDTH, block_top, block_bottom, old_pos, index) for c in range(chunk_left + 1, chunk_right): chunk = world.loaded_chunks.get(c) col3 = self.check_collision(chunk, 0, Chunk.WIDTH, block_top, block_bottom, old_pos, index) chunk = world.loaded_chunks.get(chunk_right) col4 = self.check_collision(chunk, 0, block_right, block_top, block_bottom, old_pos, index) if col1 or col2 or col3 or col4: self.vel[index] = 0 #reset acceleration? if index == 0: self.bounding_box.x = Convert.world_to_pixel(self.pos[index]) else: self.bounding_box.y = Convert.world_to_pixel(self.pos[index])
def break_block(self, player, mouse_pos, viewport): angle = self.find_angle(player, mouse_pos, viewport) block_pos = Convert.pixels_to_world(self.find_pos(angle, player.pixel_pos(True), Convert.viewport_to_pixels(mouse_pos, viewport), player.get_break_distance())) #it aint right chunk = self.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1]) block = self.get_block(block_pos) if block["breakable"]: chunk.blocks[block_pos[1]][Convert.world_to_chunk(block_pos[0])[0]] = get_block("water") chunk.entities.append(BlockDrop.BlockDrop(block_pos, block["name"]))
def update(self): for x in range(self.loaded_chunks.first, self.loaded_chunks.end): chunk = self.loaded_chunks.get(x) for entity in chunk.entities: entity.update(self) if Convert.world_to_chunk(entity.pos[0])[1] != chunk.x: print("Moving", entity, entity.pos) chunk.entities.remove(entity) self.loaded_chunks.get(Convert.world_to_chunk(entity.pos[0])[1]).entities.append(entity)
def update(self, world): old_chunk = Convert.world_to_chunk(self.pos[0])[1] hspeed = min(abs(self.vel[0] + self.acceleration * self.dir[0]), self.max_speed) * self.dir[0] vspeed = min(abs(self.vel[1] + self.acceleration * self.dir[1]), self.max_speed) * self.dir[1] self.vel = [hspeed, vspeed] super(Player, self).update(world) new_chunk = Convert.world_to_chunk(self.pos[0])[1] if new_chunk != old_chunk: world.load_chunks(new_chunk) entities = self.get_nearby_entities(world) for entity in entities: if(self.bounding_box.colliderect(entity.bounding_box)): if isinstance(entity, ItemDrop): if self.inventory.insert(entity.get_itemstack()) == None: world.loaded_chunks.get(entity.get_chunk()).entities.remove(entity)
def render(): if gamemode == MENU: menu.render(screen) elif gamemode == PLAYING: screen.fill(SKY) world.render(screen, viewport) if DEBUG: #render debug text h = 10 fpsimg = font.render("fps: " + str(clock.get_fps()), 0, WHITE) screen.blit(fpsimg, (10, h)) h += fpsimg.get_height() posimg = font.render("pos: [{0:.2f}".format(player.pos[0]) + ", {0:.2f}]".format(player.pos[1]), 0, WHITE) screen.blit(posimg, (10, h)) h += posimg.get_height() chunk = world.loaded_chunks.get(Convert.world_to_chunk(player.pos[0])[1]) chunkimg = font.render("chunk: " + str(chunk.x), 0, WHITE) screen.blit(chunkimg, (10, h)) h += chunkimg.get_height() biomeimg = font.render("biome: " + str(chunk.biome["name"]), 0, WHITE) screen.blit(biomeimg, (10, h)) h += biomeimg.get_height() player.render(screen, Convert.world_to_viewport(player.pos, viewport)) if gui is None: target_pos = world.find_pos(world.find_angle(player, pygame.mouse.get_pos(), viewport), Convert.pixels_to_viewport(player.pixel_pos(True), viewport), pygame.mouse.get_pos(), player.get_break_distance()) screen.blit(img_target, [x - y for x, y in zip(target_pos, [dim / 2 for dim in img_target.get_size()])]) #zoo-wee mama! else: gui.render(screen) pygame.display.flip()
def generate_structure(self, structure, x): #TODO: add background blocks defined separately if structure["type"] == "column": height = random.randint(structure["minheight"], structure["maxheight"]) for y in range(self.heights[x] - height, self.heights[x]): self.set_block_at(x, y, World.get_block(structure["block"]), False) elif structure["type"] == "json": structure_file = open(structure["location"]) structure_json = json.load(structure_file) curr_y = self.heights[x] - len(structure_json["shape"]) for line in structure_json["shape"]: curr_world_x = Convert.chunk_to_world(x, self) for char in line: #find the right chunk chunk = self #world.chunks[Convert.world_to_chunk(x)[1]]- can't really do this... curr_chunk_x = Convert.world_to_chunk(curr_world_x)[0] if curr_chunk_x < WIDTH: if char == " ": block_name = "water" else: block_name = structure_json["blocks"][char] block = World.get_block(block_name) #TODO: add background chunk.set_block_at(curr_chunk_x, curr_y, block, False) if block["entity"] != "": #generate the block entity EntityClass = getattr(importlib.import_module("ent." + block["entity"]), block["entity"]) instance = EntityClass([curr_world_x, curr_y], self) self.entities.append(instance) curr_world_x += 1 curr_y += 1 structure_file.close() elif structure["type"] == "singleblock": self.set_block_at(x, self.heights[x] - 1, World.get_block(structure["block"]), False)
def generate_structure(self, structure, x): if structure["type"] == "column": height = random.randint(structure["minheight"], structure["maxheight"]) for y in range(self.heights[x] - height, self.heights[x]): self.blocks[y][x] = World.get_block(structure["block"]) elif structure["type"] == "json": structure_file = open(structure["location"]) structure_json = json.load(structure_file) curr_y = self.heights[x] - len(structure_json["shape"]) for line in structure_json["shape"]: curr_world_x = Convert.chunk_to_world(x, self) for char in line: #find the right chunk chunk = self #world.chunks[Convert.world_to_chunk(x)[1]]- can't really do this... curr_chunk_x = Convert.world_to_chunk(curr_world_x)[0] if curr_chunk_x < WIDTH: if char == " ": block = "water" else: block = structure_json["blocks"][char] chunk.blocks[curr_y][curr_chunk_x] = World.get_block(block) curr_world_x += 1 curr_y += 1 structure_file.close() elif structure["type"] == "other": #why did I write this? pass
def update(self, world): old_chunk = Convert.world_to_chunk(self.pos[0])[1] hspeed = min(abs(self.vel[0] + self.acceleration * self.dir[0]), self.max_speed) * self.dir[0] vspeed = min(abs(self.vel[1] + self.acceleration * self.dir[1]), self.max_speed) * self.dir[1] self.vel = [hspeed, vspeed] super(Player, self).update(world) new_chunk = Convert.world_to_chunk(self.pos[0])[1] if new_chunk != old_chunk: world.load_chunks(new_chunk) entities = world.loaded_chunks.get(Convert.world_to_chunk(self.pos[0])[1]).entities for entity in entities: if(self.bounding_box.colliderect(entity.bounding_box)): if type(entity) is BlockDrop: if self.pickup(entity.blockname): entities.remove(entity) print(self.inventory)
def update(self): for x in range(self.loaded_chunks.first, self.loaded_chunks.end): chunk = self.loaded_chunks.get(x) for entity in chunk.entities: entity.update(self) if Convert.world_to_chunk(entity.pos[0])[1] != chunk.x \ and self.loaded_chunks.contains_index(Convert.world_to_chunk(entity.pos[0])[1]) \ and entity in chunk.entities: chunk.entities.remove(entity) self.create_entity(entity) for layer in [True, False]: blocks_to_remove = [] for breaking_block in self.breaking_blocks[layer]: breaking_block["progress"] -= 1 if breaking_block["progress"] <= 0: blocks_to_remove.append(breaking_block) for b in blocks_to_remove: self.breaking_blocks[layer].remove(b)
def render_break_preview(self, background, world, block, block_pos, screen, viewport): chunk = world.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1]) blockimg = world.get_block_render(World.get_block_id(block["name"]), block_pos, block["connectedTexture"], background, chunk, background).copy() mask = pygame.mask.from_surface(blockimg) olist = mask.outline() polysurface = pygame.Surface((Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE), pygame.SRCALPHA) color = self.get_color(background) pygame.draw.polygon(polysurface, color, olist, 0) screen.blit(polysurface, Convert.world_to_viewport(block_pos, viewport))
def is_clear(self, world, pos): for x in range(int(pos[0]), int(pos[0] + self.width)): for y in range(int(pos[1]), int(pos[1] + self.height)): if not world.is_loaded_chunk(Convert.world_to_chunk(x)[1]): return False if y >= World.HEIGHT: return False block = World.get_block(world.get_block_at((x, y), False)) if block["solid"]: return False return True
def break_block(self, world, mouse_pos, viewport, background): block_pos = self.find_angle_pos(mouse_pos, viewport) chunk = world.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1]) #if there's a foreground block covering the background, don't break anything if background and world.get_block_at(block_pos, False) != "water": return block = World.get_block(world.get_block_at(block_pos, background)) held_item = self.get_held_item() if held_item is None: harvest_level = 0 break_speed = 1 else: harvest_level = held_item.get_harvest_level() break_speed = held_item.get_break_speed() if (not block["breakable"]) or (block["harvestlevel"] > harvest_level): return block_to_break = None breaking_blocks = world.breaking_blocks[background] for breaking_block in breaking_blocks: if breaking_block["pos"] == block_pos: block_to_break = breaking_block if block_to_break is None: block_to_break = {"pos": block_pos, "name": block["name"], "progress": 0, "breaktime": block["breaktime"]} breaking_blocks.append(block_to_break) block_to_break["progress"] += 2 * break_speed if block_to_break["progress"] >= block_to_break["breaktime"]: #remove the block breaking_blocks.remove(block_to_break) chunk.set_block_at(Convert.world_to_chunk(block_pos[0])[0], block_pos[1], World.get_block("water"), background) blockentity = None if block["entity"] != "": #remove the associated entity for entity in chunk.entities: if type(entity).__name__ == block["entity"] and [int(entity.pos[0]), int(entity.pos[1])] == block_pos: chunk.entities.remove(entity) blockentity = entity break chunk.entities.append(ItemDrop(block_pos, block["name"], blockentity))
def load_state(self, path): savefile = open(path, "rb") save_data = pickle.load(savefile) savefile.close() self.player.set_pos(save_data["player_pos"]) player_chunk = Convert.world_to_chunk(self.player.pos[0])[1] self.loaded_chunks = TwoWayList.TwoWayList() self.load_chunks(player_chunk) self.player.inventory = save_data["player_inventory"] for row in self.player.inventory: for item in row: if item is not None: item.load_image() self.player.selected_slot = save_data["hotbar_slot"]
def load_state(self, path): savefile = open(path, "rb") save_data = pickle.load(savefile) savefile.close() self.player = save_data["player"] self.seed = save_data["seed"] Generate.setup(self.seed) player_chunk = Convert.world_to_chunk(self.player.pos[0])[1] self.loaded_chunks = TwoWayList.TwoWayList() self.load_chunks(player_chunk) self.player.load_image() for row in self.player.inventory: for item in row: if item is not None: item.load_image()
def render(): if gamemode == MAINMENU or gamemode == PAUSEMENU: menu.render_background(screen) menu.render(screen) elif gamemode in (PLAYING, OPENGUI): player = world.player shift = pygame.key.get_pressed()[pygame.K_LSHIFT] or pygame.key.get_pressed()[pygame.K_RSHIFT] screen.fill(SKY) #background world.render(screen, viewport, True) if shift: player.draw_block_highlight(world, pygame.mouse.get_pos(), viewport, screen, shift) world.render_breaks(screen, viewport, True) #foreground world.render(screen, viewport, False) if not shift: player.draw_block_highlight(world, pygame.mouse.get_pos(), viewport, screen, shift) world.render_breaks(screen, viewport, False) player.render(screen, Convert.world_to_viewport(player.pos, viewport)) #add blue overlay- not completely sure this is good overlay = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT)) overlay.set_alpha(64) overlay.fill(BLUE) screen.blit(overlay, (0, 0)) if gamemode == PLAYING: hotbarGui.render(screen) else: gui.render(screen) if DEBUG: #render debug text chunk = world.loaded_chunks.get(Convert.world_to_chunk(player.pos[0])[1]) debugtext = ["fps: {0:.2f}".format(clock.get_fps()), "pos: [{0:.2f}".format(player.pos[0]) + ", {0:.2f}]".format(player.pos[1]), "chunk: " + str(chunk.x), "biome: " + str(chunk.biome["name"])] debugimg = GUI.render_string_array(debugtext, font, 0, WHITE) h = SCREEN_HEIGHT - debugimg.get_height() screen.blit(debugimg, (2 * SCALE, h)) pygame.display.flip()
def render_block_preview(self, background, held_item, world, block_pos, screen, viewport): held_block = World.get_block(held_item.name) chunk = world.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1]) blockimg = world.get_block_render(World.get_block_id(held_block["name"]), block_pos, held_block["connectedTexture"], background, chunk, background).copy() mask = pygame.mask.from_surface(blockimg) olist = mask.outline() polysurface = pygame.Surface((Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE), pygame.SRCALPHA) screen.blit(polysurface, Convert.world_to_viewport(block_pos, viewport)) collides = False entities = world.get_nearby_entities(self.get_chunk()) entities.append(self) for entity in entities: if entity.collides(block_pos) and entity.background == background: collides = True color = self.get_color(background) if collides and World.get_block(held_block["name"])["solid"]: color = (color[0], 0, 0, color[3]) pygame.draw.polygon(polysurface, color, olist, 0) blockimg.blit(polysurface, (0, 0), special_flags=pygame.BLEND_RGBA_MULT) screen.blit(blockimg, Convert.world_to_viewport(block_pos, viewport))
def interact(self, player, item): if self.locked or self.animating: return False world = Game.get_world() sides = [(0, 1), (1, 0), (0, -1), (-1, 0)] for side in sides: goal_pos = [self.pos[0] + side[0], self.pos[1] + side[1]] block = world.get_block_at(goal_pos, False) if block == "puzzleBackground": entity_collision = False entities = world.loaded_chunks.get(Convert.world_to_chunk(goal_pos[0])[1]).entities for entity in entities: if entity.pos == goal_pos: entity_collision = True if not entity_collision: self.old_pos = self.pos self.animating = True self.set_pos(goal_pos) Game.play_sound("sfx/puzzle/slide.ogg") return True return False
def get_block(self, world_pos): chunk = self.loaded_chunks.get(Convert.world_to_chunk(world_pos[0])[1]) x_in_chunk = Convert.world_to_chunk(world_pos[0])[0] return chunk.blocks[world_pos[1]][x_in_chunk]
def set_block_at(self, world_pos, block, background): chunk = self.loaded_chunks.get(Convert.world_to_chunk(world_pos[0])[1]) x_in_chunk = Convert.world_to_chunk(world_pos[0])[0] chunk.set_block_at(x_in_chunk, world_pos[1], block, background)
def create_entity(self, entity): self.loaded_chunks.get(Convert.world_to_chunk(entity.pos[0])[1]).entities.append(entity)
def close(self, world): if self.moving_item is not None: chunk = world.loaded_chunks.get(Convert.world_to_chunk(self.player.pos[0])[1]) chunk.entities.append(ItemDrop(self.player.pos, self.moving_item.name, self.moving_item.imageurl, self.moving_item.data, self.moving_item.count)) self.moving_item = None
def get_chunk(self): return Convert.world_to_chunk(self.pos[0])[1] #should be accurate
def get_nearby_entities(self, world): entities = list(world.loaded_chunks.get(Convert.world_to_chunk(self.pos[0])[1]).entities) entities += world.loaded_chunks.get(Convert.world_to_chunk(self.pos[0])[1] - 1).entities entities += world.loaded_chunks.get(Convert.world_to_chunk(self.pos[0])[1] + 1).entities return entities