def __init__(self, config: Config): self.__timer = Timer() self.__config = config self.__status = Status.START self.__level = 0 self.__score = 0 self.__best_score = 0 self.__entity_manager = EntityManager(self.__config) self.__renderer = Renderer(self.__config)
def test_entity_manager_checking(self): id_doublon_detected = False try: EntityManager.check_all() except Exception: id_doublon_detected = True if not id_doublon_detected: raise "Entity manager has missed an id doublon" GameState.set_value("entities.1.id", 1) EntityManager.check_all()
class GameManager: def __init__(self): self.entityManager = EntityManager() self.messageDispatcher = MessageDispatcher(self) self.gameTime = GameTime() def AddEntity(self, entity): self.entityManager.Register(entity) def GetEntityName(self, ID): return self.entityManager.GetFromID(ID).name def GetEntity(self, ID): return self.entityManager.GetFromID(ID) def Broadcast(self, delay, sender, receiverID, msg, extraInfo): log("At loop " + str(self.gameTime.GetLoop()) + ", " + str(self.entityManager.GetFromID(sender.GetID()).name) + " sent message to " + str(self.entityManager.GetFromID(receiverID).name) + " with message: " + str(msg) + ". Delay: " + str(delay)) self.messageDispatcher.DispatchMessage(delay, sender.GetID(), receiverID, msg, extraInfo) def NextTimeStep(self): self.gameTime.NextTimestep() def HoursTo(self, time): return self.gameTime.HoursTo(time) def GetTime(self): return self.gameTime.GetTime() def GetTimeStr(self): return self.gameTime.GetTimeStr() def ToTimeStr(self, time): return self.gameTime.ToTimeStr(time) def GetWeekday(self): return self.gameTime.GetWeekday() def GetWeekdayStr(self): return self.gameTime.GetWeekdayStr() def NextLoop(self): self.gameTime.NextLoop() def GetLoop(self): return self.gameTime.GetLoop()
def run_game(): # Initialize game, settings, and create a screen object. pygame.init() settings = Settings.getInstance() screen = pygame.display.set_mode( (settings.screen_width, settings.screen_height)) pygame.display.set_caption(settings.window_caption) # Make the Play button. play_button = Button(screen, "Play") # Make Groupmanager em = EntityManager.getInstance() # Make ship ship = Ship(screen) em.add_single("ship", ship) # Make a group to store bullets in. em.add_group("bullets") # Make a group to store aliens in em.add_group("aliens") # Create statistics and scoreboard stats = GameStats() sb = Scoreboard(settings, screen, stats) # Load background. bg = BackGround() # Create explosions group em.add_group("explosions") # Start background music SoundManager.getInstance().play_music() # Make power up group em.add_group("power_ups") # Start the main loop for the game. while True: # Watch for keyboard and mouse events. gf.check_events(screen, stats, sb, play_button) if stats.game_active: em.update_singles() gf.update_bullets(screen, stats, sb) gf.update_aliens(screen, stats, sb) gf.update_explosions() gf.update_power_ups() gf.update_screen(screen, bg, stats, sb, play_button)
class Game: _instance = None def __new__(cls, *args, **kwargs): if not Game._instance: Game._instance = object.__new__(cls) return Game._instance def __init__(self): self.entity_manager = EntityManager() self.message_dispatcher = MessageDispatcher() def add_entity(self, entity): self.entity_manager.register_entity(entity) entity.game = self def update(self): for entity in self.entity_manager: entity.update() self.message_dispatcher.dispatch_delayed_messages()
def initialize(self): """Initialize the engine and all managers""" logging.info("Creating systems...") self.entity_manager = EntityManager(self) self.block_system = BlockSystem(self) self.graphics_system = GraphicsSystem(self) self.camera_system = CameraSystem(self) self.input_system = InputSystem(self) self.physics_system = PhysicsSystem(self) self.test_system = TestSystem(self) logging.info("Initializing...") self.entity_manager.initialize() self.block_system.initialize() self.graphics_system.initialize() self.camera_system.initialize() self.input_system.initialize() self.physics_system.initialize()
class Core: __timer: Timer __entity_manager: EntityManager __renderer: Renderer __config: Config __level: int __score: int __best_score: int __status: Status __key_status: KeyStatus def __init__(self, config: Config): self.__timer = Timer() self.__config = config self.__status = Status.START self.__level = 0 self.__score = 0 self.__best_score = 0 self.__entity_manager = EntityManager(self.__config) self.__renderer = Renderer(self.__config) def __update_key_status(self): self.__key_status += KeyStatus.get_status() def __update(self) -> None: self.__update_key_status() if self.__status == Status.START and pyxel.btn(pyxel.KEY_S): self.__entity_manager.init() self.__status = Status.GAMING elif pyxel.btn(pyxel.KEY_R): self.__level = 0 self.__score = 0 self.__status = Status.START elif self.__timer.time_pass_ns > self.__config.get_tick_time( self.__level) and self.__status == Status.GAMING: try: lines = self.__entity_manager.process_tick(self.__key_status) except DeathException: self.__status = Status.DEATH else: self.__score += lines * self.__config.score_per_line self.__best_score = max(self.__score, self.__best_score) self.__level = self.__score // self.__config.score_per_level self.__key_status = KeyStatus.get_status() self.__timer.start() def __render(self) -> None: self.__renderer.render( Content(status=self.__status, block_map=self.__entity_manager.block_map, entity=self.__entity_manager.current_entity, current_score=self.__score, best_score=self.__best_score, level=self.__level)) def run(self) -> None: pyxel.init(width=self.__config.width, height=self.__config.height, caption=self.__config.translate.title, palette=Color.get_palette(), quit_key=pyxel.KEY_ESCAPE) play_sound() self.__key_status = KeyStatus.get_status() self.__timer.start() pyxel.run(self.__update, self.__render)
def first_time(): print('THIS IS THE FIRST TIME') db.connect(first_time) def execute_script(filename): script = open(filename, "r") queries = db.parse_queries(script) db.execute_queries(queries) script.close() execute_script("SQL_scripts/drop_tables.sql") execute_script("SQL_scripts/create_tables.sql") em = EntityManager(db) role = em.create_role("Service Desk", True) user = em.create_user("Joe", "Biden", "*****@*****.**", role) department = em.create_department("General Management") team = em.create_team("Marketing", department) em.dump() db.commit() db.close()
from incident_value_change_request import IncidentValueChangeRequest from datetime import timedelta HTTP_OKAY = 200 HTTP_CREATED = 201 HTTP_BAD_REQUEST = 400 HTTP_FORBIDDEN = 403 HTTP_NOT_FOUND = 404 HTTP_UNPROCESSABLE = 422 HTTP_SERVER_ERROR = 500 app = Flask(__name__, static_url_path='/static', instance_relative_config=True) app.secret_key = b'_5#y2L"F4Q8z\n\xec]/' database = Database('irms.db') entity_manager = EntityManager(database, False) entity_manager.initialize() def handle_shutdown(): database.close() atexit.register(handle_shutdown) def get_user(): if 'user_id' in session: return entity_manager.get_user(int(session['user_id'])) return None
from configuration import TOKEN, db_param from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from base import Base from bot_message_sender import BotMessageSender from message_processor import MessageProcessor from entity_manager import EntityManager # Setting up mysqlalchemy engine = create_engine(db_param, echo=True) engine.connect() Base.metadata.create_all(engine) Session = sessionmaker(bind=engine) session = Session() entity_manager = EntityManager(session) # Setting up bot polling updater = Updater(token=TOKEN) dispatcher = updater.dispatcher logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.DEBUG) ms = BotMessageSender(updater.bot) mp = MessageProcessor(entity_manager, ms) def start(bot, update): mp.start(update.message.chat_id, update.message.text)
def __init__(self): self.entityManager = EntityManager() self.messageDispatcher = MessageDispatcher(self) self.gameTime = GameTime()
# Internal imports from settings import Settings from bullet import Bullet from alien import Alien from explosion import Explosion from sound_manager import SoundManager from entity_manager import EntityManager from power_up import PowerUp from settings import P_TYPE # Singleton instance of Settings class settings = Settings.getInstance() # Singleton instance of Entity Manager class ent_man = EntityManager.getInstance() def check_keydown_events(event, screen): """Respond to keypresses.""" ship = ent_man.get_single("ship") if event.key == pygame.K_RIGHT: ship.moving_right = True elif event.key == pygame.K_LEFT: ship.moving_left = True elif event.key == pygame.K_SPACE: fire_bullet(screen) SoundManager.getInstance().laser.play() elif event.key == pygame.K_q: sys.exit(0)
class Engine(EngineObject): """An engine is the main controller of the game. Handles startup, looping, states. Has pointers to all managers. """ class State(object): """Enumeration of possible engine states""" RELEASED = 'RELEASED' MINIMAL = 'MINIMAL' MAINMENU = 'MAINMENU' GAMEPLAY = 'GAMEPLAY' def __init__(self, local_options): """Contructor""" logging.info("Initializing engine.") r = random.Random() r.seed(time.time()) self.execution_handle = abs(int(r.getrandbits(32))) self.local_options = local_options self.state = self.State.RELEASED EngineObject.__init__(self, self) def transition(self, state): """Handle state transitions""" ss = (self.state, state) if ss == (self.State.RELEASED, self.State.MINIMAL): self.initialize() self.crosslink_singletons() elif ss == (self.State.MINIMAL, self.State.MAINMENU): self.init_engine() self.init_menu() elif ss == (self.State.MAINMENU, self.State.GAMEPLAY): self.load_level() elif ss == (self.State.GAMEPLAY, self.State.MAINMENU): self.release_level() elif ss == (self.State.MAINMENU, self.State.RELEASED): self.release_engine() sys.exit(0) else: raise Exception('Invalid engine state transition: %s' % ss) self.state = state def initialize(self): """Initialize the engine and all managers""" logging.info("Creating systems...") self.entity_manager = EntityManager(self) self.block_system = BlockSystem(self) self.graphics_system = GraphicsSystem(self) self.camera_system = CameraSystem(self) self.input_system = InputSystem(self) self.physics_system = PhysicsSystem(self) self.test_system = TestSystem(self) logging.info("Initializing...") self.entity_manager.initialize() self.block_system.initialize() self.graphics_system.initialize() self.camera_system.initialize() self.input_system.initialize() self.physics_system.initialize() def crosslink(self): """Hook this engine up to the managers""" pass def crosslink_singletons(self): """Execute all crosslinks on managers and the engine""" logging.info("Crosslinking...") self.crosslink() self.entity_manager.crosslink() self.block_system.crosslink() self.graphics_system.crosslink() self.camera_system.crosslink() self.input_system.crosslink() self.physics_system.crosslink() def init_engine(self): """Initialize all managers with the engine""" logging.info("Initializing the engine...") self.entity_manager.init_engine() self.block_system.init_engine() self.graphics_system.init_engine() self.camera_system.init_engine() self.input_system.init_engine() self.physics_system.init_engine() self.entity_manager.init_engine_post() self.block_system.init_engine() self.graphics_system.init_engine_post() self.camera_system.init_engine_post() self.input_system.init_engine_post() self.physics_system.init_engine_post() def init_menu(self): """Initialize all managers for menus""" logging.info("Initiailizing the menu...") self.entity_manager.init_menu() self.block_system.init_menu() self.graphics_system.init_menu() self.camera_system.init_menu() self.input_system.init_menu() self.physics_system.init_menu() def load_level(self): """Load level in all managers""" logging.info("Loading the level...") self.physics_system.load_level() self.entity_manager.load_level() self.block_system.load_level() self.graphics_system.load_level() self.camera_system.load_level() self.input_system.load_level() self.test_system.load_level() #load_world(self.block_system) def release_level(self): """Release level in all managers""" logging.info("Releasing the level...") save_world(self.block_system.chunks) self.graphics_system.release_level() self.entity_manager.release_level() self.block_system.release_level() self.camera_system.release_level() self.input_system.release_level() self.physics_system.release_level() def release_engine(self): """Prepare to shutdown the engine""" logging.info("Shutting down the engine...") self.input_system.release_engine() self.graphics_system.release_engine() self.camera_system.release_engine() self.entity_manager.release_engine() self.block_system.release_engine() self.physics_system.release_engine() def main_loop(self): """ Execute the main game loop! """ last_time = time.time() dtime = 0.0 weu = ogre.WindowEventUtilities() weu.messagePump() logging.info("Entering the main loop. Game on.") while True: self._main_step(dtime) self.render() weu.messagePump() # sleeps to keep a consistent FPS new_time = self._sleep_for_fps_balance(last_time) dtime = new_time - last_time last_time = new_time def _sleep_for_fps_balance(self, last_time): now = time.time() dtime = now - last_time sleep_time = max(1.0 / float(MAX_FPS) - dtime, 0) time.sleep(sleep_time) return now def _main_step(self, dtime): """run a single loop pre: is_nat(dtime) """ self.input_system.tick(dtime) self.entity_manager.tick(dtime) self.block_system.tick(dtime) self.graphics_system.tick(dtime) self.camera_system.tick(dtime) self.physics_system.tick(dtime) def render(self): """Dispatch render request to all managers""" self.input_system.render() self.entity_manager.render() self.block_system.render() self.graphics_system.render() self.camera_system.render() self.physics_system.render()
def insert_text_sagittaria(): text.delete(1.0, END) sagittaria = EntityManager().create_sagittaria() text_sagittaria = TextInsert(sagittaria) return text_sagittaria
def insert_text_giant_kites(): text.delete(1.0, END) giant_kites = EntityManager().create_giant_kites() text_giant_kites = TextInsert(giant_kites) return text_giant_kites
def insert_text_skewer(): text.delete(1.0, END) skewer = EntityManager().create_skewer() text_skewer = TextInsert(skewer) return text_skewer
def insert_text_bowtruckle(): text.delete(1.0, END) bowtruckle = EntityManager().create_bowtruckle() text_bowtruckle = TextInsert(bowtruckle) return text_bowtruckle
def insert_text_grut(): text.delete(1.0, END) grut = EntityManager().create_grut() text_grut = TextInsert(grut) return text_grut
from miner import Miner from wife import Wife from entity_manager import EntityManager import time import random ##random.seed(10) rounds = 20 entity_mgr = EntityManager() bob = Miner('bob') elsa = Wife('elsa') entity_mgr.register_entry(bob) entity_mgr.register_entry(elsa) for i in range(rounds): bob.update() elsa.update() time.sleep(.1)
def __init__(self): self.entity_manager = EntityManager() self.message_dispatcher = MessageDispatcher()