Exemple #1
0
    def __init__(self, option_handler):
        self.option_handler = option_handler
        self.state = State.MENU

        self.level = Level()
        self.players = dict()
        self.colliders = []

        self.time_scale = 1.0

        self.camera = Camera([0, 0], self.option_handler.resolution)

        self.respawn_time = 50.0

        self.menu = MainMenu()
        self.player_menus = [
            PlayerMenu((6 * i - 9) * basis(0)) for i in range(4)
        ]
        self.options_menu = OptionsMenu()
        self.options_menu.set_values(self.option_handler)

        self.network = None
        self.network_id = -1
        self.obj_id = -1

        self.controller_id = 0
Exemple #2
0
  def __init__(self):
    self.window = Window(Game.WINDOW_WIDTH, Game.WINDOW_HEIGHT)
    self.window.set_title(Game.TITLE)

    self.keyboard = self.window.get_keyboard()
    self.mouse = self.window.get_mouse()

    self.menuPool = []

    if (Game.DEBUG):
      self._frameRate = 0
      self.frameRate = 0
      self.timer = 0

    self.mainMenu = MainMenu(self)
    self.difficultyMenu = DifficultyMenu(self)

    self.menuPool.append(self.mainMenu)
    self.menuPool.append(self.difficultyMenu)

    self.life = Game.MAX_LIFE

    self.difficulty = 1
    self.score = 0

    self.inGame = False
Exemple #3
0
    def setup(self):
        """Set up the game"""
        # set the default state
        self.state_change = False
        self.state = GameStates.MAIN_MENU

        # setup the background
        self.background = Background()
        self.background.center_x = SCREEN_WIDTH / 2
        self.background.center_y = SCREEN_HEIGHT / 2

        # setup the main menu
        self.main_menu = MainMenu()
        self.main_menu.center_x = SCREEN_WIDTH / 2
        self.main_menu.center_y = SCREEN_HEIGHT / 2

        # setup the pause menu
        self.pause_menu = PauseMenu()
        self.pause_menu.center_x = SCREEN_WIDTH / 2
        self.pause_menu.center_y = SCREEN_HEIGHT / 2

        # setup the game over screen
        self.game_over_screen = GameOverMenu()
        self.game_over_screen.center_x = SCREEN_WIDTH / 2
        self.game_over_screen.center_y = SCREEN_HEIGHT / 2

        # setup the highscores
        self.load_scores()

        # setup the scoreboard
        self.score_board = ScoreBoard()
        self.score_board.center_x = SCREEN_WIDTH / 2
        self.score_board.center_y = SCREEN_HEIGHT / 2

        # setup the player
        self.player = Player()
        self.player.center_x = SCREEN_WIDTH / 2
        self.player.center_y = SCREEN_HEIGHT / 2

        # setup the creatures
        self.all_creature_sprites_list = arcade.SpriteList()
        for i in range(self.current_creature_amount):
            rand = random.randint(1, 2)
            if rand == 1:
                creature = Moth()
            elif rand == 2:
                creature = Bug()
            creature.setup()
            self.all_creature_sprites_list.append(creature)

        # setup the obstacles
        self.all_obstacle_sprite_list = arcade.SpriteList()
        for i in range(MAX_OBSTACLE_COUNT):
            obstacle = Obstacle()
            obstacle.setup()
            self.all_obstacle_sprite_list.append(obstacle)
Exemple #4
0
class MyApp(App):
    def build(self):
        self.title = "Blackjack"
        self.parent = Widget()  
        sm = ScreenManager()
        
        
        # set up the screens
        
        #splashcreen
        self.ss = Screen(name = 'splash_screen')
        splashmenu = SplashScreen()
        splashmenu.buildUp()
        self.ss.add_widget(splashmenu)
        
        #main menu
        self.mm = Screen(name = 'main_menu')
        self.mainmenu = MainMenu()
        self.mainmenu.buildUp()
        self.mm.add_widget(self.mainmenu)
        
        #add the logo to mainmenu and splashscreen
        logo = Image(source = 'images/logo.png')
        logo.width = Window.width/2
        logo.height = Window.height/2
        logo.x = Window.width/2 - (logo.width-logo.width*.05)
        logo.y = (Window.height/2 - logo.width/2)
        self.mm.add_widget(logo)
       
     
        #game screen
        
        self.gs = Game(name = 'game')
        
      
        
        #Add screens to screen manager
        sm.add_widget(self.ss)
        sm.add_widget(self.mm)
        sm.add_widget(self.gs)
        
        sm.current = 'main_menu'
        
        def check_screen_change(obj):
            if(self.mainmenu.buttonText == 'Play'):
                sm.current = 'game'
                self.gs.start_round()
                
                
        self.mainmenu.bind(on_button_release = check_screen_change)
        
        return sm
Exemple #5
0
def MainMenuStart():
    #Code below makes the first MainMenu instance work
    #and delete Game instances if a new MainMenu is created
    try:
        del(CurrentRun)
    except NameError:
           pass
    global MainMenu

    #Starts Main Menu loop in file menu.py
    MenuInstance = MainMenu()
    MenuInstance.mm_loop()
    IntroStart(MenuInstance)
Exemple #6
0
    def __init__(self, app_name, root_view, app=None, components=[]):
        TopLevelMenu.__init__(self)
        self.app_name = app_name

        self.menu = {"left": MainMenu(), "right": MainMenu()}
        self.system_module = None
        self.babel = mydomain
        self.root_view = root_view
        self.component_config = components
        self.search_view = None
        self.base_templates = {"plain": "appshell/base_plain.html"}
        self.access_map = {}

        if app:
            self.init_app(app)
Exemple #7
0
class MainMenuTests(unittest.TestCase):
    def setUp(self):
        self.menu = MainMenu(WorkLog())

    def test_init(self):
        self.assertEqual(len(self.menu.options), 3)
        self.assertIsInstance(self.menu.options[1], MenuOption)

    def test_print_title(self):
        output = io.StringIO()
        sys.stdout = output
        self.menu.print_title()
        sys.stdout = sys.__stdout__
        text = "WORK LOG\nWhat would you like to do?\n"
        self.assertEqual(output.getvalue(), text)
Exemple #8
0
 def __init__(self, world):
     self.world = world
     self.load_image = self.world.load_image
     self.display = world.display
     self.menu = MainMenu(self)
     self.dialog = Dialog(self, self.display)
     self.state = ""
Exemple #9
0
    def __init__(self):
        pygame.init()
        self.running = True # When the application is running
        self.playing = False # When the game is actually being played
        self.UP_KEY, self.DOWN_KEY, self.START_KEY, self.BACK_KEY = False, False, False, False # START_KEY = ENTER
        self.I_KEY, self.M_KEY = False, False
        self.DISPLAY_H = 600
        self.DISPLAY_W = 600
        self.mid_width = self.DISPLAY_W/2
        self.mid_height = self.DISPLAY_H/2
        self.twelth_x = self.DISPLAY_W / 12
        self.twelth_y = self.DISPLAY_H / 12

        #Initialise window
        self.window = pygame.display.set_mode((self.DISPLAY_W, self.DISPLAY_H))
        pygame.display.set_caption("SOME COOL GAME NAME")
        self.display = pygame.Surface((self.window.get_size()))
        self.font = pygame.font.SysFont("Courier", 20)
        self.action_font = pygame.font.SysFont("Courier", 16)
        self.legend_font = pygame.font.SysFont("Courier", 12)
        self.BLACK = (0,0,0)
        self.GREEN = (0,255,0)

        self.main_menu = MainMenu(self)
        self.options_menu = OptionsMenu(self)
        self.credits_menu = CreditsMenu(self)
        self.level_one_map = LevelOneMap(self)
        self.curr_menu = self.main_menu
        self.current_screen = ''
        self.all_options_selected = []

        # Current menu. Self (current Game instance) given as parameter as MainMenu requires a game to be passed in.

        self.level_one = LevelOne(self)
        self.current_level = 0
Exemple #10
0
    def __init__(self, app):
        super(MainWindow, self).__init__()
        self.app = app
        print('window created')
        self.setWindowIcon(QIcon('img/icon.png'))
        self.setWindowTitle('Kasino')
        self.setPalette(QPalette(Qt.darkGreen))
        self.setup_music()

        self.statusbar = QStatusBar(self)
        self.statusbar.setStyleSheet('background: white')
        self.setStatusBar(self.statusbar)
        self.statusbar.showMessage('Welcome to the Cassino game!')

        self.menubar = QMenuBar(self)
        self.optionsMenu = self.menubar.addMenu('Options')
        self.music_toggle = QAction()
        self.music_toggle.setText('Music')
        self.music_toggle.setShortcut('Ctrl+m')
        self.music_toggle.setCheckable(True)
        self.music_toggle.setChecked(True)
        self.optionsMenu.addAction(self.music_toggle)
        self.music_toggle.triggered.connect(self.toggle_music)

        self.speedGroup = QActionGroup(self)
        self.speedGroup.triggered.connect(self.set_speed)

        self.slow_speed = QAction('Slow', self.speedGroup)
        self.slow_speed.setCheckable(True)
        self.normal_speed = QAction('Normal', self.speedGroup)
        self.normal_speed.setCheckable(True)
        self.fast_speed = QAction('Fast', self.speedGroup)
        self.fast_speed.setCheckable(True)
        self.vfast_speed = QAction('Very Fast', self.speedGroup)
        self.vfast_speed.setCheckable(True)
        self.normal_speed.setChecked(True)

        self.speed_menu = self.optionsMenu.addMenu('Speed')
        self.speed_menu.addActions(self.speedGroup.actions())
        self.menubar.setMouseTracking(False)
        self.setMenuBar(self.menubar)

        self.play_widget = PlayWidget(self)
        self.main_menu = MainMenu(self)
        self.start_menu = StartMenu(self)
        self.widgets = QStackedWidget(self)
        self.widgets.addWidget(self.play_widget)
        self.widgets.addWidget(self.main_menu)
        self.widgets.addWidget(self.start_menu)
        self.widgets.setCurrentWidget(self.main_menu)

        self.setCentralWidget(self.widgets)
        self.setGeometry(25, 50, 1028, 720)

        self.main_menu.startbutton.clicked.connect(self.init_game)
        self.main_menu.loadbutton.clicked.connect(self.load_game)
        self.main_menu.quitbutton.clicked.connect(self.quit)
        self.play_widget.quit_button.clicked.connect(self.quit_to_menu)
        self.play_widget.save_button.clicked.connect(self.save_game)
        self.start_menu.startbutton.clicked.connect(self.start_game)
Exemple #11
0
class BankCRM:
    menu = MainMenu()

    def run(self):
        while True:
            self.menu.display_menu()
            choice = input("Enter an option: ")
            item = self.menu.choices.get(choice)
            if item and item in (self.menu.credit_menu,
                                 self.menu.investor_menu):
                while True:
                    item.display_menu()
                    choice = input("Enter an option: ")
                    action = item.choices.get(choice)
                    if action == item.quit:
                        break
                    if action:
                        action()
                    else:
                        print("{0} is not a valid choice".format(choice))
                    continue
            elif item:
                item()
            else:
                print("{0} is not a valid choice".format(choice))
Exemple #12
0
    def __init__(self, app):
        super(MainWindow, self).__init__()

        # QApplication
        self.app = app

        # events queue
        self._events = Queue.Queue(0)

        # modal dialog holder
        self.dialog = None

        # store User in session
        self._user = None

        self.resize(1024, 600)
        self.setWindowTitle(u"Malnutrition Aigüe au Mali")
        self.setWindowIcon(QtGui.QIcon('images/icon32.png'))

        self.menu = MainMenu(self)
        self.menu.build()
        self.addToolBar(self.menu)

        self.statusbar = NUTStatusBar(self)
        self.setStatusBar(self.statusbar)

        self.view_widget = NUTWidget(self)

        self.change_context(LoginWidget)

        self.thread = SnakeMQServer(self)
        self.thread.start()

        self.timer = None
Exemple #13
0
    def __init__(self):

        pygame.init()
        self.level = 0

        self.checkanswer = True
        self.running = True
        self.playing = False
        self.game_over = False
        self.paused = False
        self.UP, self.DOWN, self.LEFT, self.RIGHT, self.START, self.BACK = False, False, False, False, False, False
        self.allow_pausing = True
        self.player = rocket(self)
        self.rock = asteroid(self)
        self.windowX, self.windowY = 1200, 700
        self.display = pygame.Surface((self.windowX, self.windowY))
        self.screen = pygame.display.set_mode([self.windowX, self.windowY])
        self.font_name = 'fonts/game_over.ttf'
        self.font_game = 'fonts/OpenSans-Light.ttf'
        pygame.display.set_caption("Rocket Logic: Not quite rocket science")
        self.main_menu = MainMenu(self)
        self.instr_menu = InstructionsMenu(self)
        self.options_menu = OptionsMenu(self)
        self.credits_menu = CreditsMenu(self)
        self.curr_menu = self.main_menu
        self.get_new_equation()
Exemple #14
0
    def __init__(self,
                 title="",
                 sWidth=1280,
                 sHeight=720,
                 bgC=color_rgb(25, 25, 25)):
        self.window = GraphWin(title, sWidth, sHeight)
        self.window.setBackground(bgC)

        self.gameState = GameState.MENU

        self.menu = MainMenu(self.window)
        self.game = Game(self.window, False)

        self.dt = 0.0  #DeltaTime
        self.lastFrameTime = 0.0

        self.setState(self.gameState)
Exemple #15
0
  def __initGame(self):
    """ Probably going to be a good idea to move the majority of these configs to a config file 
    ...soon as I create a ini object """
    environ['SDL_VIDEO_CENTERED'] = '1'
    pygame.init()
    self.clock = pygame.time.Clock()
    self.running = True
    self.fullscreen = False
    if G["fullscreen"] == True:
      self.screen = pygame.display.set_mode((G["screen_width"], G["screen_height"]), pygame.FULLSCREEN, G["color_depth"])
    else:
      self.screen = pygame.display.set_mode((G["screen_width"], G["screen_height"]), 0, G["color_depth"])
    self.fps = self.clock.get_fps()
    pygame.mouse.set_visible(False)

    self.GameMenu = MainMenu(self.screen)
    self.RunWorld = False
Exemple #16
0
    def createWidgets(self):
        # 创建一个Text
        self.text = tkinter.Text(self,width=550, height=650)
        self.text.pack()

        # 将主菜单栏加到根窗口

        menu = MainMenu(root)
        menu.createWidget()
        self.mainMenu = menu.getMenu()
        #添加快捷键事件处理
        self.root.bind("<Control-n>",lambda event:self.newfile()) 
        self.root.bind("<Control-o>",lambda event:self.openfile()) 
        self.root.bind("<Control-s>",lambda event:self.savefile()) 
        self.root.bind("<Control-q>",lambda event:self.exit())

        menu.bindMenuFile(newfile=self.newfile,
        openfile=self.openfile,
        savefile=self.savefile,
        exit=self.exit)

        quickMenu = QuickMenu(self.root)
        quickMenu.createWidget()
        quickMenu.bindMenu(changeBG=self.changBG)
        self.quickMenu = quickMenu.menu


        self.root["menu"] = self.mainMenu
        #为右键绑定事件
        self.root.bind("<Button-2>",self.showQuickMenu)
    def __init__(self):
        pygame.mixer.pre_init(44100, -16, 2, 512)
        pygame.init()
        pygame.key.set_repeat(500, 100)
        pygame.font.init()
        pygame.event.set_allowed([
            pygame.QUIT, pygame.VIDEORESIZE, pygame.KEYDOWN,
            pygame.MOUSEBUTTONDOWN
        ])

        self.playing = True
        self.clock = pygame.time.Clock()
        self.running = True

        # Start with the game paused (menus will keep running though)
        self.paused = True

        self.fullscreen = config["graphics"]["fullscreen"]
        self.vsync = config["graphics"]["vsync"]

        # Engine
        self.renderer = Renderer(self)
        self.spriteRenderer = SpriteRenderer(self)
        self.clickManager = ClickManager(self)
        self.textHandler = TextHandler()

        # Loaders
        self.imageLoader = ImageLoader(self)
        self.mapLoader = MapLoader()
        self.audioLoader = AudioLoader()

        # Map editor
        self.mapEditor = MapEditor(self)

        # Menu's
        self.mainMenu = MainMenu(self)
        self.optionMenu = OptionMenu(self)

        if self.fullscreen:
            self.renderer.setFullscreen()

        self.setCaption()
        self.setIcon()
        self.setCursor()
Exemple #18
0
class Loop:
    def __init__(self):
        self.state = "menu"
        self.game_state = Game(self)
        self.mainmenu_state = MainMenu(self.game_state, self)
        self.levelselect_state = LevelSelectMenu(self.game_state, self)



    def main(self):

        while True:
            if self.state == "game":
                # run game updates
                self.game_state.tick()
            elif self.state == "menu":
                self.mainmenu_state.tick()
            elif self.state == "levelSelect":
                self.levelselect_state.tick()
Exemple #19
0
def main():
   start_menu = StartMenu()
   main_menu = MainMenu()
   mode = 'start'
   user = None

   while True:
      try:
         if mode == 'start':
            user = start_menu.start_logic()
            mode = 'registered'

         elif mode == 'registered':
            main_menu.main_menu_logic()
            mode = 'start'
            
      except UserExitException:
         print('\n\n=================================================\nExiting the programm.\nThank you for using this software and goodbye!')
         exit(0)
      def ValidarUser():
            user = str(entryuser.get())
            password = str(entrypassword.get())
            # User(user)
            connection = mysql.connector.connect(host="localhost",user="******",password="",database="bdlanchonete")
            mycursor = connection.cursor()

            sqlselect = "select * from usuarios where nome like '"+user+"' and senha like '"+password+"' "  # like (parecido com)
            #print(sqlselect)
            mycursor.execute(sqlselect)
            valido = mycursor.fetchall()

            if len(valido) > 0:
                  connection = mysql.connector.connect(host="localhost",user="******",password="",database="bdlanchonete")
                  mycursor = connection.cursor()

                  sqlselectUsuario = "select * from log_usuario "  # like (parecido com)            
                  mycursor.execute(sqlselectUsuario)
                  validarUsuario = mycursor.fetchall()

                  if len(validarUsuario) > 0:
                        connection = mysql.connector.connect(host="localhost",user="******",password="",database="bdlanchonete")
                        mycursor = connection.cursor()

                        sqlDeleteUsuario = "DELETE FROM  log_usuario "
                        mycursor.execute(sqlDeleteUsuario)
                        connection.commit()    

                        sqlInsertUsuario = "INSERT INTO log_usuario(nome) VALUES('{}')".format(user)
                        mycursor.execute(sqlInsertUsuario)
                        connection.commit()    

                  else:
                        connection = mysql.connector.connect(host="localhost",user="******",password="",database="bdlanchonete")
                        mycursor = connection.cursor()
                        sqlInsertUsuario = "INSERT INTO log_usuario(nome) VALUES('{}')".format(user)
                        mycursor.execute(sqlInsertUsuario)
                        connection.commit()    


                  window.destroy()
                  MainMenu()                 


            else:
                  messagebox.showwarning("Warning","Usuário ou senha inválida!")
                  # entryuser.delete(0, END)
                  entrypassword.delete(0, END)
                  entrypassword.focus()

            mycursor.close()
            connection.commit()
            connection.close()
Exemple #21
0
class Interface(object):
    def __init__(self, world):
        self.world = world
        self.load_image = self.world.load_image
        self.display = world.display
        self.menu = MainMenu(self)
        self.dialog = Dialog(self, self.display)
        self.state = ""

    def show_dialog(self, owner, player, handler):
        self.dialog.init_dialog(owner, player, handler)
        self.state = "dialog"
        self.world.state = "itf"

    def show_menu(self, state="game"):
        self.menu.set_state(state)
        self.state = "menu"
        self.world.state = "itf"

    def return_event(self):
        for event in pygame.event.get():
            if event.type == KEYDOWN:
                return event
        else:
            return EmptyEvent()

    def draw(self):
        if self.state == "menu":
            self.menu.key_loop(self.return_event())
            self.menu.draw(self.display)
        elif self.state == "dialog":
            self.dialog.key_loop(self.return_event())
            self.dialog.draw()
        else:
            self.world.state = "game"
Exemple #22
0
    def __init__(self, cfg, mic=None):

        # arguments
        self.cfg = cfg
        self.mic = mic

        # init pygame
        pygame.init()

        # init display
        self.screen = pygame.display.set_mode(self.cfg['game']['screen_size'])

        # screen capturer
        self.screen_capturer = ScreenCapturer(self.screen, self.cfg['game'])

        # menues
        self.main_menu = MainMenu(self.cfg['game'], self.screen)
        self.help_menu = HelpMenu(self.cfg['game'], self.screen)
        self.option_menu = OptionMenu(self.cfg['game'], self.screen, self.mic)

        # game loop
        self.game_loop_state_dict = {
            'main_menu_loop': 0,
            'game_loop': 1,
            'help_menu_loop': 2,
            'option_menu_loop': 3,
            'exit': 4
        }

        # loop action
        self.loop_action_dict = {
            'start_button': 'game_loop',
            'help_button': 'help_menu_loop',
            'option_button': 'option_menu_loop',
            'end_button': 'exit',
            'exit': 'exit'
        }

        # start at main menu
        self.game_loop_state = self.game_loop_state_dict['main_menu_loop']
Exemple #23
0
 def __init__(self):
     pygame.init()
     self.exit = False
     self.framerate = 60
     self.clock = None
     self.delta_time = 0
     self.tabs = {}
     self.add_tab('game', Game(self))
     self.add_tab('mainmenu', MainMenu(self))
     self.current_tab = self.get_tab('mainmenu')
     self.current_tab.start()
     self.screen = pygame.display.set_mode(self.current_tab.get_size().floor().get())
     Painter.init(self.screen)
Exemple #24
0
def main():
    print('Press return to start the game')

    pygame.init()
    RUN = True
    screen = pygame.display.set_mode(SCREEN_SIZE)
    background = pygame.image.load(BG_PATH).convert_alpha()
    pygame.display.set_caption('PyPong')
    menu = MainMenu(screen)

    while RUN:
        for event in pygame.event.get():
            if event.type == QUIT or \
                    (event.type == KEYDOWN and event.key == K_ESCAPE):
                RUN = False
            if event.type == KEYDOWN and event.key == K_RETURN:
                menu.start()

        pygame.draw.rect(screen, BLACK, SCREEN_ORI + SCREEN_SIZE)
        screen.blit(background, SCREEN_ORI)
        pygame.display.flip()

    pygame.quit()
Exemple #25
0
    def eventCheck(self, event):

        if event.type == QUIT:
            self.running = False
        if event.type == KEYDOWN:
            if event.key == K_p or event.key == K_ESCAPE: # Pause the game and open the menu
                self.menu = MainMenu(self)
                self.menu.run()
            if event.key == K_SPACE:
                self.player.shooting = True
            if event.key == K_UP:
                self.player.moving.add("forward")
            if event.key == K_DOWN:
                self.player.moving.add("back")
            if event.key == K_RIGHT:
                self.player.moving.add("right")
            if event.key == K_LEFT:
                self.player.moving.add("left")
            if event.key == K_e:
                if self.player.emp:
                    self.player.triggerEmp(self.screen, Enemy.container, self.boss)
            if event.key == K_m:
                self.player.missile(Enemy.container, self.boss)
            if event.key == K_n:
                self.player.nuke(self.screen, Enemy.container, self.boss)
            if event.key == K_r:
                self.player.repair()
            if event.key == K_EQUALS:
                self.volume += 0.1
                if self.volume > 1:
                    self.volume = 1.0
                pygame.mixer.music.set_volume(self.volume)
            if event.key == K_MINUS:
                self.volume -= 0.1
                if self.volume < 0:
                    self.volume = 0.0
                pygame.mixer.music.set_volume(self.volume)
        if event.type == KEYUP:
            if event.key == K_SPACE:
                self.player.shooting = False
            if event.key == K_UP:
                self.player.moving.remove("forward")
            if event.key == K_DOWN:
                self.player.moving.remove("back")
            if event.key == K_RIGHT:
                self.player.moving.remove("right")
            if event.key == K_LEFT:
                self.player.moving.remove("left")
Exemple #26
0
 def __init__(self):
     pygame.init()
     self.running, self.playing = True, False
     self.UP_KEY, self.DOWN_KEY, self.START_KEY, self.BACK_KEY = False, False, False, False
     self.DISPLAY_W, self.DISPLAY_H = 600, 800
     self.display = pygame.Surface((self.DISPLAY_W, self.DISPLAY_H))
     self.window = pygame.display.set_mode((self.DISPLAY_W, self.DISPLAY_H))
     self.font_name = pygame.font.match_font("comicsansms")
     self.font = pygame.font.Font(None, 32)
     self.BLACK, self.WHITE = (0, 0, 0), (255, 255, 255)
     self.main_menu = MainMenu(self)
     self.options = OptionsMenu(self)
     self.credits = CreditsMenu(self)
     self.controls = ControlsMenu(self)
     self.volume = VolumeMenu(self)
     self.current_menu = self.main_menu
Exemple #27
0
 def __init__(self):
     pygame.init()
     self.running, self.playing = True, False
     self.UP_KEY, self.DOWN_KEY, self.START_KEY, self.BACK_KEY = False, False, False, False
     self.DISPLAY_W, self.DISPLAY_H = 800, 800
     self.display = pygame.Surface((self.DISPLAY_W, self.DISPLAY_H))
     self.window = pygame.display.set_mode(
         ((self.DISPLAY_W, self.DISPLAY_H)))
     self.font_name = 'LobsterTwo-Bold.otf'
     self.font_name2 = 'SEASRN__.ttf'
     self.font_name1 = pygame.font.get_default_font()
     self.BLACK, self.WHITE = (0, 0, 0), (255, 255, 255)
     self.main_menu = MainMenu(self)
     #self.options = OptionsMenu(self)
     #self.credits = CreditsMenu(self)
     self.curr_menu = self.main_menu
Exemple #28
0
    def __init__(self, debug=False):

        self.debug = debug

        ## Centers game window, needs to be before pygame.init()
        os.environ['SDL_VIDEO_CENTERED'] = '1'


        self.state = S_MENU
        self.fps = FPS
        self.paused = False
        self.all_player_names = []

        self.wait = 1500 #WAITING TIME AFTER FIRST PLAYER DIES, BEFORE MENU SHOWS UP. IN MILLISECONDS.

        self.keymap = {} #REGISTER KEPRESS CONSTANTLY
        self.keymap_singlepress = {} #REGISTER KEYPRESS ONE TIME
        self.events = {} #REGISTER EVENT

        #PYGAME INIT REQUIRED
        pygame.init()
        self.screen = pygame.display.set_mode(SCREEN_SIZE)
        pygame.display.set_caption(CAPTION)
        self.font = pygame.font.Font("fonts/04b.ttf", 18)
        self.scorefont = pygame.font.Font("fonts/04b.ttf", 42)
        self.keys = pygame.key.get_pressed()
        self.clock = pygame.time.Clock()

        self.register_eventhandler(pygame.QUIT, self.quit)
        self.register_key(pygame.K_ESCAPE, self.quit, singlepress = True)

        self.menu = MainMenu(self)
        self.pregame_menu = False
        self.betweengame_menu = False
        self.aftergame_menu = False
        Sound.sounds_init()
        Sound.Sounds["menumusic"].play()

        self.displaytime = False
        self.ammo = []

        self.maps = ["grass", "sand"]

        if self.debug:
            self.displaytime = True
Exemple #29
0
    def __init__(self, window):
        self.window = window
        self.active_env = None
        self.levelone_env = self.init_levelone()

        self.main_menu_env = MainMenu(on_start_game=self.start_game,
                                      on_exit=self.exit,
                                      window=self.window)

        self.pause_env = PauseMenu(on_resume=self.start_game,
                                   on_restart=self.restart,
                                   on_exit=self.exit,
                                   window=self.window)

        self.game_over_env = GameOverMenu(on_restart=self.restart,
                                          on_exit=self.exit,
                                          window=self.window)

        self.start_menu()
Exemple #30
0
 def __init__(self):
     wx.Frame.__init__(self,
                       None,
                       size=(600, 600),
                       title="Astute Song Hunter",
                       style=wx.DEFAULT_FRAME_STYLE
                       & ~(wx.MAXIMIZE_BOX | wx.RESIZE_BORDER))
     self.Menubar = MainMenu(self)
     self.SetMenuBar(self.Menubar)
     self.MainPanel = wx.Panel(self)
     self.Tools = Toolbar(self, self.MainPanel)
     self.Tune = TunePanel(self, self.MainPanel)
     self.Song = SongPanel(self, self.MainPanel)
     self.Search = SearchPanel(self, self.MainPanel)
     self.SetToolBar(self.Tools)
     VBox = wx.BoxSizer(wx.VERTICAL)
     VBox.Add(self.Tune, proportion=0, flag=wx.BOTTOM | wx.LEFT, border=10)
     VBox.Add(self.Search, proportion=0, flag=wx.LEFT | wx.TOP, border=20)
     HBox = wx.BoxSizer()
     HBox.Add(VBox, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
     HBox.Add(self.Song, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
     self.MainPanel.SetSizer(HBox)
     self.Centre()
Exemple #31
0
        """Add new entry"""
        employee, _ = models.Employee.get_or_create(name=utils.get_name())
        task = models.Task.create(employee=employee,
                                  title=utils.get_title(),
                                  time=utils.get_time(),
                                  notes=utils.get_notes())
        task.show()
        input("The entry has been added. Press enter to return to the menu")

    @classmethod
    def edit_task(self, index, tasks):
        """Edit entry"""
        tasks[index].edit()
        return index

    @classmethod
    def delete_task(self, index, tasks):
        """Delete a task for the user selected."""
        answer = input("Do you really want to delete this task? [y/N]: ")
        if answer.lower() == 'y':
            tasks[index].delete_instance()
            tasks.remove(tasks[index])
            if index > 1:
                return index - 1
            return 0
        return index


if __name__ == '__main__':
    MainMenu().run()
Exemple #32
0
from machine import Pin, SoftI2C
from sh1106 import SH1106, SH1106_I2C

from menu import MainMenu

from time import sleep
from time import time

import config

#
# Create Display
#
i2c: SoftI2C = SoftI2C(scl=Pin(22), sda=Pin(21), freq=400000)
config.DISPLAY = SH1106_I2C(128, 64, i2c, addr=0x3c)
config.DISPLAY.sleep(False)

#
# Create Menu
#
config.MAIN_MENU = MainMenu(config.DISPLAY)

# Updates values on main menu
config.delay(config.delay())
config.blob(config.blob())
config.active(config.active())

# Impoprt pin listeners
import pinListener
Exemple #33
0
"""
This module initializes and runs the main game.
"""

from game import Game
from menu import MainMenu
import pygame

SCREEN_SIZE = (960, 500)

if __name__ == "__main__":
    pygame.init()
    pygame.display.set_caption("PING")

    goal_score = 10
    game = Game(SCREEN_SIZE, goal_score)
    mainMenu = MainMenu(game, SCREEN_SIZE)
    mainMenu.display()
Exemple #34
0
    def on_show(self):
        FORMAT = '%(asctime)s - %(levelname)s: %(message)s'
        logging.basicConfig(format=FORMAT, level=logging.DEBUG)

        log = logging.getLogger('tkplus-demo')

        def cool2():
            print "GREETZ"

        def cool():
            global f
            messagebox.show('hello world')
            f1 = Form(caption="New Form", left=320, top=200)
            btn1 = Button(f1, caption='Hello', left=5, top=5, width=200, height=100)
            btn1.on_click = cool2
            btn1.background = 'blue'
            f1.show_modal()
            print "I'm a cool app"

        log.debug('demo app starting')
        f = Form(caption="Hello", width=640, height=480)
        f.caption = "Greetings"
        f.resizable = True
        f.form_type = SINGLE

        #img = Image(f, left=0, top=0, width=400, height=400, file='ok.gif')
        #img2 = Image(f, left=20, top=20, width=30, height=30, file='ok.gif')
    
        b = Button(f, caption="&Click Me", left=0, top=0, width=120, height=35)
        b.on_click = cool
        b.default = True

        b2 = Button(f, caption="Click &Me 2", left=0, top=40, width=120, height=35)
        
        def on_new():
            print "HELLO"
            messagebox.show("NEW FILE")

        menu = MainMenu(f)
        filemenu = menu.create("File")
        filemenu.create("New", on_click=on_new)
        filemenu.separator()
        filemenu.create("Exit", on_click=f.close)

        def close_notify():
            print "CLOSING"

        popup1 = PopupMenu(f)
        popup1.create("Click me", on_click=on_new)

        popup2 = PopupMenu(f)

        dlg = OpenDialog(f)
        dlg.multiple = True
        dlg.title = 'Pick a file'
        dlg.filter = 'Text Documents|*.txt'
        def raise_ex():
            raise ValueError('If I had a nickel for every exception that was thrown...')
        b2.on_click = raise_ex

        #f.icon = 'notepad.ico'

        tv1 = TreeView(f, top=80, left=5, width=600, height=300)
        item = tv1.items.add('C:')
        item.add('Documents and Settings')
        item.add('Users').add('Todd Suess').add('Desktop')
        item.add('Windows').add('system32')

        sb = StatusBar(f)

        f.left, f.top = 0, 0
        f.show()
Exemple #35
0
def run_main():
    menu_scene = Scene()
    menu_scene.add(BackgroundLayer())
    menu_scene.add(MultiplexLayer(MainMenu(), Authors()))
    director.run(menu_scene)
Exemple #36
0
 def set_menu_mode(self):
     self.mode = self.Mode.MENU
     self.menu = MainMenu(main=self,
                          screen=self.display,
                          settings=self.settings)
Exemple #37
0
class GameHandler():
    """
  game handler
  """
    def __init__(self, cfg, mic=None):

        # arguments
        self.cfg = cfg
        self.mic = mic

        # init pygame
        pygame.init()

        # init display
        self.screen = pygame.display.set_mode(self.cfg['game']['screen_size'])

        # screen capturer
        self.screen_capturer = ScreenCapturer(self.screen, self.cfg['game'])

        # menues
        self.main_menu = MainMenu(self.cfg['game'], self.screen)
        self.help_menu = HelpMenu(self.cfg['game'], self.screen)
        self.option_menu = OptionMenu(self.cfg['game'], self.screen, self.mic)

        # game loop
        self.game_loop_state_dict = {
            'main_menu_loop': 0,
            'game_loop': 1,
            'help_menu_loop': 2,
            'option_menu_loop': 3,
            'exit': 4
        }

        # loop action
        self.loop_action_dict = {
            'start_button': 'game_loop',
            'help_button': 'help_menu_loop',
            'option_button': 'option_menu_loop',
            'end_button': 'exit',
            'exit': 'exit'
        }

        # start at main menu
        self.game_loop_state = self.game_loop_state_dict['main_menu_loop']

    def run_game(self):
        """
    run game loops
    """

        # overall loop
        while self.game_loop_state != self.game_loop_state_dict['exit']:

            # run menu loops
            if self.game_loop_state == self.game_loop_state_dict[
                    'main_menu_loop']:
                self.det_next_loop(self.main_menu.menu_loop())
            elif self.game_loop_state == self.game_loop_state_dict[
                    'help_menu_loop']:
                self.det_next_loop(self.help_menu.menu_loop())
            elif self.game_loop_state == self.game_loop_state_dict[
                    'option_menu_loop']:
                self.det_next_loop(self.option_menu.menu_loop())

                # run game loop
            elif self.game_loop_state == self.game_loop_state_dict[
                    'game_loop']:
                self.det_next_loop(self.game_loop())

                # exit
            else:
                self.game_loop_state = self.game_loop_state_dict['exit']

    def det_next_loop(self, action):
        """
    determine next loop
    """

        # game loop state update
        self.game_loop_state = self.game_loop_state_dict[self.loop_action_dict[
            action]] if self.game_loop_state == self.game_loop_state_dict[
                'main_menu_loop'] else self.game_loop_state_dict[
                    'main_menu_loop']

    def game_loop(self):
        """
    actual game loop
    """

        # level creation
        levels = [
            Level_01(self.screen, self.cfg['game']['screen_size'], self.mic),
            Level_02(self.screen, self.cfg['game']['screen_size'], self.mic)
        ]

        # choose level
        level = levels[0]

        # game logic with dependencies
        game_logic = ThingsGameLogic(level, levels)

        # add clock
        clock = pygame.time.Clock()

        # init stream
        self.mic.init_stream()

        # mic stream and update
        with self.mic.stream:

            # game loop
            while game_logic.run_loop:
                for event in pygame.event.get():

                    # input handling
                    game_logic.event_update(event)
                    level.event_update(event)

                # frame update
                level = game_logic.update()
                level.update()
                self.screen_capturer.update()

                # update display
                pygame.display.flip()

                # reduce framerate
                clock.tick(cfg['game']['fps'])

            # save video plus audio
            self.screen_capturer.save_video(self.mic)
from menu import MainMenu

if __name__ == "__main__":
    # Enter the main menu
    menu = MainMenu(".sr_data")
    menu.run()
Exemple #39
0
    def on_combat(self):
        from menu import MainMenu

        MainMenu.start_battle()
Exemple #40
0
class Game(object):
  """Controls Gameplay and main loop"""
  def __init__(self):
    self.__initGame()
    while self.running:
      self.clock.tick(G["frame_speed"])
      pygame.display.set_caption(G["name"] + " FPS: " + str(self.clock.get_fps()))
      self.__checkEvents()
      self.__renderScreen()
    self.__exitGame()

  def __initGame(self):
    """ Probably going to be a good idea to move the majority of these configs to a config file 
    ...soon as I create a ini object """
    environ['SDL_VIDEO_CENTERED'] = '1'
    pygame.init()
    self.clock = pygame.time.Clock()
    self.running = True
    self.fullscreen = False
    if G["fullscreen"] == True:
      self.screen = pygame.display.set_mode((G["screen_width"], G["screen_height"]), pygame.FULLSCREEN, G["color_depth"])
    else:
      self.screen = pygame.display.set_mode((G["screen_width"], G["screen_height"]), 0, G["color_depth"])
    self.fps = self.clock.get_fps()
    pygame.mouse.set_visible(False)

    self.GameMenu = MainMenu(self.screen)
    self.RunWorld = False

  def __checkEvents(self):

    if self.GameMenu.selection == 0:

      for event in pygame.event.get():

        if event.type == QUIT:
          self.running = False

        elif event.type == KEYDOWN:

          if event.key == K_ESCAPE:
            self.running = False
            
          elif event.key == K_a:
            self.World.addCharacter(self.mainCharacter)
          elif event.key == K_c:
            self.World.removeCharacter(self.mainCharacter)
          
          elif event.key == K_LSHIFT:
            self.mainCharacter.movementspeed += 10

          elif event.key in(K_DOWN, K_UP, K_LEFT, K_RIGHT):
            self.mainCharacter.move_keys.append(pygame.key.name(event.key))
            self.mainCharacter.direction = (self.mainCharacter.move_keys[-1])
            self.mainCharacter.stop = False
            
        elif event.type == KEYUP:

          if event.key == K_LSHIFT:
            self.mainCharacter.movementspeed -= 10

          if event.key in(K_DOWN, K_UP, K_LEFT, K_RIGHT):
            key_id = self.mainCharacter.move_keys.index(pygame.key.name(event.key))
            del self.mainCharacter.move_keys[key_id]
            if len(self.mainCharacter.move_keys) != 0:
              self.mainCharacter.direction = (self.mainCharacter.move_keys[-1])
            else: 
              self.mainCharacter.stop = True

  def __renderScreen(self):
    """ 
    Display the Game's Main Menu, until a option is selected 
    This is going to need to change
    the menu needs to be one just for the main screen 
    """
    if self.GameMenu.active == True:
      self.GameMenu.run()
    
    if self.GameMenu.selection == 0:
      if self.RunWorld == False:
        collisionlist = []

        self.mainCharacter = Hero("Hero", collisionlist)
        self.World = WorldScene(self.screen)
        self.World.addCharacter(self.mainCharacter)
        self.World.setHero(self.mainCharacter)
        self.World.setMap("BIG")
        self.RunWorld = True
      else:
        self.World.update()
    
  def __exitGame(self):
    """docstring for __exitGame"""
    pygame.quit()
    pass
Exemple #41
0
from game import Game
from map import Map
import os
import argparse

version = None
with open('version_history.txt', 'r') as f:
  version = f.readline()[:-1]

parser = argparse.ArgumentParser(description='Process command line options.')
parser.add_argument('--debug', action='store_true', help='Turn on debug logging')
parser.add_argument('--version', action='version', version='Billy in the Fat Lane v'+version)
args = parser.parse_args()

quit_completely = False
main_menu = MainMenu()

while not quit_completely:
  """Clear the screen, use cls if Windows or clear if Linux"""
  if not args.debug:
    os.system('cls' if os.name=='nt' else 'clear')
  print "Welcome to Billy in the Fat Lane v"+version+"\n"
  selection = main_menu.display().lower()
  """Clear the screen, use cls if Windows or clear if Linux"""
  if not args.debug:
    os.system('cls' if os.name=='nt' else 'clear')
  if selection == 'q':
    quit_completely, quit_to_main_menu = QuitMenu().display()
  if selection == 'n':
    print "Loading maps..."
    map_list = []
Exemple #42
0
class MainWindow(QtGui.QMainWindow):
    def __init__(self, app):
        super(MainWindow, self).__init__()

        # QApplication
        self.app = app

        # events queue
        self._events = Queue.Queue(0)

        # modal dialog holder
        self.dialog = None

        # store User in session
        self._user = None

        self.resize(1024, 600)
        self.setWindowTitle(u"Malnutrition Aigüe au Mali")
        self.setWindowIcon(QtGui.QIcon('images/icon32.png'))

        self.menu = MainMenu(self)
        self.menu.build()
        self.addToolBar(self.menu)

        self.statusbar = NUTStatusBar(self)
        self.setStatusBar(self.statusbar)

        self.view_widget = NUTWidget(self)

        self.change_context(LoginWidget)

        self.thread = SnakeMQServer(self)
        self.thread.start()

        self.timer = None

    def change_context(self, context_widget, *args, **kwargs):
        if self.view_widget.prevent_close():
            if not self.view_widget.attempt_close():
                return

        # check permissions
        if context_widget.require_logged_user() and not self.is_logged():
            self.change_context(LoginWidget)
            return

        # remove focus from previous page
        self.view_widget.clearFocus()

        # instanciate context
        self.view_widget = context_widget(parent=self, *args, **kwargs)

        # adjust menu pagination
        self.menu.setPagination(context_widget.has_pagination())

        # attach context to window
        self.setCentralWidget(self.view_widget)

        # set focus to default widget on target
        focus = self.view_widget.default_focus()
        if focus:
            focus.setFocus()

    def open_dialog(self, dialog, modal=False, *args, **kwargs):
        self.dialog = dialog(parent=self, *args, **kwargs)
        self.dialog.setModal(modal)
        self.dialog.exec_()
        self.dialog = None

    def process_event(self, event):
        # discard if event expired
        if not event.alive:
            return

        # send event to modal dialog if exist
        if self.dialog:
            self.dialog.process_event(event)

        # has event been discarded?
        if not event.alive:
            return

        # send event to current widget
        self.view_widget.process_event(event)

        # has event been discarded?
        if not event.alive:
            return

        # nobody handled event. Use default notification
        self.default_event_handler(event)
        event.discard()

    def default_event_handler(self, event):
        #rep = QtGui.QMessageBox.question(self, u"Incoming SMS", event.detail)
        self.statusbar.showMessage(event.verbose())
        event.discard()

    def add_event(self, event):
        # add event to queue and launch a timer
        # this way we can process event on the QtGui thread.
        self._events.put(event)
        self.timer = self.startTimer(1000)

    def timerEvent(self, qt_event):
        # retrieve event from queue
        # delete timer
        # process event gui-wise
        event = self._events.get()
        if event:
            self.killTimer(self.timer)
            self.process_event(event)

    def closeEvent(self, event):
        # make sure we kill ZMQ thread before leaving
        self.thread.stop()
        event.accept()
        # stop Gammu-SMSD
        envoy.run('sudo /etc/init.d/gammu-smsd stop')

    def is_logged(self):
        return self._user and self._user.active

    def keyPressEvent(self, event):
        ''' menu shortcuts on function keys '''
        if event.key() in self.menu.SHORTCUTS.keys():
            self.menu.SHORTCUTS[event.key()]()
Exemple #43
0
class Game:

    def __init__ (self):

        self.screensize   = self.assembleImages()
        self.screen       = pygame.display.set_mode(self.screensize, 0, 32)
        self.volume       = 0.5
        self.player       = SpaceShip(self.screensize)
        HealthBar(self.player, self.screen, True)
        self.clock        = pygame.time.Clock()
        self.level        = 1
        self.boss         = None
        self.font         = pygame.font.Font("GearsOfPeace.ttf", 12)
        self.med_font     = pygame.font.Font("GearsOfPeace.ttf", 30)
        self.big_font     = pygame.font.Font("GearsOfPeace.ttf", 50)
        self.notify       = {"msg": None, "timer": [60*3, 0]}
        self.spawner      = {"max_enemies": 2,
                             "enemy_killed": 0,
                             "spawn_delay": (60 * 2.2),
                             "spawn_counter": 0,
                             "boss_out": False,}
        self.running = True

    def openingScene (self):

        to_play = [sfx.AI_greeting, sfx.AI_mission]
        running = True
        for index, sound in enumerate(to_play):
            sound.play()
            while running:
                self.time_passed = self.clock.tick(60)/1000.0
                if not pygame.mixer.get_busy():
                    break
                for event in pygame.event.get():
                    if event.type == QUIT:
                        running = False
                        self.running = False
                        return
                    if event.type == KEYDOWN and event.key == K_ESCAPE:
                        running = False
                        sound.stop()
                        return
                
                self.manageSprite(Background.container)
                text = "SPACEBAR = FIRE ZE LASERS"
                surface = self.font.render(text, True, (255,255,255))
                self.screen.blit(surface, (self.screensize[0]/2-120, 250))
                text = "M = FIRE A MISSILE"
                surface = self.font.render(text, True, (255,255,255))
                self.screen.blit(surface, (self.screensize[0]/2-120, 280))
                text = "N = LAUNCH NUCLEAR WARHEAD"
                surface = self.font.render(text, True, (255,255,255))
                self.screen.blit(surface, (self.screensize[0]/2-120, 310))
                text = "E = EMP (Scorpion Upgrade Line)"
                surface = self.font.render(text, True, (255,255,255))
                self.screen.blit(surface, (self.screensize[0]/2-120, 340))
                text = "R = Repair (Collect Wrenches)"
                surface = self.font.render(text, True, (255,255,255))
                self.screen.blit(surface, (self.screensize[0]/2-120, 370))
                text = "PRESS Esc TO SKIP INTRO"
                surface = self.med_font.render(text, True, (255,255,255))
                self.screen.blit(surface, (self.screensize[0]/2-250, 450))
                self.manageSprite(self.player.container)
                pygame.display.flip()


    def assembleImages(self):

        image_path = os.path.join("backgrounds", choice(BACKGROUNDS))

        backgroundTL = ScrollingBackground(image_path)
        backgroundBL = ScrollingBackground(image_path)
        backgroundTL.rect.bottom = backgroundBL.rect.top
        width = backgroundTL.rect.width
        height = backgroundTL.rect.height

        global screenrect
        screenrect = Rect(0,0,backgroundTL.rect.width,backgroundTL.rect.height)
        display = pygame.display.Info()
        if display.current_h < 1000:
            height = display.current_h 
        return (width, height)

    def manageSprite (self, container):

        container.update(self.time_passed)
        container.draw(self.screen)

    def spawnEnemies (self):

        spwn = self.spawner
        if spwn["spawn_counter"] >= spwn["spawn_delay"]:
            if len(Enemy.container) < spwn["max_enemies"]:
                if self.level -3 in range(3):
                    enemy = choice([Drone, Warship])(self.screensize,
                                                     self.player,
                                                     self.level)
                elif self.level > 6:
                    enemy = choice([Drone, Warship, Bomber])(self.screensize, 
                                                             self.player, 
                                                             self.level)
                else:
                    enemy = Drone(self.screensize, self.player, self.level)
                if self.level > 10:
                    enemy.armor["T"] *= 2
                    enemy.armor["M"] *= 2
                HealthBar(enemy, self.screen)
                spwn["spawn_counter"] = 0
        else:
            if not spwn["boss_out"]:
                spwn["spawn_counter"] += 1

        if spwn["enemy_killed"] >= spwn["max_enemies"]+(
                5+self.level*3) and (spwn["boss_out"] == False):
            sfx.stab.play()
            self.boss = Boss(self.screensize, self.player, self.level)
            self.boss.rect.midbottom = (self.screensize[0]/2, 0)
            spwn["enemy_killed"] = 0
            spwn["boss_out"] = True
            spwn["max_enemies"] += 1
            HealthBar(self.boss, self.screen)

    def gameOver (self):

        # Do all the game over stuff here...
        self.running = False # True for debugging purposes - set to False to end game

    def playerDamage (self, enemy, projectiles):

        for proj in projectiles:
            proj.explode()
            if enemy.decreaseHealth(proj.damage) <= 0:
                if type(enemy).__name__ == "Guard":
                    self.boss.guards_out -= 1
                    self.player.exp += enemy.armor["M"]
                    enemy.die(sfx.muffled_explosion)
                    return
                self.spawner["enemy_killed"] += 1
                if type(enemy).__name__ == "Drone":
                    self.player.exp += enemy.armor["M"]+1
                else:
                    self.player.exp += enemy.armor["M"]
                chance = randint(1,13)
                if chance in [12, 13]:
                    new_powerup = Wrench()
                    new_powerup.rect.center = enemy.rect.center
                    PowerUpGlow(new_powerup)
                elif chance == 2:
                    new_powerup = Bullet()
                    new_powerup.rect.center = enemy.rect.center
                    PowerUpGlow(new_powerup)
                elif chance == 3:
                    new_powerup = MissileReload()
                    new_powerup.rect.center = enemy.rect.center
                    PowerUpGlow(new_powerup)
                elif chance == 4:
                    new_powerup = GunUpgrade()
                    new_powerup.rect.center = enemy.rect.center
                    PowerUpGlow(new_powerup)
                enemy.die(sfx.muffled_explosion)
                break

    def collisionCheck (self, collide):

        # Check if the player has shot an enemy (non boss)
        kpow = collide(Enemy.container, Fireball.container, False, True)
        if kpow:
            for enemy in kpow:
                self.playerDamage(enemy, kpow[enemy])
        # Check if an enemy has shot the player
        boom = collide(EnemyFireball.container, self.player.container, True, False)
        if boom:
            if self.player.decreaseHealth(1) <= 0:
                self.player.die()
        # Check if the player crashed into an enemy
        bang = collide(Enemy.container, self.player.container, False, False)
        if bang:
            for enemy in bang:
                e_armor = enemy.armor["T"]
                if type(enemy).__name__ == "Guard":
                    self.boss.guards_out -= 1
                enemy.die(sfx.muffled_explosion)
                if self.player.decreaseHealth(e_armor) <= 0:
                    self.player.die()
        # Check if the player has shot a boss
        bash = collide(Fireball.container, Boss.container, True, False)
        if bash:
            for projectile in bash:
                if not self.boss.invincible:
                    if self.boss.decreaseHealth(projectile.damage) <= 0:
                        self.spawner["boss_out"] = False
                        self.player.exp += self.boss.armor["M"]
                        self.level += 1
                        self.boss.die(sfx.muffled_explosion)
                        self.boss = None
                        self.player.ranks["remaining"] += 1
                        text = "New Upgrades! (Press ESC)"
                        self.notify["msg"] = self.med_font.render(text, True, (255,255,255))
                        break
                    projectile.explode()
        # Check if the player has grabbed a PowerUp
        ding = collide(PowerUp.container, self.player.container, True, False)
        if ding:
            for power in ding:
                power.effect(self.player)

    def showStats (self):

        fr = self.font.render
        if self.player.lives < 0:
            text = "Game Over..."
            surface = self.big_font.render(text, True, (255,255,255))
            self.screen.blit(surface, (200, self.screensize[1]/2-75))
            text = "EXP: %s -- LEVEL: %s" %(game.player.exp, game.level)
            surface = fr(text, True, (255,255,255))
            self.screen.blit(surface, (350, self.screensize[1]/2))
        else:
            text = "Level: %s" %(game.level)
            surface = fr(text, True, (255,255,255))
            self.screen.blit(surface, (10, 10))
            text = "EXP: %s" %(int(round(game.player.exp)))
            surface = fr(text, True, (255,255,255))
            self.screen.blit(surface, (10, 30))
            text = "Escape Pods: %s" %(game.player.lives)
            surface = fr(text, True, (255,255,255))
            self.screen.blit(surface, (10, 50))
            text = game.player.getHitPercentage()
            surface = fr(text, True, (255,255,255))
            self.screen.blit(surface, (10, 70))
            text = "Armor: %s/%s" % (game.player.armor["T"], game.player.armor["M"])
            surface = fr(text, True, (255,255,255))
            self.screen.blit(surface, (10, self.screensize[1]-50))
            text = "Missiles: %s" %(self.player.missiles)
            surface = fr(text, True, (255,255,255))
            self.screen.blit(surface, (self.screensize[0]-180, 10))
            text = "Repair Drones: %s" %(self.player.wrenches)
            surface = fr(text, True, (255,255,255))
            self.screen.blit(surface, (self.screensize[0]-180, 30))
            text = "Nukes: %s" %(game.player.nukes)
            surface = fr(text, True, (255,255,255))
            self.screen.blit(surface, (self.screensize[0]-180, 50))
            if self.player.missile:
                text = "NEXT MISSILE: 0:%s" %(round(game.player.missile_timer[1],1))
                surface = fr(text, True, (255,255,255))
                self.screen.blit(surface, (self.screensize[0]-180, 70))
            if self.player.emp:
                text = "NEXT EMP: 0:%s" %(round(game.player.emp["timer"][1],1))
                surface = fr(text, True, (255,255,255))
                self.screen.blit(surface, (self.screensize[0]-180, 90))


    def displayNotifications (self):

        if not self.notify["msg"]: return
        if self.notify["timer"][1] >= self.notify["timer"][0]:
            self.notify["msg"] = None
            self.notify["timer"][1] = 0
        else:
            self.screen.blit(self.notify["msg"], (275, int(self.screensize[1]/3-50)))
            self.notify["timer"][1] += 1

    def eventCheck(self, event):

        if event.type == QUIT:
            self.running = False
        if event.type == KEYDOWN:
            if event.key == K_p or event.key == K_ESCAPE: # Pause the game and open the menu
                self.menu = MainMenu(self)
                self.menu.run()
            if event.key == K_SPACE:
                self.player.shooting = True
            if event.key == K_UP:
                self.player.moving.add("forward")
            if event.key == K_DOWN:
                self.player.moving.add("back")
            if event.key == K_RIGHT:
                self.player.moving.add("right")
            if event.key == K_LEFT:
                self.player.moving.add("left")
            if event.key == K_e:
                if self.player.emp:
                    self.player.triggerEmp(self.screen, Enemy.container, self.boss)
            if event.key == K_m:
                self.player.missile(Enemy.container, self.boss)
            if event.key == K_n:
                self.player.nuke(self.screen, Enemy.container, self.boss)
            if event.key == K_r:
                self.player.repair()
            if event.key == K_EQUALS:
                self.volume += 0.1
                if self.volume > 1:
                    self.volume = 1.0
                pygame.mixer.music.set_volume(self.volume)
            if event.key == K_MINUS:
                self.volume -= 0.1
                if self.volume < 0:
                    self.volume = 0.0
                pygame.mixer.music.set_volume(self.volume)
        if event.type == KEYUP:
            if event.key == K_SPACE:
                self.player.shooting = False
            if event.key == K_UP:
                self.player.moving.remove("forward")
            if event.key == K_DOWN:
                self.player.moving.remove("back")
            if event.key == K_RIGHT:
                self.player.moving.remove("right")
            if event.key == K_LEFT:
                self.player.moving.remove("left")

    def run (self):

        #self.notify["msg"] = self.med_font.render("Pew Pew Space", True, (255,255,255))
        self.openingScene()

        sfx.play_music()
        collide = pygame.sprite.groupcollide

        while self.running:
            self.time_passed = self.clock.tick(60)/1000.0
            pygame.display.set_caption("[FPS -- %s]" %(int(self.clock.get_fps())))
            for event in pygame.event.get():
                self.eventCheck(event)

            self.spawnEnemies()
            self.manageSprite(Background.container)           # Background
            self.showStats()                                  # Stats
            self.displayNotifications()                       # Notifications
            self.manageSprite(Passive.container)              # Passive sprites
            self.manageSprite(Animation.container)            # Animations
            self.manageSprite(Fireball.container)             # Player's bullets
            self.manageSprite(Missile.container)              # Player missiles
            self.manageSprite(Boss.container)                 # Boss
            self.manageSprite(EnemyFireball.container)        # Enemy's bullets
            self.manageSprite(Enemy.container)                # Enemies
            self.manageSprite(HealthBar.container)            # Healthbars
            self.manageSprite(PowerUp.container)              # PowerUps
            self.manageSprite(self.player.container)          # Player
            self.collisionCheck(collide)                      # Collisions
            pygame.display.flip()                             # Update dislplay