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)
