def game_over(self):
"""
Whenever game should end or not. Events:
- checks whether game duration exceeded given time
- checks the collision between 2 Agents by using 2 methods: AABB and - if first return POSSIBLE collision - SAT
Parameters
----------
None
Returns
-------
is_over : boolean
whether game ended
winner : string or None
who won the game, if the game ended
"""
if self.duration <= 0:
return True, "HIDING"
if Collision.aabb(self.player_seek.pos,
(self.player_seek.width, self.player_seek.height),
self.player_hide.pos,
(self.player_hide.width, self.player_hide.height)):
logger_engine.info(
"Rectangle collision, checking Polygon Collision by using SAT Method."
)
if Collision.sat(self.player_seek.get_abs_vertices(),
self.player_hide.get_abs_vertices()):
logger_engine.info("Polygon Collision! Ending the game!")
return True, "SEEKER"
return False, None
def reset(self):
"""
Resets the environment by running init() function
Parameters
----------
None
Returns
-------
None
"""
# it just uses init function
logger_engine.info(f"{LOGGING_DASHES} Resetting Game {LOGGING_DASHES}")
self.init()
def __init__(self, config):
"""
Constructs all neccesary attributes for the HideNSeek Object
Parameters
----------
config : configparser Object
contains config file in configparser (dict-like) Object
"""
self.fps = config['GAME'].getint('FPS', fallback=30)
self.map_path = config['GAME'].get('MAP_PATH',
fallback='fallback_map') + '.bmp'
self.clock = None
self.screen = None
self.dt = None
self.cfg = config['GAME']
self.duration = None
self.p_hide_cfg = config['AGENT_HIDING']
self.p_seek_cfg = config['AGENT_SEEKER']
self.agent_env = {}
logger_engine.info("Initializing Game Engine")
logger_engine.info(f"\tFPS: {self.fps}")
def step(self):
"""
Runs every frame, does:
overwrites screen
locks fps
updates Agents (depending on the Agent Action) based on previously calculated Agent local environments
creates local environment for Agents
updates Agents POV
updates game duration
Parameters
----------
None
Returns
-------
None
"""
# clean screen
logger_engine.info("New Frame")
logger_engine.debug("\tLocking FPS")
self.dt = self.clock.tick_busy_loop(self.fps)
logger_engine.info(f"\tFPS: {self.clock.get_fps()}")
self._reduce_agent_cooldown(self.player_seek)
self._reduce_agent_cooldown(self.player_hide)
logger_engine.debug("\tTaking actions")
new_action_seek = copy.deepcopy(random.choice(
self.player_seek.actions))
new_action_hide = copy.deepcopy(random.choice(
self.player_hide.actions))
if new_action_seek['type'] == 'remove_wall':
self._remove_wall()
else:
self.player_seek.update(new_action_seek, self.agent_env['p_seek'],
logger_seeker)
if new_action_hide['type'] == 'add_wall':
self._add_wall()
else:
self.player_hide.update(new_action_hide, self.agent_env['p_hide'],
logger_hiding)
logger_engine.debug("\tCalculating Local Environments")
self._calc_local_env()
logger_engine.debug("\tUpdating vision")
self.player_seek.update_vision(self.agent_env['p_seek'])
self.player_hide.update_vision(self.agent_env['p_hide'])
self.duration -= 1
logger_engine.info(f"\tLeft: {self.duration} frames")
def generate_map(all_objects, map_bmp):
"""
Generates map by using BMP File
Parameters
----------
all_objects : dict
dictionary of objects to add into the game
Returns
-------
walls_group : list
list of wall objects
player_seek : Object
Seeker object.
player_hide : Object
Hiding object.
width : int
game screen width.
height : int
game screen int.
"""
walls_group = []
player_seek = None
player_hide = None
width, height = map_bmp.size
for obj in all_objects:
center_x = (obj["vertices"][0]["x"] + obj["vertices"][1]["x"]) / 2
center_y = (obj["vertices"][0]["y"] + obj["vertices"][1]["y"]) / 2
obj_width = obj["vertices"][1]["x"] - obj["vertices"][0]["x"]
obj_height = obj["vertices"][1]["y"] - obj["vertices"][0]["y"]
obj_size = (obj_width, obj_height)
if obj["type"] == "wall":
logger_engine.info("\t\tWall")
walls_group.append(
Wall(None, center_x, center_y, obj_size,
config['GAME']['GRAPHICS_PATH_WALL']))
elif obj["type"] == "seeker":
logger_engine.info("\t\tSeeker Agent")
player_seek = Seeker(config['AGENT_SEEKER'], obj_size,
(center_x, center_y), width, height)
elif obj["type"] == "hider":
logger_engine.info("\t\tHiding Agent")
player_hide = Hiding(config['AGENT_HIDING'], obj_size,
(center_x, center_y), width, height)
return walls_group, player_seek, player_hide, width, height
def init(self, walls, seeker, hider, width, height):
"""
Initializes game environment, which means creating Agents & their POV,
adding them to Sprite Group and creating Sprite Group for Walls
Parameters
----------
None
Returns
-------
None
"""
self.duration = self.cfg.getint('DURATION', fallback=60)
self.clock = pygame.time.Clock()
self.width, self.height = width, height
logger_engine.info(f"\tResolution: {self.width}x{self.height}")
logger_engine.info("\tWalls Sprite Group")
self.walls_group = pygame.sprite.Group()
self.walls_group.add(walls)
self.player_seek = seeker
self.player_hide = hider
logger_engine.info("Initializing Environment Objects")
self.player_seek.update_vision({
'walls': [],
'enemy': None,
})
self.player_hide.update_vision({
'walls': [],
'enemy': None,
})
self._calc_local_env()
logger_engine.info("\tSeeker Vision")
self.player_seek.update_vision(self.agent_env['p_seek'])
logger_engine.info("\tHiding Vision")
self.player_hide.update_vision(self.agent_env['p_hide'])
logger_engine.info("\tAgents Sprite Group")
self.players_group = pygame.sprite.Group()
self.players_group.add(self.player_seek)
self.players_group.add(self.player_hide)
elif obj["type"] == "seeker":
logger_engine.info("\t\tSeeker Agent")
player_seek = Seeker(config['AGENT_SEEKER'], obj_size,
(center_x, center_y), width, height)
elif obj["type"] == "hider":
logger_engine.info("\t\tHiding Agent")
player_hide = Hiding(config['AGENT_HIDING'], obj_size,
(center_x, center_y), width, height)
return walls_group, player_seek, player_hide, width, height
if __name__ == "__main__":
logger_engine.info(f"{LOGGING_DASHES} Initializing game {LOGGING_DASHES}")
os.environ['SDL_VIDEO_CENTERED'] = config['VIDEO']['CENTERED']
render_mode = 'human'
logger_engine.info(
f"\tGenerating map from BMP ({config['GAME'].get('MAP_PATH', fallback='maps/map')}.bmp)"
)
map_bmp = MapGenerator.open_bmp(
config['GAME'].get('MAP_PATH', fallback='maps/map') + '.bmp')
all_objects = MapGenerator.get_objects_coordinates(
map_bmp, MapGenerator.get_predefined_palette())
walls, seeker, hider, width, height = generate_map(all_objects, map_bmp)
pygame.init()
game = HideNSeek(config=config)
game.init(walls, seeker, hider, width, height)