diff --git a/assets/apple.png b/assets/apple.png index 609435b..b037055 100644 Binary files a/assets/apple.png and b/assets/apple.png differ diff --git a/assets/atlas.png b/assets/atlas.png index 25b0add..07f1d2d 100644 Binary files a/assets/atlas.png and b/assets/atlas.png differ diff --git a/assets/map1.png b/assets/map1.png index 21920bf..4562a37 100644 Binary files a/assets/map1.png and b/assets/map1.png differ diff --git a/assets/map2.png b/assets/map2.png index 90e2f7e..9b0c08a 100644 Binary files a/assets/map2.png and b/assets/map2.png differ diff --git a/assets/map3.png b/assets/map3.png index 11cf3ae..08e1912 100644 Binary files a/assets/map3.png and b/assets/map3.png differ diff --git a/assets/map4.png b/assets/map4.png index 1d49162..e5e452c 100644 Binary files a/assets/map4.png and b/assets/map4.png differ diff --git a/assets/player.png b/assets/player.png index 3aebbc3..1386dd8 100644 Binary files a/assets/player.png and b/assets/player.png differ diff --git a/assets/srgb_profile_fix.py b/assets/srgb_profile_fix.py new file mode 100644 index 0000000..8869722 --- /dev/null +++ b/assets/srgb_profile_fix.py @@ -0,0 +1,11 @@ +import os +import pygame as pg + +for i in os.listdir('.'): + try: + img = pg.image.load(i) + pg.image.save(img, i) + except: + print("Failed to fix image " + i) + +print('Success. All images were fixed!') diff --git a/assets/stevenson.png b/assets/stevenson.png index 00e57c8..9caa64f 100644 Binary files a/assets/stevenson.png and b/assets/stevenson.png differ diff --git a/assets/stone.png b/assets/stone.png index a3638f6..27732da 100644 Binary files a/assets/stone.png and b/assets/stone.png differ diff --git a/assets/tree.png b/assets/tree.png index 78004b9..2ef55f1 100644 Binary files a/assets/tree.png and b/assets/tree.png differ diff --git a/assets/water.png b/assets/water.png index d08257a..155a14e 100644 Binary files a/assets/water.png and b/assets/water.png differ diff --git a/assets/wood.png b/assets/wood.png index 993aee0..2aad13b 100644 Binary files a/assets/wood.png and b/assets/wood.png differ diff --git a/survival/__init__.py b/survival/__init__.py index 35625fc..b0e66dc 100644 --- a/survival/__init__.py +++ b/survival/__init__.py @@ -1,21 +1,10 @@ import pygame from settings import SCREEN_WIDTH, SCREEN_HEIGHT -from survival import esper from survival.camera import Camera -from survival.components.camera_target_component import CameraTargetComponent -from survival.components.input_component import InputComponent -from survival.components.movement_component import MovementComponent -from survival.components.position_component import PositionComponent -from survival.components.sprite_component import SpriteComponent from survival.game_map import GameMap from survival.player_generator import PlayerGenerator from survival.resource_generator import ResourceGenerator -from survival.systems.camera_system import CameraSystem -from survival.systems.collision_system import CollisionSystem -from survival.systems.draw_system import DrawSystem -from survival.systems.input_system import InputSystem -from survival.systems.movement_system import MovementSystem from survival.world_generator import WorldGenerator if __name__ == '__main__': diff --git a/survival/building_generator.py b/survival/building_generator.py new file mode 100644 index 0000000..bdfeacf --- /dev/null +++ b/survival/building_generator.py @@ -0,0 +1,18 @@ +from survival.components.collision_component import CollisionComponent +from survival.components.inventory_component import InventoryComponent +from survival.components.position_component import PositionComponent +from survival.components.sprite_component import SpriteComponent + + +class BuildingGenerator: + def create_home(self, world, game_map): + home = world.create_entity() + pos = PositionComponent([32, 32], [32, 32]) + world.add_component(home, pos) + world.add_component(home, InventoryComponent()) + + game_map.add_entity(home, pos) + sprite = SpriteComponent('stone.png') + sprite.set_scale(2) + world.add_component(home, sprite) + world.add_component(home, CollisionComponent()) diff --git a/survival/components/direction_component.py b/survival/components/direction_component.py new file mode 100644 index 0000000..e768a48 --- /dev/null +++ b/survival/components/direction_component.py @@ -0,0 +1,12 @@ +from survival.enums import Direction + + +class DirectionChangeComponent: + def __init__(self, direction): + self.direction = direction + + def rotate_left(self): + self.direction = Direction.rotate_left(self.direction) + + def rotate_right(self): + self.direction = Direction.rotate_right(self.direction) diff --git a/survival/components/inventory_component.py b/survival/components/inventory_component.py new file mode 100644 index 0000000..18d39f9 --- /dev/null +++ b/survival/components/inventory_component.py @@ -0,0 +1,24 @@ +class InventoryComponent: + def __init__(self, maxitems): + self.maxitems = maxitems + self.items = {} + + def addItem(self, item, count): + if item not in self.items: + self.items[item] = count + else: + self.items[item] = self.items[item] + count + if self.items[item] > self.maxitems: + self.items[item] = self.maxitems + + def removeItem(self, item, count): + if self.items: + self.items[item] = self.items[item] - count + if self.items[item] < 0: + self.items[item] = 0 + + def hasItem(self, item): + if self.items[item] != 0: + return True + else: + return False diff --git a/survival/components/moving_component.py b/survival/components/moving_component.py index 0de446e..ec2e69e 100644 --- a/survival/components/moving_component.py +++ b/survival/components/moving_component.py @@ -1,5 +1,4 @@ class MovingComponent: - def __init__(self, direction, target): - self.direction = direction - self.movement_target = target - self.checked_collision = False + def __init__(self): + self.target = None + self.direction_vector = None diff --git a/survival/components/pathfinding_component.py b/survival/components/pathfinding_component.py new file mode 100644 index 0000000..4dbe908 --- /dev/null +++ b/survival/components/pathfinding_component.py @@ -0,0 +1,5 @@ +class PathfindingComponent: + def __init__(self, target_pos): + self.target_grid_pos = (int(target_pos[0] / 32), int(target_pos[1] / 32)) + self.current_target = None + self.path = None diff --git a/survival/components/position_component.py b/survival/components/position_component.py index 5164100..2838d6f 100644 --- a/survival/components/position_component.py +++ b/survival/components/position_component.py @@ -1,4 +1,15 @@ +from survival.enums import Direction + + class PositionComponent: - def __init__(self, pos, grid_pos): + def __init__(self, pos, grid_pos, direction=Direction.DOWN): self.position = pos self.grid_position = grid_pos + self.direction = direction + self.direction_change_timer = 0 + + def rotate_left(self): + return Direction.rotate_left(self.direction) + + def rotate_right(self): + return Direction.rotate_right(self.direction) diff --git a/survival/components/time_component.py b/survival/components/time_component.py new file mode 100644 index 0000000..e8bd962 --- /dev/null +++ b/survival/components/time_component.py @@ -0,0 +1,20 @@ +class TimeComponent: + def __init__(self, minute, hour, day, timer): + self.minute = minute + self.hour = hour + self.day = day + self.timer = timer + + def add_time(self, minutes): + self.minute += minutes + if self.minute >= 60: + temp = self.minute - 60 + self.hour += 1 + if self.hour >= 24: + temp2 = self.hour - 24 + self.day += 1 + self.hour = temp2 + self.minute = temp + + def __str__(self): + return f'Day {self.day}, {self.hour}:{self.minute}' diff --git a/survival/enums.py b/survival/enums.py new file mode 100644 index 0000000..cefa661 --- /dev/null +++ b/survival/enums.py @@ -0,0 +1,34 @@ +from enum import IntEnum + + +class Direction(IntEnum): + DOWN = 0 + LEFT = 1 + UP = 2 + RIGHT = 3 + + @staticmethod + def rotate_left(direction): + return Direction((direction - 1) % 4) + + @staticmethod + def rotate_right(direction): + return Direction((direction + 1) % 4) + + @staticmethod + def get_vector(direction): + if direction == Direction.UP: + return 0, -1 + elif direction == Direction.DOWN: + return 0, 1 + elif direction == Direction.LEFT: + return -1, 0 + elif direction == Direction.RIGHT: + return 1, 0 + + @staticmethod + def from_vector(vector): + if vector[0] == 0: + return Direction.DOWN if vector[1] == 1 else Direction.UP + else: + return Direction.LEFT if vector[0] == -1 else Direction.RIGHT diff --git a/survival/game_map.py b/survival/game_map.py index dfc0365..b8563be 100644 --- a/survival/game_map.py +++ b/survival/game_map.py @@ -1,6 +1,4 @@ -from survival.components.position_component import PositionComponent from survival.entity_layer import EntityLayer -from survival.player import Player from survival.tile_layer import TileLayer @@ -25,4 +23,4 @@ class GameMap: self.entity_layer.remove_entity(pos) def is_colliding(self, pos): - return self.entity_layer.is_colliding(pos) + return pos[0] < 0 or pos[0] >= self.width or pos[1] < 0 or pos[1] >= self.height or self.entity_layer.is_colliding(pos) diff --git a/survival/graph_search.py b/survival/graph_search.py new file mode 100644 index 0000000..92054e7 --- /dev/null +++ b/survival/graph_search.py @@ -0,0 +1,88 @@ +from enum import Enum + +from survival import GameMap +from survival.components.position_component import PositionComponent +from survival.enums import Direction + + +class Action(Enum): + ROTATE_LEFT = 0 + ROTATE_RIGHT = 1 + MOVE = 2 + + +class State: + def __init__(self, position, direction): + self.position = position + self.direction = direction + + +class Node: + def __init__(self, state: State, parent=None, action=None): + self.state = state + self.parent = parent + self.action = action + + +def get_moved_position(position, direction): + vector = Direction.get_vector(direction) + return position[0] + vector[0], position[1] + vector[1] + + +def get_states(state: State, game_map: GameMap): + states = list() + + states.append((Action.ROTATE_LEFT, State(state.position, state.direction.rotate_left(state.direction)))) + states.append((Action.ROTATE_RIGHT, State(state.position, state.direction.rotate_right(state.direction)))) + + target_state = get_moved_position(state.position, state.direction) + if not game_map.is_colliding(target_state): + states.append((Action.MOVE, State(target_state, state.direction))) + + return states + + +def graph_search(game_map: GameMap, start: PositionComponent, goal: tuple): + fringe = list() + explored = list() + + explored_states = set() + fringe_states = set() + + start = State(start.grid_position, start.direction) + fringe.append(Node(start)) + fringe_states.add((tuple(start.position), start.direction)) + + while True: + # No solutions found + if not any(fringe): + return [] + + node = fringe.pop(0) + fringe_states.remove((tuple(node.state.position), node.state.direction)) + + # Check goal + if node.state.position == goal: + actions = [node.action] + parent = node.parent + + while parent is not None: + if parent.action is not None: + actions.append(parent.action) + parent = parent.parent + + actions.reverse() + return actions + + explored.append(node) + explored_states.add((tuple(node.state.position), node.state.direction)) + + # Get all possible states + for state in get_states(node.state, game_map): + sub_state = (tuple(state[1].position), state[1].direction) + if sub_state not in fringe_states and sub_state not in explored_states: + new_node = Node(state=state[1], + parent=node, + action=state[0]) + fringe.append(new_node) + fringe_states.add((tuple(new_node.state.position), new_node.state.direction)) diff --git a/survival/pathfinding.py b/survival/pathfinding.py new file mode 100644 index 0000000..dfaa68b --- /dev/null +++ b/survival/pathfinding.py @@ -0,0 +1,58 @@ +from collections import deque as Queue + + +def valid_neighbor(n, game_map, visited): + if n[0] < 0 or n[1] < 0 or n[0] >= game_map.width or n[1] >= game_map.height: + return False + if visited[n[0]][n[1]]: + return False + if game_map.is_colliding(n): + return False + + return True + + +def breadth_first_search(game_map, start, target): + visited = [[False for _ in range(game_map.height)] for _ in range(game_map.width)] + q = Queue() + came_from = dict() + start = tuple(start) + target = tuple(target) + + came_from[start] = None + + q.append(start) + visited[start[0]][start[1]] = True + + while len(q) > 0: + cell = q.popleft() + + if cell == target: + break + + neighbors = [ + (cell[0] - 1, cell[1]), + (cell[0], cell[1] + 1), + (cell[0] + 1, cell[1]), + (cell[0], cell[1] - 1), + ] + + for neighbor in neighbors: + if valid_neighbor(neighbor, game_map, visited): + q.append(neighbor) + visited[neighbor[0]][neighbor[1]] = True + came_from[neighbor] = cell + + path = list() + current = target + + while current != start: + path.append(current) + if current not in came_from: + path.clear() + return path + + current = came_from[current] + + path.reverse() + return path diff --git a/survival/player.py b/survival/player.py index a689663..995f5e6 100644 --- a/survival/player.py +++ b/survival/player.py @@ -2,8 +2,6 @@ from random import randint import pygame -from survival.image import Image - class Player: def __init__(self): diff --git a/survival/player_generator.py b/survival/player_generator.py index df7a317..4a24660 100644 --- a/survival/player_generator.py +++ b/survival/player_generator.py @@ -3,6 +3,7 @@ from survival.components.input_component import InputComponent from survival.components.movement_component import MovementComponent from survival.components.position_component import PositionComponent from survival.components.sprite_component import SpriteComponent +from survival.components.time_component import TimeComponent class PlayerGenerator: @@ -19,5 +20,6 @@ class PlayerGenerator: sprite = SpriteComponent('stevenson.png') sprite.set_scale(1) world.add_component(player, sprite) + world.add_component(player, TimeComponent(0, 0, 0, 0)) return player diff --git a/survival/resource_generator.py b/survival/resource_generator.py index ba5aa3f..fe36c9a 100644 --- a/survival/resource_generator.py +++ b/survival/resource_generator.py @@ -13,7 +13,7 @@ class ResourceGenerator: def generate_resources(self): for x in range(RESOURCES_AMOUNT): obj = self.world.create_entity() - sprites = ['apple.png', 'water.png', 'wood.png', 'stone.png'] + sprites = ['apple.png', 'water.png', 'wood.png'] empty_grid_pos = self.get_empty_grid_position() empty_pos = [empty_grid_pos[0] * 32, empty_grid_pos[1] * 32] diff --git a/survival/settings.py b/survival/settings.py index 577806c..fd6e84f 100644 --- a/survival/settings.py +++ b/survival/settings.py @@ -1,3 +1,4 @@ SCREEN_WIDTH = 1920 SCREEN_HEIGHT = 1080 RESOURCES_AMOUNT = 300 +DIRECTION_CHANGE_DELAY = 200 diff --git a/survival/systems/collision_system.py b/survival/systems/collision_system.py index 5a7055e..5e0bea2 100644 --- a/survival/systems/collision_system.py +++ b/survival/systems/collision_system.py @@ -1,6 +1,9 @@ +import operator + from survival import esper from survival.components.moving_component import MovingComponent from survival.components.position_component import PositionComponent +from survival.enums import Direction class CollisionSystem(esper.Processor): @@ -9,17 +12,19 @@ class CollisionSystem(esper.Processor): def process(self, dt): for ent, (pos, moving) in self.world.get_components(PositionComponent, MovingComponent): - if moving.checked_collision: + if moving.target is not None: continue moving.checked_collision = True - if self.check_collision(moving.movement_target): + vector = Direction.get_vector(pos.direction) + moving.target = tuple(map(operator.add, vector, pos.grid_position)) + moving.direction_vector = vector + if self.check_collision(moving.target): self.world.remove_component(ent, MovingComponent) - else: - self.map.move_entity(pos.grid_position, moving.movement_target) - pos.grid_position = moving.movement_target + self.map.move_entity(pos.grid_position, moving.target) + pos.grid_position = moving.target def check_collision(self, pos): return self.map.is_colliding(pos) diff --git a/survival/systems/direction_system.py b/survival/systems/direction_system.py new file mode 100644 index 0000000..86d9f8f --- /dev/null +++ b/survival/systems/direction_system.py @@ -0,0 +1,27 @@ +from survival import esper +from survival.components.direction_component import DirectionChangeComponent +from survival.components.position_component import PositionComponent +from survival.settings import DIRECTION_CHANGE_DELAY + + +class DirectionSystem(esper.Processor): + def process(self, dt): + for ent, (pos, direction) in self.world.get_components(PositionComponent, DirectionChangeComponent): + if pos.direction_change_timer > 0: + pos.direction_change_timer -= dt + continue + + dir_left = pos.rotate_left() + dir_right = pos.rotate_right() + + pos.direction_change_timer = DIRECTION_CHANGE_DELAY + + if dir_left == direction.direction: + pos.direction = dir_left + elif dir_right == direction.direction: + pos.direction = dir_right + else: + pos.direction = dir_left + continue + + self.world.remove_component(ent, DirectionChangeComponent) diff --git a/survival/systems/draw_system.py b/survival/systems/draw_system.py index cf70fe7..2cb35ae 100644 --- a/survival/systems/draw_system.py +++ b/survival/systems/draw_system.py @@ -10,4 +10,5 @@ class DrawSystem(esper.Processor): def process(self, dt): for ent, (sprite, pos) in self.world.get_components(SpriteComponent, PositionComponent): sprite.image.pos = pos.position + sprite.image.origin = (32 * pos.direction.value, 0) self.camera.draw(sprite.image) diff --git a/survival/systems/input_system.py b/survival/systems/input_system.py index c8d7cc8..d4b6c23 100644 --- a/survival/systems/input_system.py +++ b/survival/systems/input_system.py @@ -1,26 +1,34 @@ import pygame from survival import esper +from survival.components.direction_component import DirectionChangeComponent from survival.components.input_component import InputComponent from survival.components.moving_component import MovingComponent +from survival.components.pathfinding_component import PathfindingComponent from survival.components.position_component import PositionComponent class InputSystem(esper.Processor): - def __init__(self): - self.map = None + def __init__(self, camera): + self.camera = camera def process(self, dt): for ent, (inp, pos) in self.world.get_components(InputComponent, PositionComponent): keys = pygame.key.get_pressed() + mouse = pygame.mouse.get_pressed(3) + if mouse[0] == 1: + pos = pygame.mouse.get_pos() + pos = (pos[0] - self.camera.camera.left, pos[1] - self.camera.camera.top) + if not self.world.has_component(ent, PathfindingComponent): + self.world.add_component(ent, PathfindingComponent(pos)) if self.world.has_component(ent, MovingComponent): continue if keys[pygame.K_LEFT]: - self.world.add_component(ent, MovingComponent([-1, 0], [pos.grid_position[0] - 1, pos.grid_position[1]])) + if not self.world.has_component(ent, DirectionChangeComponent): + self.world.add_component(ent, DirectionChangeComponent(pos.rotate_left())) elif keys[pygame.K_RIGHT]: - self.world.add_component(ent, MovingComponent([1, 0], [pos.grid_position[0] + 1, pos.grid_position[1]])) - elif keys[pygame.K_DOWN]: - self.world.add_component(ent, MovingComponent([0, 1], [pos.grid_position[0], pos.grid_position[1] + 1])) + if not self.world.has_component(ent, DirectionChangeComponent): + self.world.add_component(ent, DirectionChangeComponent(pos.rotate_right())) elif keys[pygame.K_UP]: - self.world.add_component(ent, MovingComponent([0, -1], [pos.grid_position[0], pos.grid_position[1] - 1])) + self.world.add_component(ent, MovingComponent()) diff --git a/survival/systems/movement_system.py b/survival/systems/movement_system.py index 70ad744..5f0d868 100644 --- a/survival/systems/movement_system.py +++ b/survival/systems/movement_system.py @@ -13,23 +13,22 @@ class MovementSystem(esper.Processor): for ent, (mov, pos, moving, sprite) in self.world.get_components(MovementComponent, PositionComponent, MovingComponent, SpriteComponent): - if moving.direction[0] != 0: - pos.position[0] += moving.direction[0] * mov.speed * dt / 100 - if abs(moving.movement_target[0] * 32 - pos.position[0]) < 0.1 * mov.speed: - pos.position = [moving.movement_target[0] * 32, moving.movement_target[1] * 32] - self.world.remove_component(ent, MovingComponent) - else: - pos.position[1] += moving.direction[1] * mov.speed * dt / 100 - if abs(pos.position[1] - moving.movement_target[1] * 32) < 0.1 * mov.speed: - pos.position = [moving.movement_target[0] * 32, moving.movement_target[1] * 32] - self.world.remove_component(ent, MovingComponent) - if moving.direction[0] == 1: - sprite.image.origin = (96, 0) - elif moving.direction[0] == -1: - sprite.image.origin = (64, 0) - elif moving.direction[1] == 1: - sprite.image.origin = (0, 0) - else: - sprite.image.origin = (32, 0) + pos.position[0] += moving.direction_vector[0] * mov.speed * dt / 100 + pos.position[1] += moving.direction_vector[1] * mov.speed * dt / 100 + if abs(moving.target[0] * 32 - pos.position[0]) < 0.1 * mov.speed and abs( + pos.position[1] - moving.target[1] * 32) < 0.1 * mov.speed: + pos.position = [moving.target[0] * 32, moving.target[1] * 32] + self.world.remove_component(ent, MovingComponent) + + # if moving.direction[0] != 0: + # pos.position[0] += moving.direction[0] * mov.speed * dt / 100 + # if abs(moving.movement_target[0] * 32 - pos.position[0]) < 0.1 * mov.speed: + # pos.position = [moving.movement_target[0] * 32, moving.movement_target[1] * 32] + # self.world.remove_component(ent, MovingComponent) + # else: + # pos.position[1] += moving.direction[1] * mov.speed * dt / 100 + # if abs(pos.position[1] - moving.movement_target[1] * 32) < 0.1 * mov.speed: + # pos.position = [moving.movement_target[0] * 32, moving.movement_target[1] * 32] + # self.world.remove_component(ent, MovingComponent) diff --git a/survival/systems/pathfinding_movement_system.py b/survival/systems/pathfinding_movement_system.py new file mode 100644 index 0000000..551abd4 --- /dev/null +++ b/survival/systems/pathfinding_movement_system.py @@ -0,0 +1,62 @@ +from survival import esper +from survival.components.direction_component import DirectionChangeComponent +from survival.components.movement_component import MovementComponent +from survival.components.moving_component import MovingComponent +from survival.components.position_component import PositionComponent +from survival.enums import Direction +from survival.graph_search import graph_search, Action +from survival.pathfinding import breadth_first_search +from survival.systems.input_system import PathfindingComponent + + +class PathfindingMovementSystem(esper.Processor): + def __init__(self, game_map): + self.game_map = game_map + pass + + def process(self, dt): + for ent, (pos, pathfinding, movement) in self.world.get_components(PositionComponent, PathfindingComponent, + MovementComponent): + if pathfinding.path is None: + pathfinding.path = graph_search(self.game_map, pos, pathfinding.target_grid_pos) + + if len(pathfinding.path) < 1: + self.world.remove_component(ent, PathfindingComponent) + continue + + if self.world.has_component(ent, MovingComponent) or self.world.has_component(ent, DirectionChangeComponent): + continue + + action = pathfinding.path.pop(0) + + if action == Action.ROTATE_LEFT: + self.world.add_component(ent, DirectionChangeComponent(Direction.rotate_left(pos.direction))) + elif action == Action.ROTATE_RIGHT: + self.world.add_component(ent, DirectionChangeComponent(Direction.rotate_right(pos.direction))) + else: + self.world.add_component(ent, MovingComponent()) + + # if pathfinding.path is None: + # pathfinding.path = breadth_first_search(self.game_map, pos.grid_position, pathfinding.target_grid_pos) + # + # if len(pathfinding.path) < 1 and pathfinding.current_target is None: + # self.world.remove_component(ent, PathfindingComponent) + # continue + # + # if self.world.has_component(ent, MovingComponent): + # continue + # + # if pathfinding.current_target is None: + # target = pathfinding.path.pop(0) + # else: + # target = pathfinding.current_target + # + # vector = (target[0] - pos.grid_position[0], target[1] - pos.grid_position[1]) + # direction = Direction.from_vector(vector) + # if direction != pos.direction: + # pathfinding.current_target = target + # self.world.add_component(ent, DirectionChangeComponent(direction)) + # continue + # + # pathfinding.current_target = None + # self.world.add_component(ent, MovingComponent()) diff --git a/survival/systems/time_system.py b/survival/systems/time_system.py new file mode 100644 index 0000000..a1624bf --- /dev/null +++ b/survival/systems/time_system.py @@ -0,0 +1,12 @@ +from survival import esper +from survival.components.time_component import TimeComponent + + +class TimeSystem(esper.Processor): + def process(self, dt): + for ent, time in self.world.get_component(TimeComponent): + time.timer += dt + if time.timer > 1000: + time.add_time(1) + time.timer = 0 + print(time) diff --git a/survival/world_generator.py b/survival/world_generator.py index 02e75ff..586564b 100644 --- a/survival/world_generator.py +++ b/survival/world_generator.py @@ -1,19 +1,25 @@ from survival import esper from survival.systems.camera_system import CameraSystem from survival.systems.collision_system import CollisionSystem +from survival.systems.direction_system import DirectionSystem from survival.systems.draw_system import DrawSystem from survival.systems.input_system import InputSystem from survival.systems.movement_system import MovementSystem +from survival.systems.pathfinding_movement_system import PathfindingMovementSystem +from survival.systems.time_system import TimeSystem class WorldGenerator: def create_world(self, camera, game_map): world = esper.World() - world.add_processor(InputSystem()) + world.add_processor(InputSystem(camera)) world.add_processor(CameraSystem(camera)) world.add_processor(MovementSystem(), priority=1) world.add_processor(CollisionSystem(game_map), priority=2) world.add_processor(DrawSystem(camera)) + world.add_processor(TimeSystem()) + world.add_processor(PathfindingMovementSystem(game_map), priority=3) + world.add_processor(DirectionSystem()) return world