示例#1
0
def test_player_incoming_miss():
    player1 = Player(1)
    assert player1.incoming(2, 2) == {
        'hit': False,
        'sunk': False,
        'winner': False
    }
    def initialize_players(self):
        if self.lan_mode and len(self.players) < self.play_num:
            self.master.master.after(1000, self.initialize_players)
        else:
            # Play num in joined mode is 0
            for i in range(self.play_num):
                pl = Player(self.players[i])
                pl.draw_letters(self.bag)
                self.players.append(pl)

                # If the game is against a computer, no need for the second
                # iteration because its class is different
                if self.comp_mode:
                    self.opponent = AIOpponent()
                    self.opponent.draw_letters(self.bag)
                    self.players.append(self.opponent)

                    break

            # Deletes the name strings
            del self.players[:self.play_num]

            if self.lan_mode:
                self.queue.put(self.players)

            self.init_turn()
示例#3
0
    def reset(self):
        self.level = 1
        self.xp = 1
        self.hp = 10
        self.max_hp = 10
        self.attack = 1
        self.prev_level = 1
        self.high_score_current = self.score_display.score_read()
        self.player = Player(self.hp, self.attack, self.max_hp,
                             self.display_width, self.display_height,
                             self.health_bar, pygame)
        self.crashed = False
        self.enemies = []
        self.point = 0
        self.xp_new = 100
        self.enemy_spawn_time = 5
        self.multiplier = 1
        self.items = []

        for count in range(0, 5):
            test_enemy = Enemy(random.randint(0, self.display_width),
                               random.randint(0, self.display_height),
                               self.health_bar, pygame, self.multiplier)
            self.enemies.append(test_enemy)

        self.add_enemy()
示例#4
0
class Controller:

    def __init__(self):
        self.status = ''
        self.monsters = [
            Spider,
            Ghoul
        ]
        self.player_dead = False
        
    def start_game(self):
        self.player = Player()

    def fight(self):
        monster = self.create_monster(self.player.level)
        while True:
            print("player health: {0} player mana: {1}\n{2} health: {3}".format(
                self.player.curr_stats['health'],
                self.player.curr_stats['mana'],
                monster.name,
                monster.curr_stats['health']
            ))
            player_move = self.player.choose_move()
            self.apply_status_changes(player_move, self.player, monster)
            if monster.curr_stats['health'] <= 0:
                self.display_success_message(monster)
                self.player.gain_exp(monster.exp)
                break
            self.apply_status_changes(monster.choose_move(), monster, self.player)
            if self.player.curr_stats['health'] <= 0:
                self.display_death_message(monster)
                self.player_dead = True
                raise PlayerDeath()
                
        return monster

    def regain(self):
        print('Regained HP and Mana!')
        self.player.curr_stats['health'] = self.player.max_stats['health']
        self.player.curr_stats['mana'] = self.player.max_stats['mana']

    def display_death_message(self, monster):
        print(monster.player_death_msg)

    def display_success_message(self, monster):
        print(monster.monster_death_msg)

    def apply_status_changes(self, modifiers, action_doer, action_enemy):
        action_doer.curr_stats['health'] += modifiers['health']
        action_doer.curr_stats['mana'] -= modifiers['mana']
        action_doer.curr_stats['defense'] += modifiers['defense']
        action_enemy.curr_stats['health'] -= modifiers['attack'] + action_enemy.curr_stats['defense']

    def create_monster(self, level):
        possible_monsters = []
        for monster in self.monsters:
            if abs(monster().level_spawn - level) <= 5:
                possible_monsters.append(monster)
        monster_klass = random.choice(possible_monsters)
        return monster_klass()
示例#5
0
class App:
    def __init__(self, is_prod=False):
        pygame.init()
        inf = pygame.display.Info()
        pygame.mouse.set_visible(False)
        flags = pygame.FULLSCREEN if is_prod else pygame.RESIZABLE
        window = pygame.display.set_mode([inf.current_w, inf.current_h], flags)
        self.player = Player()
        self.text = MirrorText('', window)
        self.is_running = False

    def start(self):
        if not self.is_running:
            self.player.play()
            self.text.run()
            self.is_running = True

    def stop(self):
        if self.is_running:
            try:
                Player.stop()
                self.text.stop()
                self.is_running = False
            except Exception as err:
                print("[App.stop(self)] threw an exception %d" % err)

    def exit(self):
        self.stop()
        while self.text.thr.isAlive():
            pygame.time.delay(10)
        pygame.quit()
示例#6
0
 def on_scene_enter(self):
     #glEnable(GL_POINT_SMOOTH)
     #glEnable(GL_TEXTURE_2D)
     self.player = Player()
     self.players = [self.player]
     self.dynamic.append(self.player)
     self.last_lead = self.player.position = self.campos = self.cam_spline.get_point(0)
     clock.schedule(self.update)
 def setUp(self):
     card_one = Card("Heart", "5", 5)
     card_two = Card("Diamond", "Jack", 11)
     card_three = Card("Spade", "7", 7)
     card_four = Card("Spade", "Ace", 14)
     cards = [card_one, card_two, card_three, card_four]
     self.deck = Deck(cards)
     self.player = Player("John", self.deck)
示例#8
0
 def stop(self):
     if self.is_running:
         try:
             Player.stop()
             self.text.stop()
             self.is_running = False
         except Exception as err:
             print("[App.stop(self)] threw an exception %d" % err)
示例#9
0
def test_player_incoming_hit():
    player1 = Player(1)
    player1.board.place_ship(player1.ships[0], 2, 2)
    assert player1.incoming(2, 2) == {
        'hit': True,
        'sunk': False,
        'winner': False
    }
示例#10
0
 def test_player_updates_play_state(self):
     player = Player()
     # assert default player state
     assert player.in_game is True
     # assert we can set player to inactive
     player.in_game = False
     # assert that the player state has changed
     assert player.in_game is False
示例#11
0
 def __init__(self, is_prod=False):
     pygame.init()
     inf = pygame.display.Info()
     pygame.mouse.set_visible(False)
     flags = pygame.FULLSCREEN if is_prod else pygame.RESIZABLE
     window = pygame.display.set_mode([inf.current_w, inf.current_h], flags)
     self.player = Player()
     self.text = MirrorText('', window)
     self.is_running = False
示例#12
0
 def startGame(self):
     self.player = Player()
     self.enemies = []
     self.amountOfEnemies = 0
     self.spawnEnemy()
     self.clock = pygame.time.Clock()
     self.timer = 0
     self.enemyTimer = 0
     self.timeUntilEnemySpawns = 2000
     self.gameState = "GAME"
示例#13
0
文件: window.py 项目: fryntiz/gMusic
    def __init__(self):
        app_builder = ApplicationWindow.builder
        app_builder.add_from_file("gui.glade")

        app_builder.connect_signals(Player())

        _switch_status = app_builder.get_object('switch_status')
        if Player().is_server_active():
            _switch_status.set_active(True)

        window = app_builder.get_object("mainWindow")
        window.show_all()
示例#14
0
    def __init__(self):
        deck = Deck.shuffle()
        self.trump = deck[-1]

        hand1 = deck[:HAND_SIZE]
        deck = deck[HAND_SIZE:]

        hand2 = deck[:HAND_SIZE]

        self.deck = deck[HAND_SIZE:]
        self.ai = AIPlayer(self, hand1)
        self.player = Player(self, hand2)
        self.set_first_turn()
示例#15
0
    def main(self):
        pygame.init()

        self.DISPLAYSURF = pygame.display.set_mode(
            (WINDOW_WIDTH, WINDOW_HEIGHT))

        pygame.display.set_caption('Hello World!')
        self.playerImg = pygame.image.load('./pics/player.png')
        self.appleImg = pygame.image.load('./pics/apple.png')
        self.player = Player()
        self.apple = Apple()

        self.score = 0
        self.clock = pygame.time.Clock()

        # Text
        self.font = pygame.font.Font('freesansbold.ttf', 16)
        self.text = self.font.render('Score: ' + str(self.score), True, white,
                                     black)
        self.textRect = self.text.get_rect()
        self.textRect.x = 1200
        self.textRect.y = 700

        while True:

            # Event Handler
            for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_LEFT:
                        self.player.moveLeft()

                    if event.key == pygame.K_UP:
                        self.player.moveUp()

                    if event.key == pygame.K_DOWN:
                        self.player.moveDown()

                    if event.key == pygame.K_RIGHT:
                        self.player.moveRight()

                    if event.key == pygame.K_ESCAPE:
                        self.die()

                if event.type == QUIT:
                    self.die()

            self.player.update()
            self.checkCollision()
            self.draw()
            pygame.display.update()
            time.sleep(50.0 / 1000.0)
示例#16
0
def addSummaries(urlGen, queue, players, gender,friends):    
    # read number of records to pull
    numScrape = 10 
    if len(sys.argv) == 2:
        numScrape = int(sys.argv[1])

    while (numScrape > 0):
        pid = queue.next()
        print pid
        try:
            player = Player(getPlayerInfo(urlGen, pid), players.connection)
            if not player.isPrivate():
                player.addPlayerInfoToDB()
                player.addGender(gender)
                friendsList = getFriendIds(urlGen, pid)
                if friendsList != "none": 
                    player.addNumFriends(friendsList)
                print queue.count, "|",player.steamid,  player.firstName, player.gender, player.genderConf, player.loccountrycode, player.locstatecode,"friends",player.numFriends, " remaining: ", numScrape
                if player.loccountrycode == "US" and  player.locstatecode != "CA": # we are targeting americans
                    friends.addFriends(pid, friendsList)
                    print "\tadding friends from player from ", player.loccountrycode
                    for friend in friendsList:
                        if not (queue.inQueue(friend) or players.inPlayers(friend)):
                            queue.push(friend)
            queue.free(player.steamid)
        except UnicodeEncodeError :
            print "UnicodeEncodeError"
            queue.free(pid)
        numScrape -= 1
示例#17
0
def train():

    env = Environment()
    player = Player()

    for episode in range(2):
        env.start()

        while True:
            actions = player.act(env.state)
            reverd = env.apply(actions)
            player.learn(reverd)
            if env.done:
                break
    return
示例#18
0
    def __init__(self):
        pygame.init()
        self.display_width = 790
        self.display_height = 740
        self.level = 1
        self.xp = 1
        self.hp = 10
        self.max_hp = 10
        self.attack = 1
        self.talent_point = 0
        self.prev_level = 1
        self.name = "test name"
        self.score_display = ScoreScreen()
        self.high_score_current = self.score_display.score_read()
        self.is_paused = False
        pygame.display.set_caption('Taemasu v0.1')
        self.health_bar = pygame.image.load('lib/img/healthbar.png')
        self.player = Player(self.hp, self.attack, self.max_hp,
                             self.display_width, self.display_height,
                             self.health_bar, pygame)
        self.game_display = pygame.display.set_mode((1200, 1200))
        self.white = (255, 255, 255)
        self.clock = pygame.time.Clock()
        self.crashed = False
        self.game_display.fill(self.white)
        self.enemies = []
        self.sword = pygame.image.load('lib/img/sword.png')
        self.map = Map('maptest.txt', self.display_width, self.display_height,
                       pygame)
        pygame.font.init()  # you have to call this at the start,
        # if you want to use this module.
        self.myfont = pygame.font.SysFont('Comic Sans MS', 30)
        self.point = 0
        self.xp_new = 100
        self.background = pygame.image.load('lib/img/background4.png')
        self.enemy_spawn_time = 2
        self.multiplier = 1
        self.start = True
        self.items = []
        self.exiting = False

        for count in range(0, 5):
            test_enemy = Enemy(random.randint(0, self.display_width),
                               random.randint(0, self.display_height),
                               self.health_bar, pygame, self.multiplier)
            self.enemies.append(test_enemy)

        self.add_enemy()
示例#19
0
 def setup_game(self):
     player1_letter = input(
         "What letter would Player 1 like to user? (X or O)?: ").upper()
     if player1_letter not in ['X', 'O']:
         #NOTE the player won't see this as is
         print(
             'Invalid input! Automatically selecting X for Player 1 and O for Player 2'
         )
         player1_letter = 'X'
         player2_letter = 'O'
     else:
         print('Assigned %s to Player 1' % player1_letter)
         player2_letter = 'O' if player1_letter == 'X' else 'X'
         print('Assigned %s to Player 2' % player2_letter)
     self.p1 = Player('Player 1', player1_letter, self.size)
     self.p2 = Player('Player 2', player2_letter, self.size)
示例#20
0
    def _configure_default_features(self):
        '''
            Import dependencies and configure default features.
        '''
        self._log.warning('configure default features...')
        from lib.button import Button
        self._log.info('configuring button...')
        self._ros._button = Button(self._ros._config,
                                   self._ros.get_message_queue(),
                                   self._ros._mutex)

        from lib.bumpers import Bumpers
        self._log.info('configuring bumpers...')
        self._ros._bumpers = Bumpers(self._ros._config,
                                     self._ros.get_message_queue(), None,
                                     Level.INFO)

        from lib.infrareds import Infrareds
        self._log.info('configuring infrared trio...')
        self._ros._infrareds = Infrareds(self._ros._config,
                                         self._ros.get_message_queue(),
                                         Level.INFO)

        from lib.player import Sound, Player
        self._log.info('configuring player...')
        self._ros._player = Player(Level.INFO)

        self._log.warning('default features ready.')
示例#21
0
 def setUp(self):
   card_one = Card("Heart", "5", 5)
   card_two = Card("Diamond", "Jack",11)
   card_three = Card("Spade", "7", 7)
   card_four = Card("Spade", "Ace", 14)
   cards = [card_one, card_two, card_three, card_four]
   self.deck = Deck(cards)
   self.player1 = Player("John", self.deck)
   card_five = Card("Heart", "8", 8)
   card_six = Card("Diamond", "Jack",11)
   card_seven = Card("Spade", "3", 3)
   card_eight = Card("Club", "Queen", 12)
   cards2 = [card_five, card_six, card_seven, card_eight]
   self.deck2 = Deck(cards2)
   self.player2 = Player("John", self.deck2)
   self.turn = Turn(self.player1, self.player2)
示例#22
0
    def __init__(self):
        pygame.init()
        self.options = Options(self)
        self.screen = pygame.display.set_mode(self.options.window_size)
        self.icon = Image("game_icon.png")
        self.caption = "Sunni (Alpha 3.0.0)"
        self.keys = Keys(self)
        self.page = None
        self.file_directory = os.getcwd()[:-3]
        self.mouse = Mouse()
        self.clock = pygame.time.Clock()
        self.fps = 30
        self.start_time = time.time()
        self.current_time = 0   # The amount of time the program as been running
        self.music = Music(self)
        self.saves = [Save(n) for n in range(4)]
        self.selected_save = None
        self.is_running = True
        self.next_battle = None

        self.main_menu = MainMenu(self)
        self.opening_sequence = OpeningSequence(self)
        self.opening_sequence.visit()
        self.new_game_page = NewGamePage(self)
        self.load_game_page = LoadGamePage(self)

        self.player = None
        self.opponent = None

        self.initialise()
        OpeningSequence.initialise()
        NewGamePage.initialise()
        LoadGamePage.initialise()
        Surface.initialise(self)
        Options.initialise()
        Move.initialise(self)
        Character.initialise()
        Player.initialise()
        MainMenu.initialise()
        MemeDog.initialise()
        Battle.initialise()

        self.opponents = OrderedDict()
        self.opponents["Meme Dog"] = MemeDog
        self.opponents["Kanye Snake"] = KanyeSnake
        self.opponents["Spook Dog"] = SpookDog
        self.opponents["Evil Cloud"] = EvilCloud
示例#23
0
 def __init__(self):
     """
     Initiates a Game object with the necessary features
     """
     self.dealer = Dealer(self)  # The dealer
     self.player = Player(
         self
     )  # The players: eventually change this to a list of players to allow for more than one
示例#24
0
    def __init__(self):
        """Starts the game"""
        # Create the window and register the draw handler
        self.window = pyglet.window.Window(caption='Pysteroids',
                                           width=WINDOW_WIDTH,
                                           height=WINDOW_HEIGHT)
        self.window.on_draw = self.on_draw

        # Add key handler to keep track of key presses
        self.keys = key.KeyStateHandler()
        self.window.push_handlers(self.keys)

        # Grab an absolute directory name for the game path
        # This helps when loading resources on an installed version
        # of Pysteroids
        game_path = os.path.dirname(os.path.abspath(__file__))
        pyglet.resource.path = [game_path + '/lib/res',
                                game_path + '/lib/res/sounds']
        pyglet.resource.reindex()

        # Grab the game's effect player
        self.effect_player = EffectPlayer.instance()

        # Create the player
        self.player = Player()

        # Create game rules and an asteroid manager to generate
        # asteroids
        self.asteroid_manager = AsteroidManager(self.on_level_change)

        # Create a label for displaying the number of lives left
        self.lives_left_label = \
            pyglet.text.Label('Lives Left: ' + str(self.player.lives_left),
                              font_name='Droid Sans Mono',
                              font_size=12,
                              x=70, y=WINDOW_HEIGHT-15,
                              anchor_x='center', anchor_y='center')

        # Create a score label
        self.score_label = \
            pyglet.text.Label('Score: ' + str(self.player.score),
                              font_name='Droid Sans Mono',
                              font_size=12,
                              x=WINDOW_WIDTH-70, y=WINDOW_HEIGHT-15,
                              anchor_x='center', anchor_y='center')

        # Create a lable for displaying the current level
        self.level_label = \
            pyglet.text.Label('Level: ' + str(self.asteroid_manager
                                                  .curr_level_num),
                              font_name='Droid Sans Mono',
                              font_size=12,
                              x=WINDOW_WIDTH // 2, y=WINDOW_HEIGHT-15,
                              anchor_x='center', anchor_y='center')

        # Register and schedule the update function
        pyglet.clock.schedule(self.update)
示例#25
0
def test_player_take_turn_miss():
    player1 = Player(1)
    player2 = Player(2)
    player1.add_opponent(player2)
    player2.board.place_ship(player2.ships[0], 2, 2)
    assert player2.ships[0].length == 2
    player1.take_turn(2, 4, 2)
    assert player2.ships[0].length == 2
示例#26
0
    def reset(self):
        """Reset the game"""
        self.player = Player()
        self.asteroid_manager = AsteroidManager(self.on_level_change)

        # Reset the level number label
        self.level_label.text = ('Level: ' + str(self.asteroid_manager
                                                     .curr_level_num))

        # Reset score label
        self.score_label.text = 'Score: ' + str(self.player.score)
示例#27
0
 def __init__(self, pnames):
     """
     :param pnames: An Array. Name of the players as Strings
     """
     self.board = Board()
     self.players = tuple([Player(pn, self.board, self) for pn in pnames])
     self.plookup = {p.getId(): p for p in self.players}
     self.lastRoll = None
     self.p = None
     self.getFirstPlayer()
     self.state = 0
示例#28
0
文件: db.py 项目: doylezdead/phase10
def new_player(session, game_id):
    game = get_game(session, game_id)
    num = len(get_players(session, game_id))
    new_player = Player(game_id=game_id, player_id=num)
    print(new_player.__dict__)
    session.add(new_player)
    session.flush()
    pid = new_player.player_id
    game.ac += 1
    session.commit()
    return pid
示例#29
0
def main():
    skills = Skills()
    skills.combative = SkillRatings.superior
    skills.social = SkillRatings.average
    skills.kinetic = SkillRatings.above_average
    skills.technical = SkillRatings.average
    chris = Player(skills)
    print(chris.skills)

    playerdeck = Deck()
    playerdeck.shuffle()

    chris.hand = playerdeck.draw(3)
    print(chris.hand)

    card_index = int(input('Please Select Card to Play:\n[0] {0}\n[1] {1}\n[2] {2}\n'.format(chris.hand[0], chris.hand[1], chris.hand[2])))

    play_card = chris.play(card_index)
    print(play_card)
    print(chris.hand)
示例#30
0
def test_player_sink_an_opponent_ship():
    player1 = Player(1)
    player2 = Player(2)
    player1.add_opponent(player2)
    player2.board.place_ship(player2.ships[0], 2, 2)
    assert player1.take_turn(2, 2, 2)['sunk'] == False
    assert player1.take_turn(2, 3, 2)['sunk'] == True
示例#31
0
def main():

    signal.signal(signal.SIGINT, signal_handler)

    _log = Logger('play_test', Level.INFO)

    try:
        _log.info('executing player tests...')

        _player = Player(Level.INFO)

        _player.play(Sound.BLIP)
        time.sleep(3.0)

        _player.play(Sound.ALARM)
        time.sleep(3.0)

        _log.info('test complete.')

    except KeyboardInterrupt:
        _log.warning('Ctrl-C caught: complete.')
    except Exception as e:
        _log.error('error in test: {}'.format(e))
        traceback.print_exc(file=sys.stdout)
        sys.exit(1)
    finally:
        sys.exit(0)
 def on_scene_enter(self):
     clock.schedule(self.update)
     
     self.player = Player()
     self.players = [self.player]
     self.generate_level()
     
     # set up collision detection
     self.coll_detector = collision.CollisionDetector()
     
     # collisions between:
     # flock-player, player-bullets, player-objstacles, bulltets-obstacles, bullets-flock
     #self.coll_detector.register_once(self, group_name1, group_name2, group1, group2, coll_strategy, type_tuple, func):
     self.coll_detector.register_group('player', self.players)
     self.coll_detector.register_group('flocks', self.flocks)
     self.coll_detector.register_group('obstacles', self.obstacles)
     self.coll_detector.register_group('enemies', self.enemies)
     self.coll_detector.register_group('bullets', self.bullets)
     self.coll_detector.register_pair('player', 'flocks', PlayerFlockCollisionStrategy(self))
     self.coll_detector.register_pair('player', 'bullets', PlayerBulletsCollisionStrategy(self))
     self.coll_detector.register_pair('player', 'obstacles', PlayerObstaclesCollisionStrategy(self))
     self.coll_detector.register_pair('bullets', 'obstacles', BulletsObstaclesCollisionStrategy(self))
     self.coll_detector.register_pair('flocks', 'bullets', FlockBulletsCollisionStrategy(self))
     
     #self.coll_detector.register_once('player', 'flocks', self.players, self.flocks, PlayerFlockCollisionStrategy(self), tuple(), None):
     
     # enemy
     #scene, fire_rate, position, orientation)
     self.enemies.append( Enemy(self, 1, Vec3(300, 10), Vec3(0, 1) * 100.0) )
     self.enemies.append( Enemy(self, 0.1, Vec3(10, 200), Vec3(1, -0.1) * 300.0) )
     self.enemies.append( Enemy(self, 1, Vec3(500, 10), Vec3(0, 1) * 200) )
     
     p = Polygon()
     p.add_vertex(400, 400)
     p.add_vertex(550, 400)
     p.add_vertex(550, 420)
     p.add_vertex(400, 450)
     self.obstacles.append(p)
class TestPlayer(unittest.TestCase):
    def setUp(self):
        card_one = Card("Heart", "5", 5)
        card_two = Card("Diamond", "Jack", 11)
        card_three = Card("Spade", "7", 7)
        card_four = Card("Spade", "Ace", 14)
        cards = [card_one, card_two, card_three, card_four]
        self.deck = Deck(cards)
        self.player = Player("John", self.deck)

    def test_it_exists(self):
        assert type(self.player) == Player
        assert self.player.name == 'John'
        assert self.player.deck == self.deck

    def test_has_lost(self):
        assert self.player.has_lost() == False
        self.player.deck.remove_card()
        self.player.deck.remove_card()
        assert self.player.has_lost() == False
        self.player.deck.remove_card()
        self.player.deck.remove_card()
        assert self.player.has_lost() == True
示例#34
0
def main():
    skills = Skills()
    skills.combative = SkillRatings.superior
    skills.social = SkillRatings.average
    skills.kinetic = SkillRatings.above_average
    skills.technical = SkillRatings.average
    chris = Player(skills)
    print(chris.skills)

    playerdeck = Deck()
    playerdeck.shuffle()

    chris.hand = playerdeck.draw(3)
    print(chris.hand)

    card_index = int(
        input(
            'Please Select Card to Play:\n[0] {0}\n[1] {1}\n[2] {2}\n'.format(
                chris.hand[0], chris.hand[1], chris.hand[2])))

    play_card = chris.play(card_index)
    print(play_card)
    print(chris.hand)
示例#35
0
  def __init__(self, size_x, size_y, resize):
    super(Window, self).__init__(resizable = resize, visible = True, vsync = False)
    self.set_size(size_x, size_y)
    self.set_caption('SpaceCow')
    self.maximize()

    self.player = Player((self.width / 2), (self.height / 2), 0, "resources/ship.png")

    for enemies in range(self.enemy_qty):
      self.enemy.append(Enemy((self.width / 2), (self.height / 2), 0, "resources/cow.png"))

    for e in self.enemy:
      e.x_pos = randint(0, self.width)
      e.y_pos = randint(0, self.height)
      e.rotation = randint(0, 360)

    self.player.x_pos = self.width / 2
    self.player.y_pos = self.height / 2
    self.label_mouse_xy = pyglet.text.Label("Mouse Location")

    self.play_bg_music()
示例#36
0
class Pysteroids(object):
    """Runs the game and manages game variables

    Attributes:
        window: the game window
        keys: the key state
        ship: the player's ship
        asteroids: a list of the currently active asteroids
        effect_player: the EffectPlayer used to play animations and
                       sounds
        fps_display: a display to show the current FPS of the
                     application
        game_rules: the current set of game rules, defining how
                    many asteroids can be on the screen per type
        asteroid_manager: the AsteroidManager responsible for
                          generating new asteroids based on the game
                          rules
        lives_left_label: a label for displaying the number of lives
                          the player has left
        score_label: a label for displaying the player's score
        level_label: a label for displaying the current level the
                     player is on
    """
    def __init__(self):
        """Starts the game"""
        # Create the window and register the draw handler
        self.window = pyglet.window.Window(caption='Pysteroids',
                                           width=WINDOW_WIDTH,
                                           height=WINDOW_HEIGHT)
        self.window.on_draw = self.on_draw

        # Add key handler to keep track of key presses
        self.keys = key.KeyStateHandler()
        self.window.push_handlers(self.keys)

        # Grab an absolute directory name for the game path
        # This helps when loading resources on an installed version
        # of Pysteroids
        game_path = os.path.dirname(os.path.abspath(__file__))
        pyglet.resource.path = [game_path + '/lib/res',
                                game_path + '/lib/res/sounds']
        pyglet.resource.reindex()

        # Grab the game's effect player
        self.effect_player = EffectPlayer.instance()

        # Create the player
        self.player = Player()

        # Create game rules and an asteroid manager to generate
        # asteroids
        self.asteroid_manager = AsteroidManager(self.on_level_change)

        # Create a label for displaying the number of lives left
        self.lives_left_label = \
            pyglet.text.Label('Lives Left: ' + str(self.player.lives_left),
                              font_name='Droid Sans Mono',
                              font_size=12,
                              x=70, y=WINDOW_HEIGHT-15,
                              anchor_x='center', anchor_y='center')

        # Create a score label
        self.score_label = \
            pyglet.text.Label('Score: ' + str(self.player.score),
                              font_name='Droid Sans Mono',
                              font_size=12,
                              x=WINDOW_WIDTH-70, y=WINDOW_HEIGHT-15,
                              anchor_x='center', anchor_y='center')

        # Create a lable for displaying the current level
        self.level_label = \
            pyglet.text.Label('Level: ' + str(self.asteroid_manager
                                                  .curr_level_num),
                              font_name='Droid Sans Mono',
                              font_size=12,
                              x=WINDOW_WIDTH // 2, y=WINDOW_HEIGHT-15,
                              anchor_x='center', anchor_y='center')

        # Register and schedule the update function
        pyglet.clock.schedule(self.update)

    def update(self, dt):
        """Updates the game entities

        Args:
            dt: time since the last update
        """
        # Update the asteroids
        self.asteroid_manager.update(dt)

        # Update any animation data
        self.effect_player.update(dt)

        # If the player is dead, we don't have to update
        # the ship or check for collisions
        if self.player.is_dead:
            # If the player hits R, reset
            if (self.keys[key.R]):
                self.reset()
            return

        self.player.update(self.keys, dt)

        # Check for bullet hits
        for asteroid in self.asteroid_manager.asteroids:
            # We only need to check collisions if the player is
            # vulnerable, so if the player is not this will
            # short-circuit
            if self.player.is_vulnerable and asteroid.collides(self.player
                                                                   .ship):
                self.player.kill()

                # Update the display to reflect the new number of lives
                self.lives_left_label.text = ('Lives Left: ' +
                                              str(self.player.lives_left))

                # Play explosion sound
                self.effect_player.play_sound('EXPLOSION')

                break

            # Check bullet collisions
            for bullet in self.player.bullets:
                if bullet.collides(asteroid):
                    # Remove the current asteroid and add the asteroids
                    # that result from the destruction, if there are any
                    self.asteroid_manager.asteroids.remove(asteroid)
                    self.asteroid_manager.asteroids.extend(asteroid.destroy())

                    # For scoring, we only add to the player's score if
                    # the asteroid that was destroyed was small. This
                    # is easier than assigning a point value to each
                    # size of asteroid, because bigger asteroids will
                    # automatically be worth more since they 'contain'
                    # many small asteroids
                    if asteroid.size == Asteroid.Size.SMALL:
                        self.player.score += 10
                        self.score_label.text = 'Score: ' + str(self.player
                                                                    .score)

                    # Remove the bullet from the screen
                    self.player.bullets.remove(bullet)

                    # Play explosion sound
                    self.effect_player.play_sound('EXPLOSION')

    def on_draw(self):
        """Handler for the on_draw event of the game window"""
        self.window.clear()

        # Reset to the identity view matrix
        glLoadIdentity()

        # Draw the game over screen if the player is out of lives,
        # otherwise draw the lives left and the player (if not dead)
        if self.player.game_over:
            self.draw_game_over()
        else:
            self.score_label.draw()
            self.level_label.draw()
            self.draw_player_status()
            if not self.player.is_dead:
                self.player.draw()

        # Draw animation stuff
        self.effect_player.draw_animations()

        # Always draw the asteroids
        self.asteroid_manager.draw_asteroids()

    def on_level_change(self, level_num):
        """Callback for AsteroidManager, invoked when the player
        completes a level

        Parameters:
            level_num: the new level number the player is on
        """
        self.level_label.text = ('Level: ' + str(self.asteroid_manager
                                                     .curr_level_num))

        # Give the player some bonus points for completing a level
        self.player.score += 50

    def draw_player_status(self):
        """Draws an indicator showing how many lives the player
        has left and whether his teleport ability is up.

        Lives left are drawn as ships.
        """
        # Get the player's teleport status
        teleport_status = ['Down', 'Up'][self.player.teleport_up]

        # Draw the label
        teleport_status_label = pyglet.text.Label('Tele: ' + teleport_status,
                                                  font_name='Droid Sans Mono',
                                                  font_size=10,
                                                  anchor_x='center',
                                                  anchor_y='center',
                                                  x=100,
                                                  y=WINDOW_HEIGHT-30)

        teleport_status_label.draw()

        # Is the player invulnerable?
        if not self.player.is_vulnerable:
            invuln_label = pyglet.text.Label('INVULN',
                                             font_name='Droid Sans Mono',
                                             font_size=12,
                                             anchor_x='center',
                                             anchor_y='center',
                                             x=200,
                                             y=WINDOW_HEIGHT-15)
            invuln_label.draw()

        # Label the lives indicator
        lives_left_label = pyglet.text.Label('Lives:',
                                             font_name='Droid Sans Mono',
                                             font_size=10,
                                             anchor_x='center',
                                             anchor_y='center',
                                             x=70,
                                             y=WINDOW_HEIGHT-15)
        lives_left_label.draw()

        # Some variables which we will use to draw the ships
        scale = 0.25
        y = WINDOW_HEIGHT - 15

        # The first ship will be drawn at x, and then
        # the we will increment by dx for each ship we
        # draw to get the new x position
        x = 110
        dx = 20

        # Draw one ship for each life left
        for i in range(0, self.player.lives_left):
            ship_shape = Shape((20, 0, -30, 20, -30, -20),
                               Vector(x, y), 90, scale)
            ship_shape.draw()
            x += dx

    def draw_game_over(self):
        """Draws the game over screen"""
        # Create a game over label and draw it
        game_over_label = pyglet.text.Label('GAME OVER!',
                                            font_name='Droid Sans Mono',
                                            font_size=32,
                                            x=WINDOW_WIDTH//2,
                                            y=WINDOW_HEIGHT//2,
                                            anchor_x='center',
                                            anchor_y='center')

        # Display the player's final score
        final_score_label = pyglet.text.Label(('Your Score: ' +
                                              str(self.player.score)),
                                              font_name='Droid Sans Mono',
                                              font_size=26,
                                              x=WINDOW_WIDTH//2,
                                              y=WINDOW_HEIGHT//2 - 35,
                                              anchor_x='center',
                                              anchor_y='center')
        # Display option to restart
        reset_label = pyglet.text.Label('Press \'R\' to reset',
                                        font_name='Droid Sans Mono',
                                        font_size=20,
                                        x=WINDOW_WIDTH//2,
                                        y=WINDOW_HEIGHT//2 - 70,
                                        anchor_x='center',
                                        anchor_y='center')

        game_over_label.draw()
        final_score_label.draw()
        reset_label.draw()

    def reset(self):
        """Reset the game"""
        self.player = Player()
        self.asteroid_manager = AsteroidManager(self.on_level_change)

        # Reset the level number label
        self.level_label.text = ('Level: ' + str(self.asteroid_manager
                                                     .curr_level_num))

        # Reset score label
        self.score_label.text = 'Score: ' + str(self.player.score)
示例#37
0
class WinScene(scenes.Scene):

    def __init__(self, app):
        super(WinScene, self).__init__(app)
        
        self.space = Space((400, 400))
        
        def f(a, b):
            if __debug__: pass#print "missing collision function tuple type (%s, %s)" % (a.__class__.__name__, b.__class__.__name__)
        
        #self.coll_funcs = coolections.defaultdict(lambda: lambda *args, **kwargs: None) # {(type1, type2): func}
        self.coll_funcs = collections.defaultdict(lambda: f) # {(type1, type2): func}

        self.coll_funcs[(Bullet, Player)] = self.coll_player_bullet
        #self.coll_funcs[(Player, Polygon)] = self.coll_player_obstacle
        self.coll_funcs[(Bullet, Polygon)] = self.coll_bullet_obstacle
        self.coll_funcs[(Flock, Polygon)] = self.coll_flock_obstacle
        self.coll_funcs[(Flock, Bullet)] = self.coll_flock_bullet
        self.coll_funcs[(Bullet, Flock)] = self.coll_bullet_flock
        self.coll_funcs[(Player, Flock)] = self.coll_player_flock
        self.coll_funcs[(Player, Trigger)] = self.coll_player_trigger

        self.splines = []
        self.flocks = []
        self.obstacles = []
        self.enemies = []
        self.triggers = []
        self.bullets = []
        
        self.dynamic = []
        self.static = []
        
        self.winlabel = None
        self.winmsg = "You win!"
        self.campos = Vec3(0.0, 0.0)
        self.last_lead = Vec3(0.0, 0.0)
        
        self.bg_image = pyglet.image.load("data/textures/background.png")
        self.bg_texture = pyglet.image.TileableTexture.create_for_image(self.bg_image)
        self.level_file = None #self.app.level_file
        
        self.load_level()
        
        self.cam_spline = None
        for spl in self.splines:
            if spl.kind == 2: # camera spline
                self.cam_spline = spl
        if self.cam_spline is None:
            print "wtf mate"
        self.t = 0
    
    def lookat(self, pos):
        self.campos = pos - CAMOFF 

    #-- collision function --#

    def coll_flock_obstacle(self, flock, obst):
        for boid in flock.boids:
            if obst.is_point_in(boid.position.x, boid.position.y):
                flock.boids.remove(boid)
    
    def coll_player_bullet(self,  bullet, player):
        player.alive -= 10
        bullet.destroy()
        if __debug__: print 'collision player - bullet'
        pass    

    def coll_player_obstacle(self, player, obst):
        if obst.is_point_in(player.position.x, player.position.y):
            d = obst.position - player.position
            minval = 0
            for vertex in obst.vertices:
                value = d.dot(vertex)
                if value < min:
                    vert = vertex
                    minval = value
            d.normalize()
            player.position += vertex.project_onto(d) * 0.1
            #if __debug__: print player.velocity, player.position, vertex.project_onto(d)
            #if __debug__: print 'collision, player - obstacle!'
        
    def coll_bullet_obstacle(self, bullet, obst):
        if obst.is_point_in(bullet.position.x, bullet.position.y):
            bullet.destroy()
            #if __debug__: print 'collision, bullet - obstacle!'

    def coll_bullet_flock(self, bul, flock):
        self.coll_flock_bullet(flock, bul)

    def coll_flock_bullet(self, flock, bullet):
        if flock.boids:
            boid = min([((boid.position - bullet.position).lengthSQ, boid) for boid in flock.boids])
            if boid[0] < 20:
                flock.boids.remove(boid[1])
                bullet.destroy()
                if __debug__: print 'collision, flcok - bullet!'

    def coll_player_flock(self, player, flock):
        if player.color != flock.color:
            player.alive -= 1
            if __debug__: print 'collision, player - flock!'
        
    def coll_player_trigger(self, player, trigger):
        trigger.fire()

    def have_level(self, level_number):
        pass

    def load_level(self):
        self.level_file = "data/WinLevel.lvl"
        level = None
        fobj = open(self.level_file, "rb")
        level = cerealizer.load(fobj)

        if level:
            self.splines = [Spline(self, serial=s) for s in level.splines]
            self.triggers = [Trigger(0, 0, serial=t) for t in level.triggers]
            self.obstacles = [Polygon(self, serial=o) for o in level.obstacles]
            self.enemies = [Enemy(self, s.fire_rate, s.position, s.orientation) for s in level.enemies]
            # connect triggers
            for spl in self.splines:
                for trigger_uuid in spl.trigger_uuids:
                    for trigger in self.triggers:
                        if trigger.uuid == trigger_uuid:
                            trigger += spl.on_trigger
                            
            self.static.extend( self.triggers + self.obstacles + self.enemies )
            self.space.add(self.static)

    #-- state funcs --#
            
    def on_scene_enter(self):
        #glEnable(GL_POINT_SMOOTH)
        #glEnable(GL_TEXTURE_2D)
        self.player = Player()
        self.players = [self.player]
        self.dynamic.append(self.player)
        self.last_lead = self.player.position = self.campos = self.cam_spline.get_point(0)
        clock.schedule(self.update)
            
        
    def on_scene_leave(self):
        #glDisable(GL_POINT_SMOOTH)
        #glDisable(GL_TEXTURE_2D)
        clock.unschedule(self.update)
        
    def add_dynamic(self, bullet):
        self.dynamic.append(bullet)
    
    def remove_dynamic(self, bullet):
        try:
            self.dynamic.remove(bullet)
        except:
            pass
 

    def update(self, dt):
        # update spline and get position
        self.t += dt * 0.45
        
        self.winlabel = pyglet.text.Label(self.winmsg,
                            font_name='System',
                            font_size=42,
                            x=self.app.width / 2, y=self.app.height / 2,
                            anchor_x='center', anchor_y='center',
                            color=(86,10,10, 255))
        
        lead_point = self.cam_spline.get_point(self.t)
        if lead_point:
            camdelta = lead_point - self.last_lead
            self.last_lead = lead_point
            self.lookat(lead_point)
            self.player.position += camdelta
        else:
            pass  
    
        dynamics = self.dynamic #[dyn for dyn in self.dynamic if dyn.position.get_distanceSQ(self.campos) < 800*800]
        for dynamic in dynamics:
            dynamic.update(dt)
        # collision
        for item, bhits in self.space.add(dynamics):
            if bhits:
                for bitem in bhits:
                    r = item.bounding_radius + bitem.bounding_radius
                    if r * r > item.position.get_distanceSQ(bitem.position):
                        self.coll_funcs[item.__class__, bitem.__class__](item, bitem)
        
        self.space.remove(dynamics)
        if self.player.alive < 0:
            pass

    def on_draw(self):
        self.app.clear()
        glLoadIdentity()
        glColor4f(1.0, 1.0, 1.0, 1.0)
        
        # Background
        self.bg_texture.blit_tiled(0, 0, 0, 800, 600)
        # Camera translation
        glTranslatef(-self.campos.x, -self.campos.y, 0.0)
        
        for dyn in self.dynamic:
            dyn.draw()
        self.player.draw()
        for stat in self.static:
            stat.draw()
        
        glTranslatef(self.campos.x, self.campos.y, 0.0)
        if self.winlabel:
            self.winlabel.draw()

    def on_mouse_press(self, x, y, button, modifiers):
        pass
    def on_mouse_drag(self, x, y, dx, dy, button, modifiers):
        
        if pyglet.window.mouse.MIDDLE == button and __debug__:
            self.campos += Vec3(dx, dy)

    def on_key_press(self, symbol, mod):
        if symbol == UP:
            self.player.movey += 1
        elif symbol == DOWN:
            self.player.movey -= 1
        elif symbol == RIGHT:
            self.player.movex += 1
        elif symbol == LEFT:
            self.player.movex -= 1
        elif symbol == SPACE:
            self.player.switchcolor()

    def on_key_release(self, symbol, mod):
        if symbol == UP:
            self.player.movey -= 1
        elif symbol == DOWN:
            self.player.movey += 1
        elif symbol == RIGHT:
            self.player.movex -= 1
        elif symbol == LEFT:
            self.player.movex += 1

    def on_scene_leave(self):
        clock.unschedule(self.update)
示例#38
0
class Window(pyglet.window.Window):
  player = None
  enemy_qty = 100
  enemy = []
  label_mouse_xy = None
  mouse_x = 0
  mouse_y = 0

  # Class initializer
  def __init__(self, size_x, size_y, resize):
    super(Window, self).__init__(resizable = resize, visible = True, vsync = False)
    self.set_size(size_x, size_y)
    self.set_caption('SpaceCow')
    self.maximize()

    self.player = Player((self.width / 2), (self.height / 2), 0, "resources/ship.png")

    for enemies in range(self.enemy_qty):
      self.enemy.append(Enemy((self.width / 2), (self.height / 2), 0, "resources/cow.png"))

    for e in self.enemy:
      e.x_pos = randint(0, self.width)
      e.y_pos = randint(0, self.height)
      e.rotation = randint(0, 360)

    self.player.x_pos = self.width / 2
    self.player.y_pos = self.height / 2
    self.label_mouse_xy = pyglet.text.Label("Mouse Location")

    self.play_bg_music()

  def play_bg_music(self):
    bg_music = pyglet.media.Player()
    music = pyglet.media.load('resources/635964_A-Heros-Destiny.mp3')
    
    bg_music.queue(music)

    bg_music.eos_action = pyglet.media.Player.EOS_LOOP

    bg_music.play()

  def follow_mouse(self, player, timer, speed):
    player.c_val = sqrt((self.mouse_x - player.x_pos) ** 2 + \
      (self.mouse_y - player.y_pos) ** 2)
    player.x_pos -= ((player.x_pos - self.mouse_x) / player.c_val * speed * timer)
    player.y_pos -= ((player.y_pos - self.mouse_y) / player.c_val * speed * timer)
    delta_x = player.x_pos - self.mouse_x
    delta_y = player.y_pos - self.mouse_y

    if player.c_val > 1.0:
      player.rotation = atan2(delta_y, delta_x) / pi * 180 * -1

  def follow(self, enemy, timer, speed):
    enemy.c_val = sqrt((enemy.x_pos - self.player.x_pos) ** 2 + \
      (enemy.y_pos - self.player.y_pos) ** 2)
    enemy.x_pos -= ((enemy.x_pos - self.player.x_pos) / enemy.c_val * speed * timer)
    enemy.y_pos -= ((enemy.y_pos - self.player.y_pos) / enemy.c_val * speed * timer)
    delta_x =  enemy.x_pos - self.player.x_pos
    delta_y =  enemy.y_pos - self.player.y_pos

    if enemy.c_val > 1.0:
      enemy.rotation = atan2(delta_y, delta_x) / pi * 180 * -1

  def update(self, dt):
    self.label_mouse_xy.text = \
      "mouse_x: %d mouse_y: %d | player_x: %d player_y: %d | delta: %f | rotation: %f" % \
      (self.mouse_x,
        self.mouse_y,
        self.player.x_pos,
        self.player.y_pos,
        self.player.c_val,
        self.player.rotation)
    self.follow_mouse(self.player, dt, self.player.speed)

    for e in self.enemy:
      self.follow(e, dt, 10)

  def on_draw(self):
    self.clear()
    self.player.draw_player()

    for e in self.enemy:
      e.draw_player()

    self.label_mouse_xy.draw()

  def on_mouse_motion(self, x, y, dx, dy):
    self.label_mouse_xy.x = 10.0
    self.label_mouse_xy.y = 10.0
    self.mouse_x = x
    self.mouse_y = y
class PlayGroundScene(scenes.Scene):

    def __init__(self, app):
        super(PlayGroundScene, self).__init__(app)
        spline = Spline(self)
        spline.add_guide(100, 100)
        spline.add_guide(100, 200)
        spline.add_guide(100, 250)
        spline.add_guide(300, 50)
        spline.add_guide(400, 150)
        spline.add_guide(400, 400)
        spline.add_guide(200, 300)
        spline.add_guide(100, 100)
        self.flocks = [Flock(spline, 30, position=Vec3(100,100), color="black")]
        spline = Spline(self)
        spline.add_guide(750, 500)
        spline.add_guide(100, 480)
        spline.add_guide(150, 50)
        spline.add_guide(200, 100)
        spline.add_guide(500, 25)
        spline.add_guide(700, 300)
        spline.add_guide(750, 500)
        
        self.flocks.append(Flock(spline, 30, position=Vec3(200,200), action="reset"))
        self.obstacles = []
        self.player = None
        self.enemies = []
        self.bullets = []
        self.coll_detector = None

    def add_dynamic(self, entity):
        if isinstance(entity, enemies.Bullet):
            self.bullets.append(entity)
        elif isinstance(entity, flock.Flock):
            self.flocks.append(entity)
        else:
            print 'UNKNOWN  entity type to add', entity.__class__.__name__

    def remove_dynamic(self, entity):
        try:
            if isinstance(entity, enemies.Bullet):
                self.bullets.remove(entity)
            elif isinstance(entity, flock.Flock):
                self.flocks.remove(entity)
            else:
                print 'UNKNOWN entity type to remove', entity.__class__.__name__
        except:
            pass

        
    def on_scene_enter(self):
        clock.schedule(self.update)
        
        self.player = Player()
        self.players = [self.player]
        self.generate_level()
        
        # set up collision detection
        self.coll_detector = collision.CollisionDetector()
        
        # collisions between:
        # flock-player, player-bullets, player-objstacles, bulltets-obstacles, bullets-flock
        #self.coll_detector.register_once(self, group_name1, group_name2, group1, group2, coll_strategy, type_tuple, func):
        self.coll_detector.register_group('player', self.players)
        self.coll_detector.register_group('flocks', self.flocks)
        self.coll_detector.register_group('obstacles', self.obstacles)
        self.coll_detector.register_group('enemies', self.enemies)
        self.coll_detector.register_group('bullets', self.bullets)
        self.coll_detector.register_pair('player', 'flocks', PlayerFlockCollisionStrategy(self))
        self.coll_detector.register_pair('player', 'bullets', PlayerBulletsCollisionStrategy(self))
        self.coll_detector.register_pair('player', 'obstacles', PlayerObstaclesCollisionStrategy(self))
        self.coll_detector.register_pair('bullets', 'obstacles', BulletsObstaclesCollisionStrategy(self))
        self.coll_detector.register_pair('flocks', 'bullets', FlockBulletsCollisionStrategy(self))
        
        #self.coll_detector.register_once('player', 'flocks', self.players, self.flocks, PlayerFlockCollisionStrategy(self), tuple(), None):
        
        # enemy
        #scene, fire_rate, position, orientation)
        self.enemies.append( Enemy(self, 1, Vec3(300, 10), Vec3(0, 1) * 100.0) )
        self.enemies.append( Enemy(self, 0.1, Vec3(10, 200), Vec3(1, -0.1) * 300.0) )
        self.enemies.append( Enemy(self, 1, Vec3(500, 10), Vec3(0, 1) * 200) )
        
        p = Polygon()
        p.add_vertex(400, 400)
        p.add_vertex(550, 400)
        p.add_vertex(550, 420)
        p.add_vertex(400, 450)
        self.obstacles.append(p)

    def generate_level(self):
        # TODO: implement level generation here
        pass
        
    def update(self, dt):
        for flock in self.flocks:
            flock.update(dt)
        for obst in self.obstacles:
            obst.update(dt)
        for enemy in self.enemies:
            enemy.update(dt)
        for bullet in self.bullets:
            bullet.update(dt)
        self.player.update(dt)
        
        self.coll_detector.check()
        
        #print self.player.alive
        if self.player.alive < 0:
            print 'dead!'
            pass

    def on_draw(self):
        
        self.app.clear()
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()
        for flock in self.flocks:
            flock.draw()
        glColor4f(1,1,1,1)
        for obst in self.obstacles:
            obst.draw()
        for enemy in self.enemies:
            enemy.draw()
        for bullet in self.bullets:
            bullet.draw()
        self.player.draw()

        self.app.draw_fps()
        
    def on_mouse_press(self, x, y, button, modifiers):
        pass

    def on_key_press(self, symbol, mod):
        if symbol == UP:
            self.player.movey += 1
        elif symbol == DOWN:
            self.player.movey -= 1
        elif symbol == RIGHT:
            self.player.movex += 1
        elif symbol == LEFT:
            self.player.movex -= 1
        elif symbol == SPACE:
            self.player.switchcolor()

    def on_key_release(self, symbol, mod):
        if symbol == UP:
            self.player.movey -= 1
        elif symbol == DOWN:
            self.player.movey += 1
        elif symbol == RIGHT:
            self.player.movex -= 1
        elif symbol == LEFT:
            self.player.movex += 1

    def on_scene_leave(self):
        clock.unschedule(self.update)
示例#40
0
        names = []
        for mode in modes:
            names.append(mode.name)

        return {
            'modes': names,
            'currentSong': {}
        }

cherrypy.tree.mount(BasicWeb(), '/info')

cherrypy.engine.start()


# the player
player = Player()

logger.info("Entering Main-Loop")

current_mode = None

# main loop
while True:
    for mode in modes:
        mode.invalidate() # give them the chance to update priority

    modes.sort(key=lambda x: x.priority, reverse=False)

    if current_mode is not None:
        current_mode.on_stop()