Exemplo n.º 1
0
 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)
Exemplo n.º 2
0
 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()
Exemplo n.º 3
0
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()
Exemplo n.º 4
0
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)
Exemplo n.º 5
0
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()
Exemplo n.º 6
0
    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()
Exemplo n.º 7
0
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)
Exemplo n.º 8
0

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()
Exemplo n.º 9
0
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
Exemplo n.º 10
0
Arquivo: bot.py Projeto: mibobkov/wofm
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)
Exemplo n.º 11
0
 def __init__(self):
     self.entityManager = EntityManager()
     self.messageDispatcher = MessageDispatcher(self)
     self.gameTime = GameTime()
Exemplo n.º 12
0
# 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)
Exemplo n.º 13
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()
Exemplo n.º 14
0
def insert_text_sagittaria():
    text.delete(1.0, END)
    sagittaria = EntityManager().create_sagittaria()
    text_sagittaria = TextInsert(sagittaria)
    return text_sagittaria
Exemplo n.º 15
0
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
Exemplo n.º 16
0
def insert_text_skewer():
    text.delete(1.0, END)
    skewer = EntityManager().create_skewer()
    text_skewer = TextInsert(skewer)
    return text_skewer
Exemplo n.º 17
0
def insert_text_bowtruckle():
    text.delete(1.0, END)
    bowtruckle = EntityManager().create_bowtruckle()
    text_bowtruckle = TextInsert(bowtruckle)
    return text_bowtruckle
Exemplo n.º 18
0
def insert_text_grut():
    text.delete(1.0, END)
    grut = EntityManager().create_grut()
    text_grut = TextInsert(grut)
    return text_grut
Exemplo n.º 19
0
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)
Exemplo n.º 20
0
 def __init__(self):
     self.entity_manager = EntityManager()
     self.message_dispatcher = MessageDispatcher()