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) ])) ]
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)
def initialize_game(self): player = Player() player2 = Player() player2.ai = True for i in range(20): card = CardFactory.get_card_by_id(i) card.player = player card.interact_able = True player.deck.append(card) card2 = CardFactory.get_card_by_id(i) card2.visible = False player2.deck.append(card2) player.shuffle_deck() player.take_cards(3) self.objects.append(player) for i in range(len(player.hand)): player.hand[i].current_pos[0] = 300 + 150 * i player.hand[i].current_pos[1] = 400 player2.shuffle_deck() player2.take_cards(3) self.objects.append(player2) self.player = player self.player2 = player2 self.game_loo = Thread(target=self.game_loop) self.game_loo.start()
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)
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)
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)
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
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
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 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)
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))
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")
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 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
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
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
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()
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
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)
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
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))
def setUp(self): self.player = Player('player')
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()
import pygame, sys from engine.level import Level from pygame.event import event_name # import pygame and sys from engine.player import Player clock = pygame.time.Clock() # set up the clock from pygame.locals import * # import pygame modules pygame.init() # initiate pygame pygame.display.set_caption('Pygame Window') # set the window name WINDOW_SIZE = (1280, 720) # set up window size screen = pygame.display.set_mode(WINDOW_SIZE, 0, 32) # initiate screen player = Player() while True: # game loop screen.fill((146, 244, 255)) # clear screen by filling it with blue screen.fill((0, 0, 0), player.rect) screen.fill(pygame.Color("black"), player.level.rect) for event in pygame.event.get(): # event loop if event.type == QUIT: # check for window quit pygame.quit() # stop pygame sys.exit() # stop script pressed = pygame.key.get_pressed() player.leftInput = pressed[K_a] player.rightInput = pressed[K_d] player.downInput = pressed[K_s] player.upInput = pressed[K_w] player.applyMovement() pygame.display.update() # update display clock.tick(60) # maintain 60 fps
def test_add_and_retrieve_cards(self): player = Player("player2", 2) card1 = Card(VALUES[0], SUITS[0]) card2 = Card(VALUES[0], SUITS[0]) player.add_cards([card1, card2]) self.assertEqual(len(player.get_cards()), 2)
def test_add_and_retrieve_card(self): player = Player("player1", 1) card = Card(VALUES[0], SUITS[0]) player.add_card(card) self.assertEqual(player.get_cards()[0].value, VALUES[0]) self.assertEqual(player.get_cards()[0].suit, SUITS[0])
def setUp(self): """Create a Player for use in testing.""" self.player1 = Player() self.testitem = Detritus("A ROCK")
def get(self, request): player = Player("test", 100) serialized = PlayerSerializer(player).data return Response(serialized)