def test_get_transitions(self):
        """
        Make sure that we can get public and private transitions
        """

        game1 = game_runner.get_game(self.game_id)
        game1.max_players = 2
        player1 = Player()
        player2 = Player()
        action_name = "private_public_action"

        game1.register((player1, player2))
        self.assertTrue(
            game_runner.make_action(self.game_id,
                                    action_name=action_name,
                                    player=player1.game_id))

        # Now we expect a list of public transitions
        self.assertListEqual([("public", "foobar")],
                             game_runner.get_public_transitions(self.game_id))

        # We also expect player1 to have a private list
        transitions = game_runner.get_player_transitions(
            self.game_id, player1.game_id)
        self.assertListEqual([("private", "foobaz")], transitions)
        transitions = game_runner.get_player_transitions(
            self.game_id, player2.game_id)
        self.assertListEqual([], transitions)
예제 #2
0
    def test_player_calls__when_players_allin_with_stack_that_is_too_small__side_pot_is_formed(self):
        player1 = Player("Player1", 1000)
        player2 = Player("Player2", 90)
        player3 = Player("Player3", 80)
        pot = Pot()
        pot.player_calls(player1, 100)
        pot.player_calls(player2, 90)
        pot.player_calls(player3, 80)

        pots = pot.get_all_pots()
        self.assertEqual(3, len(pots))
        main_pot = pots[0]
        self.assertEqual(240, main_pot.pot_size())
        self.assertTrue(player1 in main_pot.chips_per_player)
        self.assertTrue(player2 in main_pot.chips_per_player)
        self.assertTrue(player3 in main_pot.chips_per_player)

        side_pot = pots[1]
        self.assertEqual(20, side_pot.pot_size())
        self.assertTrue(player1 in side_pot.chips_per_player)
        self.assertTrue(player2 in side_pot.chips_per_player)
        self.assertTrue(player3 not in side_pot.chips_per_player)

        side_pot = pots[2]
        self.assertEqual(10, side_pot.pot_size())
        self.assertTrue(player1 in side_pot.chips_per_player)
        self.assertTrue(player2 not in side_pot.chips_per_player)
        self.assertTrue(player3 not in side_pot.chips_per_player)
예제 #3
0
    def test_player_calls__when_players_allin_after_placing_blinds(self):
        player1 = Player("Player1", 1000)
        player2 = Player("Player2", 600)
        player3 = Player("Player3", 200)
        pot = Pot()
        pot.player_calls(player2, 5)
        pot.player_calls(player3, 200)
        pot.player_calls(player1, 1000)
        pot.player_calls(player2, 600)

        pots = pot.get_all_pots()
        self.assertEqual(3, len(pots))
        main_pot = pots[0]
        self.assertEqual(600, main_pot.pot_size())
        self.assertTrue(player1 in main_pot.chips_per_player)
        self.assertTrue(player2 in main_pot.chips_per_player)
        self.assertTrue(player3 in main_pot.chips_per_player)

        side_pot = pots[1]
        self.assertEqual(800, side_pot.pot_size())
        self.assertTrue(player1 in side_pot.chips_per_player)
        self.assertTrue(player2 in side_pot.chips_per_player)
        self.assertTrue(player3 not in side_pot.chips_per_player)

        side_pot = pots[2]
        self.assertEqual(400, side_pot.pot_size())
        self.assertTrue(player1 in side_pot.chips_per_player)
        self.assertTrue(player2 not in side_pot.chips_per_player)
        self.assertTrue(player3 not in side_pot.chips_per_player)
예제 #4
0
파일: trainer.py 프로젝트: chen9069/bird_em
 def train(self, player):
     # create new a new bot shares the same strategy
     player2 = Player(player.name + "COPY")
     player2.bot = EasyBot(player.bot.name + "_COPY")
     player2.bot.strategy = player.bot.strategy
     for _ in range(self._TRAIN_ITER):
         self.headsup_simulate(player, player2)
예제 #5
0
    def add_player(self):
        """
        Adds a player if possible and returns the player id
        """

        if len(self.players) >= self.max_players:
            raise ValueError("Too many players.")
        if self.is_set_up:
            raise ValueError("Unable to join a game in progress")

        player = Player()
        player.add_zones(self.player_zones)
        self.players.append(player)

        # Register both the player and it's zones with the game.
        self.register([player])
        self.register(player.zones.values())

        # Add the per-player zones to our dictionary and add the owner to
        # each zone.
        for name, zone in player.zones.items():
            zone.owner = player
            zone_name = name + '_' + str(player.game_id)
            self.zones[zone_name] = zone
            setattr(self, zone_name, zone)
        return player.game_id
예제 #6
0
    def __init__(self, renderer_name, config, game):
        self.__config = config
        self.__game = game

        pygame.init()
        self.__clock = pygame.time.Clock()

        self.__screen = ScreenProvider.create(config)
        self.__renderer = RendererProvider.create(config, renderer_name)
        self.__done = False
        self.__joysticks = []

        self.__connect_joysticks()

        self.__players = [
            Player(
                InputState([
                    KeyboardInputHandler(ei.KEY_MAP_1),
                    JoystickInputHandler(0)
                ])),
            Player(
                InputState([
                    KeyboardInputHandler(ei.KEY_MAP_2),
                    JoystickInputHandler(1)
                ]))
        ]
예제 #7
0
 def initialize_game(prev_game):
     player_pos_dict = {
         1: Player('player1', 1),
         2: Player('player2', 2),
         3: Player('player3', 3),
         4: Player('player4', 4)
     }
     return Game28(player_pos_dict, prev_game)
예제 #8
0
 def create_game_for_testing():
     player_dict = {
         1: Player('player1', 1),
         2: Player('player2', 2),
         3: Player('player3', 3),
         4: Player('player4', 4),
     }
     game = GameFactory.get_game_implementation(GameType.TWENTY_EIGHT,
                                                player_dict, None)
     game.player_action('player1', PlayerAction.DEALING_ACTION, None)
     return game
예제 #9
0
파일: game.py 프로젝트: Daetheys/Halite
    def __init__(self,agent1,agent2):

        self.spawn_cost = 500
        self.convert_cost = 500
        self.halite_init = 100000
        self.halite_collect = 0.75

        self.init_halite()
        self.players = [Player(0,agent1,self),Player(1,agent2,self)]
        self.nb_step = 0
        self.length = 10
 def create_game_for_testing():
     player_dict = {
         1: Player('player1', 1),
         2: Player('player2', 2),
         3: Player('player3', 3),
         4: Player('player4', 4),
     }
     game = GameFactory.get_game_implementation(GameType.TWENTY_EIGHT,
                                                player_dict, None)
     game.state = Game28State.ROUND_ONE_BIDDING_DONE
     return game
예제 #11
0
 def test_big_blind_player__correctly_determines_big_blind_position(self):
     button_positions = [(0, "Player2"), (1, "Player3"), (2, "Player0"),
                         (3, "Player1")]
     for button_position, big_blind_name in button_positions:
         with self.subTest():
             player0 = Player("Player0")
             player1 = Player("Player1")
             player2 = Player("Player2")
             player3 = Player("Player3")
             seating = Seating([player0, player1, player2, player3])
             seating.button_position = button_position
             result = seating.big_blind_player().name
             self.assertEqual(big_blind_name, result)
예제 #12
0
 def test_deal(self):
     player1 = Player("player1", 1000)
     player2 = Player("player2", 1000)
     seating = Seating([player1, player2])
     deck = Deck()
     deck.initialize()
     dealer = Dealer(deck, seating)
     dealer.deal_cards_to_players()
     hand_size = 2
     cards_dealt = len(seating.players) * hand_size
     self.assertEqual(cards_dealt, len(set(player1.cards + player2.cards)))
     expected_remaining_card_count = TestDeck.deck_size - cards_dealt
     self.assertEqual(expected_remaining_card_count, len(deck.cards))
예제 #13
0
class TestPlayer(unittest.TestCase):
    def setUp(self):
        self.player = Player('player')

    def test_constructor(self):
        self.assertEqual('player', self.player.name)
        self.assertEqual(0, self.player.score)
        self.assert_(not self.player.rack)

    def test_valid_play(self):
        self.player.rack = list('DEADBEEF')

        l = self.player.valid_play('DEAD')
        for letter in 'DEAD':
            self.assertIn(letter, l)

        l = self.player.valid_play('DEADBEEF')
        for letter in 'DEADBEEF':
            self.assertIn(letter, l)

        l = self.player.valid_play('BLAH')
        self.assert_(not l)

        # With blanks now
        self.player.rack = list('HELLO WORLD')

        l = self.player.valid_play('HELLOS')
        for letter in 'HELLOs':
            self.assertIn(letter, l)

        # Make sure the blank isn't used unless absolutely necessary
        l = self.player.valid_play('HELLO')
        for letter in 'HELLO':
            self.assertIn(letter, l)

        # What if the blank is a second instance of an existing letter?
        l = self.player.valid_play('LLLL')
        self.assertEqual(1, l.count('l'))

    def test_use_letters(self):
        self.player.rack = list('DEADBEEF')

        self.player.use_letters('DEAD')
        self.assertEqual(list('BEEF'), self.player.rack)

        self.player.rack = list('HELLO WORLD')

        self.player.use_letters('JELLO')
        self.assertEqual(list('HWORLD'), self.player.rack)
 def add_player_to_session(self, player_id):
     for pos in range(1, self.number_of_players + 1):
         if pos not in self.player_pos_dict:
             player = Player(player_id, pos)
             self.player_pos_dict[pos] = player
             return self.player_pos_dict
     raise GameEngineException("No free position available for allocation")
예제 #15
0
파일: main.py 프로젝트: ehouse/Bunbunmaru
    def __init__(self,width=800,height=600):
        """
            Game loop Class
            Accepts game window height and width
        """
        # game display vars
        self.game = pygame
        self.game.init()
        self.width = width
        self.height = height
        self.screen = self.game.display.set_mode((self.width,self.height))
        self.clock = pygame.time.Clock()
        self.game.display.set_caption('Bunbunmaru Gamejam 2013 | TOPGUN')
        self.clock.tick(60)

        # images
        self.f14 = self._load_png("f14.png")
        self.cloud = self._load_png("alpha_cloud.png")
        self.bullet = self._load_png("bullet.png")
        self.enemy = self._load_png("mig.png")

        # level management
        self.level = Level1( self.enemy )
        self.bulletMan = BulletManager()

        # entities
        self.enemies = self.level.getCurrentEnemies()
        self.sky = clouds(self.cloud)
        self.player = Player( 3, 0, self.bulletMan, 1, self.f14,
                              self.f14.get_rect(), self.bullet,
                              self.bullet.get_rect() )
예제 #16
0
파일: mygame_test.py 프로젝트: sogh/furple
    def setUp(self):
        # Here we will construct a Test World we can use to verify our systems
        # work well together.
        self.player = Player()
        self.g = Graphics()
        self.sim = Simulation()
        self.sun = SunMoon()

        # Build Test World
        self.worldmap = WorldMap(0, 0, 2, 2)
        self.worldmap.SetMapTile(0, 0,
                                 MapTile('00', 'ohoh', [MapTileTag.FOREST]))
        self.worldmap.SetMapTile(0, 1,
                                 MapTile('01', 'oh one', [MapTileTag.FOREST]))
        self.worldmap.SetMapTile(1, 0, MapTile('10', 'ten',
                                               [MapTileTag.FOREST]))
        self.worldmap.SetMapTile(1, 1,
                                 MapTile('11', 'eleven', [MapTileTag.FOREST]))

        self.worldmap.AddItemAt(0, 1, 'Test Item')

        # Create Test NPC
        self.worldmap.AddNPCAt(1, 0, 'roger')
        self.worldmap.AddNPCAt(1, 0, 'bob')

        self.game = MyGame(worldmap=self.worldmap,
                           sim=self.sim,
                           player1=self.player,
                           graphics=self.g,
                           sun=self.sun)
    def test_player_values(self):
        """
        Make sure that we can set values for a specific player.
        """

        player = Player()
        self.game.register([player])

        # Make sure that we can't get any values from a default player object
        self.assertIsNone(
            self.stateful_game_object.get_value("visible", player))

        expected_state_changes = [
            ("set", "foo", self.stateful_game_object.game_id, "visible", True)
        ]

        # Add per player transition
        self.stateful_game_object.set_value("visible", True, player)

        self.assertIsNone(self.stateful_game_object.get_value("visible"))
        self.assertEqual(
            self.stateful_game_object.get_value("visible", player), True)

        # Make sure the game got the right transitions
        self.assertEqual(expected_state_changes,
                         self.game.get_player_transitions(player.game_id))

        # Make sure we can get the proper dictionary representation
        self.assertDictEqual(self.stateful_game_object.to_dict(),
                             {'game_id': self.stateful_game_object.game_id})
        self.assertDictEqual(self.stateful_game_object.to_dict(player), {
            'game_id': self.stateful_game_object.game_id,
            'visible': True
        })
 def __allocate_seats(self, player_ids):
     for pos in range (1,self.number_of_players + 1):
         if pos < len(player_ids) + 1:
             player = Player(player_ids[pos -1], pos)
             self.player_pos_dict[pos] = player
         else:
             break
     return self.player_pos_dict
예제 #19
0
    def __init__(self, mapText, timeSpeed=1):
        self.timeSpeed = timeSpeed
        self.time = 0

        self.player = Player.DEFAULT(self)
        self.entityList = set((self.player, ))
        self._map = MapClass(self, mapText)
        self.loadedSheets = {}
예제 #20
0
파일: loader.py 프로젝트: Regis-1/LandAvMot
def load_player(instance):
    tmp_items = []
    data = None
    with open("characters/player.json", "r") as rf:
        data = json.load(rf)
    for loc_item in data["items"]:
        tmp_items.append(instance.get_item(loc_item))
    data["items"] = tmp_items
    p = Player(*data.values())

    return p
예제 #21
0
 def __init__(self):
     self.player1 = Player('1', player_config['types'][0])
     self.player2 = Player('2', player_config['types'][1])
     self.game_board = GameWindow(window_config['resolution'],
                                  window_config['size'],
                                  window_config['hexes'])
     self.game_board.draw_display(True)
     self.game_engine = GameEngine(self.game_board, self.player1)
     self.turns_played = 0
     # Four functions for four different types of game.
     self._games = {
         'human_human': self._run_p1_p2_human,
         'human_ai': self._run_p1_human_p2_ai,
         'ai_human': self._run_p1_ai_p2_human,
         'ai_ai': self._run_p1_ai_p2_ai,
     }
     # Select game type based on players
     self._run_func = self._games['{}_{}'.format(self.player1.type,
                                                 self.player2.type)]
     self.game_ended = False
     self.start_time = time.time()
예제 #22
0
    def test_player_calls__when_three_players_allin_with_stacks_that_are_too_small__three_side_pots_are_formed(self):
        player1 = Player("Player1", 1000)
        player2 = Player("Player2", 600)
        player3 = Player("Player3", 200)
        player4 = Player("Player4", 50)
        pot = Pot()
        pot.player_calls(player1, 999)
        pot.player_calls(player2, 600)
        pot.player_calls(player3, 200)
        pot.player_calls(player4, 50)

        pots = pot.get_all_pots()
        self.assertEqual(4, len(pots))
        main_pot = pots[0]
        self.assertEqual(200, main_pot.pot_size())
        self.assertTrue(player1 in main_pot.chips_per_player)
        self.assertTrue(player2 in main_pot.chips_per_player)
        self.assertTrue(player3 in main_pot.chips_per_player)
        self.assertTrue(player4 in main_pot.chips_per_player)

        side_pot = pots[1]
        self.assertEqual(450, side_pot.pot_size())
        self.assertTrue(player1 in side_pot.chips_per_player)
        self.assertTrue(player2 in side_pot.chips_per_player)
        self.assertTrue(player3 in side_pot.chips_per_player)
        self.assertTrue(player4 not in side_pot.chips_per_player)

        side_pot = pots[2]
        self.assertEqual(800, side_pot.pot_size())
        self.assertTrue(player1 in side_pot.chips_per_player)
        self.assertTrue(player2 in side_pot.chips_per_player)
        self.assertTrue(player3 not in side_pot.chips_per_player)
        self.assertTrue(player4 not in side_pot.chips_per_player)

        side_pot = pots[3]
        self.assertEqual(399, side_pot.pot_size())
        self.assertTrue(player1 in side_pot.chips_per_player)
        self.assertTrue(player2 not in side_pot.chips_per_player)
        self.assertTrue(player3 not in side_pot.chips_per_player)
        self.assertTrue(player4 not in side_pot.chips_per_player)
 def create_game_for_testing():
     player_dict = {
         1: Player('player1', 1),
         2: Player('player2', 2),
         3: Player('player3', 3),
         4: Player('player4', 4),
     }
     game = GameFactory.get_game_implementation(GameType.TWENTY_EIGHT,
                                                player_dict, None)
     game.player_action('player1', PlayerAction.DEALING_ACTION, None)
     game.player_action(
         'player2', PlayerAction.BIDDING_ACTION, {
             constants.BID_VALUE:
             game.settings.get_setting_value(constants.MIN_BID_VALUE),
             constants.TRUMP_CARD_ABBREVIATION:
             TestRoundOneBidding.get_random_card_abbreviation(game)
         })
     game.player_action(
         'player3', PlayerAction.BIDDING_ACTION, {
             constants.BID_VALUE:
             game.settings.get_setting_value(constants.MIN_BID_VALUE) + 1,
             constants.TRUMP_CARD_ABBREVIATION:
             TestRoundOneBidding.get_random_card_abbreviation(game)
         })
     game.player_action(
         'player4', PlayerAction.BIDDING_ACTION, {
             constants.BID_VALUE:
             game.settings.get_setting_value(constants.MIN_BID_VALUE) + 2,
             constants.TRUMP_CARD_ABBREVIATION:
             TestRoundOneBidding.get_random_card_abbreviation(game)
         })
     game.player_action(
         'player1', PlayerAction.BIDDING_ACTION, {
             constants.BID_VALUE:
             game.settings.get_setting_value(constants.MIN_BID_VALUE) + 3,
             constants.TRUMP_CARD_ABBREVIATION:
             TestRoundOneBidding.get_random_card_abbreviation(game)
         })
     game.player_action('player1', PlayerAction.DEALING_ACTION, None)
     return game
예제 #24
0
    def test_deregister(self):
        """
        Make sure that we can properly deregister objects.
        """

        player = Player()
        card = Card()
        zone = Zone()
        other = GameObject()
        unregistered = GameObject()

        self.game.register([player, card, zone, other])

        self.game.deregister([player, card, zone, other, unregistered])
        print self.game.registered_objects
        self.assertEqual(self.game.registered_objects["Player"][0], 2)
        self.assertEqual(self.game.registered_objects["Card"][0], 1)
        self.assertEqual(self.game.registered_objects["Zone"][0], 1)
        self.assertEqual(self.game.registered_objects["GameObject"][0], 1)
예제 #25
0
    def __init__(self,
                 worldmap=initialize.GENERATE_PHEZYGG_WORLD(),
                 sim=Simulation(),
                 player1=Player(),
                 graphics=Graphics(),
                 sun=SunMoon()):
        self.info_commands = ['help', 'info']
        self.player_move_commands = [
            'north', 'south', 'east', 'west', 'n', 's', 'e', 'w'
        ]
        self.fart_commands = ['fart']
        self.look_commands = ['look', 'search', 'investigate']
        self.npc_commands = ['greet']
        self.quit_commands = ['quit']
        self.nothing_commands = ['wait', 'nothing']
        self.item_commands = ['pickup', 'get', 'take']
        self.inventory_commands = ['inventory']
        self.use_commands = ['use']

        self.all_commands = (self.info_commands + self.player_move_commands +
                             self.fart_commands + self.quit_commands +
                             self.look_commands + self.npc_commands +
                             self.nothing_commands + self.item_commands +
                             self.inventory_commands + self.use_commands)

        self.worldmap = worldmap
        self.sim = sim
        print("Beginning game...")
        self.player1 = player1
        self.sim.AddUpdateable(self.player1)
        self.sun = sun
        self.sim.AddUpdateable(self.sun)

        # Every game loop, add things to be rendered/printed to this list.
        self.render_list = []
        # Every game loop, update our input queue to process player input.
        # In normal operation, there will only be one entry in the queue. However, this
        # enables us to insert commands in the queue for testing purposes.
        self.input_queue = deque()

        self.graphics = graphics
예제 #26
0
def processInput():
    userText = input("Enter command [Add player] [Team player] [Spot] [Web spot] [Flee jail] [Print] [teamChat]: \n")
    if 'f' in userText:
        jailCode = input("enter jail code: ")
        Action.fleePlayerWithCode(jailCode)
        Stats.printPlayersDetailed()
    elif 's' in userText:
        mobile = input("enter mobile: ")
        code = input("enter code: ")
        Action.handleSms(mobile, code)
        Stats.printPlayersDetailed()
    elif 'a' in userText:
        name = input("enter name: ")
        mobile = input("enter mobile: ")
        #email = input("enter email: ")
        Action.addPlayer(name, mobile, "")
        Stats.printPlayersDetailed()
    elif 'w' in userText:
        hash = input("enter player hash: ")
        code = input("enter code: ")
        Action.handleWeb(hash, code)
        Stats.printPlayersDetailed()
    elif 't' in userText:
        name = input("enter player name: ")
        team = input("enter team name: ")
        Action.addPlayerToTeam(name, team)
        Stats.printPlayersDetailed()
    elif 'p' in userText:
        Stats.printStats()
    elif 'c' in userText:
        name = input("enter name: ")
        message = input("enter text: ")
        playerId = Player._getIdByName(name)
        Action.sayToMyTeam(playerId, message)
    elif 'q' in userText:
        id = input("enter id: ")
        Action.browserRequestsMessages(id)
    elif 'b' in userText:
        msg = Action.base_msg_get()
        print("BASE:", msg)
    def test_make_action(self):
        """
        Make sure that we can make actions through the GameRunner.
        """

        game1 = game_runner.get_game(self.game_id)
        game1.phase = "restricted"
        player = Player()
        game1.register([player])
        action = "restricted_action"

        valid, message = game_runner.make_action(self.game_id,
                                                 action_name=action,
                                                 player_id=player.game_id)
        self.assertFalse(valid)
        self.assertEqual(message, "Illegal Action")

        game1.phase = "unrestricted"

        self.assertEqual((True, None),
                         game_runner.make_action(self.game_id,
                                                 action_name=action,
                                                 player_id=player.game_id))
예제 #28
0
 def setUp(self):
     self.player = Player('player')
예제 #29
0
파일: player.py 프로젝트: danweflen/rico
 def __init__(self,index,name,screen,invert=False):
     Player.__init__(self,index,name)
     self.screen = screen
     self.board = Board(screen.get_size())
     self.points_visible = False
     self.invert = invert
예제 #30
0
파일: player_test.py 프로젝트: sogh/furple
 def setUp(self):
     """Create a Player for use in testing."""
     self.player1 = Player()
     self.testitem = Detritus("A ROCK")
예제 #31
0
파일: player_test.py 프로젝트: sogh/furple
class PlayerTestCase(unittest.TestCase):
    """Tests Player class and functions."""
    def setUp(self):
        """Create a Player for use in testing."""
        self.player1 = Player()
        self.testitem = Detritus("A ROCK")

    def test_move(self):
        """Test player position and movement."""
        # Check default x position
        self.assertEqual(self.player1.position.x, 0)
        # Check default y position
        self.assertEqual(self.player1.position.y, 0)
        # Check the different move directions and the resulting position change
        self.player1.move('n')
        self.assertEqual(self.player1.position.y, 1)
        self.player1.move('s')
        self.assertEqual(self.player1.position.y, 0)
        self.player1.move('e')
        self.assertEqual(self.player1.position.x, 1)
        self.player1.move('w')
        self.assertEqual(self.player1.position.x, 0)

    def test_status(self):
        """Test player hunger level and update."""
        # Check initial hunger
        self.assertEqual(self.player1.PlayerStatus(), 'You feel content.')
        self.assertEqual(self.player1.hunger, 0)
        for _ in range(0, 4):
            self.player1.Update(4)
        self.assertEqual(self.player1.hunger, 4)
        self.assertEqual(self.player1.PlayerStatus(), 'You are hungry.')

    def test_inventory(self):
        """Test inventory."""
        self.player1.add_item_to_inv(self.testitem)
        self.assertIn(self.testitem, self.player1.inventory)
        self.assertEqual(self.player1.display_inv(), ["A ROCK"])
예제 #32
0
파일: main.py 프로젝트: ehouse/Bunbunmaru
class GameLoop:
    def __init__(self,width=800,height=600):
        """
            Game loop Class
            Accepts game window height and width
        """
        # game display vars
        self.game = pygame
        self.game.init()
        self.width = width
        self.height = height
        self.screen = self.game.display.set_mode((self.width,self.height))
        self.clock = pygame.time.Clock()
        self.game.display.set_caption('Bunbunmaru Gamejam 2013 | TOPGUN')
        self.clock.tick(60)

        # images
        self.f14 = self._load_png("f14.png")
        self.cloud = self._load_png("alpha_cloud.png")
        self.bullet = self._load_png("bullet.png")
        self.enemy = self._load_png("mig.png")

        # level management
        self.level = Level1( self.enemy )
        self.bulletMan = BulletManager()

        # entities
        self.enemies = self.level.getCurrentEnemies()
        self.sky = clouds(self.cloud)
        self.player = Player( 3, 0, self.bulletMan, 1, self.f14,
                              self.f14.get_rect(), self.bullet,
                              self.bullet.get_rect() )

    def _actall( self ):
         self.sky.act()
         self.player.act()
         if self.enemies != None:
             self.bulletMan.update( self.enemies )
         else:
            # game is done, do that shit here
            pass
         for enemy in self.enemies.enemyList:
             enemy.act( self.player )

    def _drawall( self ):
        """
        Draws the player, bullets, and enemies (in that order) to the screen
        """
        self.screen.fill((135,206,250))
        self.sky.draw(self.screen)
        self.player.draw(self.screen)
        for enemy in self.enemies.enemyList:
            enemy.draw( self.screen)
        self.bulletMan.drawall( self.screen)
        pygame.display.flip()

    def _load_png( self, name):
        """
            Private Load_png method
            accept: name - file name
            return: pygame image obj
        """
        fullname = os.path.join('resources',name)
        try:
            image = pygame.image.load(fullname)
            if image.get_alpha() is None:
                image = image.convert()
            else:
                image = image.convert_alpha()
        except pygame.error:
            print "Cannot load image: ",fullname
        return image

    def start(self):
        """
            Entry point of the game
        """
        while 1:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    sys.exit()
            # check if current wave is done, if it is, get new enemies
            if self.level.isComplete():
                self.enemies = self.level.getCurrentEnemies()
                if self.enemies == None:
                    break
            self._actall()
            self._drawall()
예제 #33
0
class GameLevel:
    """ Level of the game """
    def __init__(self,
                 objects,
                 player_pos,
                 limgpar=[],
                 name='',
                 parallax=True,
                 gravity=2100,
                 music=None):  #Gravity is set experimentally for jumps to 2100
        """ The player spawn in (0,0)  """
        assert objects != []  #Empty GameLevel
        self.camera = Camera()  #Camera
        self.camera.set_position(Vector(-12, -12))
        self.camera.set_dimension(Vector(25, 25))
        self.objects = objects
        self.player_pos = player_pos
        self.compute_size_level()
        self.name = name
        self.music = music

        #Creation of the gravity
        self.gravity = Gravity(
            gravity
        )  #NOTE POUR LES RAGEUX : On a testé et ca marche bien avec cette valeur -> ca permet d'avoir un saut élegant

        self.begin_time = 0
        self.time = 0  #Time Referential of the level

        #Death animation
        self.lost = False
        self.countdown = 1

        #Creation of the player
        self.player = Player()
        self.player.set_position(0, -16)  #Init pos of the player
        self.objects.append(self.player)
        self.player.link_world(self)

        #Camera Y scrolling
        self.camera_y_pos = self.player.get_position().y

        #To optimise physics
        self.sorted_objects = None
        self.dynamic_objects = set([self.player])
        self.opti_step = 10
        self.optimise_data()
        self.progression = 0

        #Get end platform locations to compute score
        self.end_platform_location = None
        self.compute_end_platform_location()

        #Load Background
        self.parallax = parallax
        self.load_bg(limgpar)

        #Link worlds
        for o in objects:
            o.link_world(self)

        #End the initialisatio
        self.end_init()

    def load_bg(self, limgpar):
        if not self.parallax:
            if len(limgpar) >= 6:
                limgpar = [limgpar[0]]
            elif len(limgpar) >= 2:
                limgpar = [limgpar[1]]

        lpar = []  #List of Parallax
        for (name, index) in limgpar:
            p = Parallax(name, index)  #Create parallax with given speed
            lpar.append(p)
        self.background = Background(lpar)

    def end_init(self):
        """ Call all end_init of objects in the world """
        for o in self.objects:
            o.end_init()

    def get_camera(self):
        """ Returns the camera """
        return self.camera

    def get_objects(self):
        """ Returns objects of the level """
        return self.objects

    def load_inventory(self, inv):
        """ Load the inventory of campaign mode in the GameLevel """
        self.player.load_inventory(inv)

    def add_node(self, n):
        """ Adds a new node to the world """
        self.objects.append(n)
        self.dynamic_objects.add(n)
        n.link_world(self)

    def compute_end_platform_location(self):
        """ Compute the list of platform location """
        self.end_platform_location = []
        for o in self.get_objects():
            if isinstance(o, SolidPlatform):
                self.end_platform_location.append(
                    o.get_hit_box().get_world_rect().get_max_x())
        self.end_platform_location.sort()

    def get_objects_opti(self):
        """ Optimise the data structure """
        while self.progression < len(self.sorted_objects):
            o = self.sorted_objects[self.progression]
            orect = o.get_hit_box().get_world_rect()
            crect = self.get_camera().rect
            if orect.collidex(crect):
                self.dynamic_objects.add(o)
                self.progression += 1
            else:
                break
        return self.dynamic_objects

    def optimise_data(self):
        """ Optimise collisions checks and aff """

        #Call it before launching the game of making modification in camera (be carefull it may take a while to execute
        def order(o1):
            return o1.get_hit_box().get_world_rect().get_min_x()

        sorted_objects = self.objects[:]
        sorted_objects.sort(key=order)
        self.sorted_objects = sorted_objects

    def compute_size_level(self):
        """ Computes the size of the level """
        maxi_x = None
        maxi_y = None
        mini_x = None
        mini_y = None
        #Get the rect in which the level is
        for o in self.objects:
            hit_box = o.get_hit_box()
            val_max_x = hit_box.get_world_rect().get_max_x()
            val_max_y = hit_box.get_world_rect().get_max_y()
            val_min_x = hit_box.get_world_rect().get_min_x()
            val_min_y = hit_box.get_world_rect().get_min_y()
            if maxi_x is None or val_max_x > maxi_x:
                maxi_x = val_max_x
            if mini_x is None or val_min_x < mini_x:
                mini_x = val_min_x
            if maxi_y is None or val_max_y > maxi_y:
                maxi_y = val_max_y
            if mini_y is None or val_min_y < mini_y:
                mini_y = val_min_y
        self.size_level = (mini_x, maxi_x, mini_y, maxi_y)

    def get_size_level(self):
        """ Returns the size of the level as a tuple (minx,maxx,miny,maxy) """
        return self.size_level

    def play(self, fps):
        """ Launches the gameLevel , returns +score if win, -score if lose """
        #Starts the music
        if self.music != None:
            pygame.mixer.music.load(self.music)
            pygame.mixer.music.play(-1)
        t0 = get_current_time()
        tn = t0
        try:
            while True:
                #Get time
                now = get_current_time()
                #Compute dt from previous iteration
                dt = now - tn
                #Updates time from the begining
                self.time = tn - t0
                #Launch the loop
                self.main_loop(dt)
                #Updates tn for the next iteration
                tn = now

        except EndGame as e:
            #print("--",time.clock()-t0,self.time)
            return (e.issue, e.score)

    def main_loop(self, dt):
        #to = time.clock()
        """ Main loop of the game (controllers, physics, ...) """
        #Animation of lose
        self.animation_end_game(dt)
        #Computes opti objects
        obj_opti = set(self.get_objects_opti())
        #Call controllers
        self.compute_controller(obj_opti, dt)
        #Computation of physics
        self.physics_step(dt, obj_opti)
        #Camera set position (3/4)
        self.compute_camera_position(obj_opti)
        #Show all sprites
        self.aff(dt, obj_opti)
        #print("aff",time.clock()-t)
        #Score
        self.compute_score()
        #Win / Lose conditions
        self.compute_win_lose()

    def animation_end_game(self, dt):
        """ Waits a bit after the player dies before ending the game """
        if self.lost:
            if self.countdown > 0:
                self.countdown -= dt
            else:
                raise EndGame(False, self.player.score)

    def compute_camera_position(self, obj_opti):
        """ Compute the camera position by trying to fix it on the platform below the player and smooth movements """
        prect = self.player.get_hit_box().get_world_rect()
        #Search for the platform right below the player
        mini = None
        for o in obj_opti:
            if isinstance(o, SolidPlatform):
                rect = o.get_hit_box().get_world_rect()
                if rect.collidex(prect):
                    y = rect.get_min_y()
                    if (
                            mini is None and prect.get_min_y() < y
                            or prect.get_min_y() < y < mini
                    ) and abs(
                            prect.get_min_y() - y
                    ) < 100:  #If it's too far it will forget it and fix on the player instead
                        mini = y
        if mini is None:  #No platform -> fix on the player
            y = self.player.get_position().y
        else:  #Fix on a platform
            y = mini

        #Smooth moving of the camera
        old_percent = 95  #The percentage of the old value of self.camera_y_pos that will be kept
        self.camera_y_pos = self.camera_y_pos * old_percent / 100 + y * (
            100 - old_percent
        ) / 100  #Computation of the new continous Y position of the camera
        self.camera.threeforth_on(
            Vector(self.player.get_position().x, self.camera_y_pos)
        )  #Position of the camera (pos X of the player et pos Y previously computed)

    def compute_win_lose(self):
        """ Compute win / lose conditions (only lose since the commit adding flags)"""
        (minx, maxx, miny, maxy) = self.get_size_level()
        if self.player.get_position().y > maxy or not (
                self.player.alive):  #C'est inversé :)
            self.lose()

    def compute_score(self):
        """ Compute score """
        while len(self.end_platform_location) > 0 and self.player.get_position(
        ).x >= self.end_platform_location[0]:
            del self.end_platform_location[0]
            self.player.add_score(1000)

    def compute_controller(self, objects, dt):
        """ Compute controllers """
        pressed = pygame.key.get_pressed()
        #Controller loop
        for event in pygame.event.get() + [None]:
            for o in set(objects):
                if o.get_controller() is not None:
                    o.get_controller().execute(event, pressed, dt)
        #Physics

    def win(self):
        """ Win the game """
        self.player.flush_score()
        raise EndGame(True, self.player.score)

    def lose(self):
        """ Lose the game """
        self.player.flush_score()
        self.lost = True

    def physics_step(self, dt, obj_opti):
        """ Compute collisions """
        for i, o in enumerate(obj_opti):
            if True:  #not(isinstance(o,SolidPlatform)): #On peut se permettre d'integrer les plateformes au calcul suite a de nombreux gains de performance
                o.compute_speed(dt)
                o.move(dt)
                if o == self.player and self.player.alive:
                    #Reposition the player
                    pos = o.get_position()
                    new_pos = Vector(self.player_pos(self.time), pos.y)
                    o.translate(new_pos - pos)

                    #Cut X speed (for MAXSPEED)
                    speed = self.player.get_speed()
                    self.player.set_speed(Vector(
                        1, speed.y))  #Player needs to have a str pos speed
                for j, o2 in enumerate(obj_opti):
                    if o.get_collide() and o2.get_collide():
                        coll = o.get_hit_box().collide_sides(o2.get_hit_box())
                        #print("--",o,o2,coll)
                        if o != o2 and coll:
                            o.collide(o2, coll, (coll + 2) % 4)
                            o2.collide(o, (coll + 2) % 4, coll)
                            while o.get_rigid_body() and o2.get_rigid_body(
                            ) and o.get_rigid_hit_box().collide(
                                    o2.get_rigid_hit_box(
                                    )) and o.get_speed() != Vector(0, 0):
                                #print("rigid")
                                o.apply_solid_reaction(o2)

    def load_camera(self, fen):
        """ Loads the actual camera of the Level """
        self.background.load(fen)  #Loads the background too
        self.camera.set_fen(fen)
        self.camera.link_world(self)

    def get_background(self):
        """ Returns the background """
        return self.background

    def set_background(self, v):
        """ Set the background """
        self.background = v

    def aff(self, dt, objects):
        """ Aff all objects that are in the camera of this """
        self.camera.aff(objects, self.get_background(),
                        self.player.get_score(), dt)
        pygame.display.flip()
예제 #34
0
    def __init__(self,
                 objects,
                 player_pos,
                 limgpar=[],
                 name='',
                 parallax=True,
                 gravity=2100,
                 music=None):  #Gravity is set experimentally for jumps to 2100
        """ The player spawn in (0,0)  """
        assert objects != []  #Empty GameLevel
        self.camera = Camera()  #Camera
        self.camera.set_position(Vector(-12, -12))
        self.camera.set_dimension(Vector(25, 25))
        self.objects = objects
        self.player_pos = player_pos
        self.compute_size_level()
        self.name = name
        self.music = music

        #Creation of the gravity
        self.gravity = Gravity(
            gravity
        )  #NOTE POUR LES RAGEUX : On a testé et ca marche bien avec cette valeur -> ca permet d'avoir un saut élegant

        self.begin_time = 0
        self.time = 0  #Time Referential of the level

        #Death animation
        self.lost = False
        self.countdown = 1

        #Creation of the player
        self.player = Player()
        self.player.set_position(0, -16)  #Init pos of the player
        self.objects.append(self.player)
        self.player.link_world(self)

        #Camera Y scrolling
        self.camera_y_pos = self.player.get_position().y

        #To optimise physics
        self.sorted_objects = None
        self.dynamic_objects = set([self.player])
        self.opti_step = 10
        self.optimise_data()
        self.progression = 0

        #Get end platform locations to compute score
        self.end_platform_location = None
        self.compute_end_platform_location()

        #Load Background
        self.parallax = parallax
        self.load_bg(limgpar)

        #Link worlds
        for o in objects:
            o.link_world(self)

        #End the initialisatio
        self.end_init()
예제 #35
0
파일: play.py 프로젝트: chen9069/bird_em
#imports
from bots.pseudo_bot import PseudoBot
from bots.easy_bot import EasyBot
from bots.trainer import Trainer
from engine.dealer import Dealer
from engine.player import Player
    
#constants
#n/a

#functions
#n/a

#
valerie = Dealer()
#print("valerie will be our dealer.")

matt_damon = Player("Matt")
ed_norton = Player("Ed")
trainer = Trainer()

matt_damon.bot = EasyBot("MattBot")
ed_norton.bot = PseudoBot("EdBot")

# each iteration took about 1 min, default is 100 iters
# trainer = Trainer()
# trainer.train(matt_damon)

valerie.start_game(matt_damon, ed_norton)
#c = "To play a hand, run ``valerie.play_hand()``\n"
valerie.play_hand();