예제 #1
0
def test_win_game():
    p = game.Player('Player1', '1')
    q = game.Player('Player2', '2')
    g = game.Game(p, q)

    for i in range(3):
        g.play(p, 1)
        g.play(q, 2)

    assert g.status == 'IN_PROGRESS'

    g.play(p, 1)

    assert g.status == 'DONE'
    assert g.winner == p
예제 #2
0
def test_game():
    p = game.Player('Player1', '1')
    q = game.Player('Player2', '2')
    g = game.Game(p, q)

    with pytest.raises(game.OutOfTurnError):
        g.play(q, 0)

    move_number = g.play(p, 0)
    assert move_number == 0

    with pytest.raises(game.OutOfTurnError):
        g.play(p, 0)

    move_number = g.play(q, 0)
    assert move_number == 1
예제 #3
0
 def setUp(self):
     self.manager = game.Manager(game.Configuration())
     # We'll create players in postiions 0, 2, 3, and 7
     for idx in range(self.manager.config.max_players):
         self.manager.add_player(game.Player("name{}".format(idx), 0))
     for idx in [1, 4, 5, 6, 8, 9]:
         self.manager.remove_player(idx)
예제 #4
0
def connected():
    print("connected")
    if request.sid not in client_list:
        client_list.append(request.sid)
    socket.emit('server_connect', {'message': request.sid})
    # tell the new player about the room
    socket.emit('init_room', {
        'room_width': game.room.width,
        'room_height': game.room.height
    },
                room=request.sid)
    newChar = game.Player(request.sid)

    # tell everyone about the new player
    socket.emit(
        'init_player', {
            'sessionId': newChar.sessionId,
            'x_position': newChar.x_position,
            'y_position': newChar.y_position
        })

    # tell the new player about everyone else
    for key, value in game.playerDict.items():
        if value != newChar:
            socket.emit('init_player', {
                'sessionId': key,
                'x_position': value.x_position,
                'y_position': value.y_position,
                'hp': newChar.hp
            },
                        room=request.sid)
예제 #5
0
def main():
    printHeadline()
    rolls = game.Rolls
    name = get_players_name()

    player1 = game.Player(name)
    player2 = game.Computer()
    run_game(player1, player2, rolls)
예제 #6
0
파일: managers.py 프로젝트: stndart/Gnomes
 def __init__(self, cx, cy, px, py):
     self.field = [[game.Cell('grass') for i in range(cx)]
                   for j in range(cy)]
     self.player = game.Player('P1', [px, py], 10)
     self.player.backpack.load_recipes('resources/recipes.txt')
     self.em = None
     self.inventory_opened = False
     self.actions = None
예제 #7
0
 def setUp(self):
     self.manager = game.Manager(game.Configuration(ante=100))
     # We'll create players in postiions 0, 1
     for idx in range(2):
         self.manager.add_player(game.Player("name{}".format(idx), 500))
     # Add the recorder last because we don't care about the add events.
     self.recorder = game.RecordingListener()
     self.manager.add_listener(self.recorder)
예제 #8
0
async def login(request):
    player = game.Player(core)
    return web.json_response({
        "id": player.id,
        "token": _generate_token(player),
        "quote_to_find": player.quote_to_find.content,
        "suggestion": player.authors_suggestion.authors
    })
예제 #9
0
 def setUp(self):
     self.manager = game.Manager(game.Configuration(ante=100))
     # We'll create players in postiions 0, 2, 4
     for idx in range(5):
         self.manager.add_player(game.Player("name{}".format(idx), 1000))
     for idx in [1, 3]:
         self.manager.remove_player(idx)
     self.recorder = game.RecordingListener()
     self.manager.add_listener(self.recorder)
예제 #10
0
    def test_game_victory_should_add_to_points(self):

        player_1 = game.Player('Mr Hero Man', 'player_1', 0)

        goldgame_ui.victory()
        expected = 1
        actual = player_1.points

        self.assertEqual(actual, expected)
예제 #11
0
 def setUp(self):
     '''
     2 of Hearts is the top card in deck
     after building the deck
     '''
     self.player = game.Player("Bob")
     self.pile = game.Pile()
     self.deck = game.Deck()
     # Drew 2 of Hearts (top card)
     self.player.draw(self.deck, self.pile)
예제 #12
0
def handlemessage(originclient, message):
    splat = message.split(" ");
    if splat[0] == "CREATEROOM":
        room = Room(random.randint(1, 1))  #logica achter het gekozen id steken
        rooms[room.roomId] = room
    if splat[0] == "GETROOMS":
        send(originclient, json.dumps(rooms, cls=MyEncoder, indent=2))
    if splat[0] == "JOINROOM":  #JOINROOM roomid playername
        room = rooms.get(int(splat[1]))  #handle null
        if room.join(game.Player(splat[2])):
            send(originclient, "you joined room ")
예제 #13
0
    async def skills(self, ctx):
        player = game.Player(ctx.author)

        embed = self.create_embed(ctx.author, title="Character skills")

        skills = player.get_skills()

        for skill in skills:
            embed.add_field(name=skill, value=skills[skill])

        await ctx.send(embed=embed)
예제 #14
0
    async def me(self, ctx):
        player = game.Player(ctx.author)

        embed = self.create_embed(ctx.author, title="Character")

        attributes = player.get_attributes()

        for attribute in attributes:
            embed.add_field(name=attribute, value=attributes[attribute])

        await ctx.send(embed=embed)
예제 #15
0
    def initialize(self, config):
        self.manager = game.Manager(config)
        # We'll create players in postiions 0, 1, 2
        for idx in range(3):
            self.manager.add_player(game.Player("name{}".format(idx), 1000))

        self.manager.button_pos = 2
        self.manager.start_game()
        self.assertEqual(0, self.manager.button_pos)
        self.manager.proceed()
        self.assertEqual(game.GameState.HOLE_CARDS_DEALT, self.manager.state)
예제 #16
0
    def load_player(filename):
        name = os.path.basename(filename)[:-3]
        players_dir = os.path.dirname(filename)
        try:
            fp, pathname, description = imp.find_module(name, [players_dir])
            p = imp.load_module(name, fp, pathname, description)
            move_function = p.move  # Get module classes from imported modules
        except Exception as e:
            raise LoadError("Error loading player '{}': {}".format(name, e))

        return game.Player(name, move_function)
예제 #17
0
    def test_add_player(self):
        player = game.Player("myname", 1000)
        self.assertEqual(0, self.manager.add_player(player))
        self.assertEqual("myname", self.manager.players[0].name)
        self.assertEqual(1000, self.manager.players[0].stack)
        self.assertEqual(0, self.manager.players[0].position)

        self.assertEqual(1, len(self.recorder.events))
        self.assertEqual(
            "Event(EventType.PLAYER_ADDED, player=Player(myname, 1000, 0))",
            str(self.recorder.events[0]))
예제 #18
0
    async def equipment(self, ctx):
        player = game.Player(ctx.author)

        embed = self.create_embed(ctx.author, title="Equipment")

        equipment_items = player.get_equipment()

        for part in equipment_items:
            embed.add_field(name=part, value=equipment_items[part].name)

        await ctx.send(embed=embed)
예제 #19
0
    def set_options_for_new_map(self):
        '''Reads values from new game options and sets options for new map'''
        self.map_.size = self.new_game_options.map_size

        map_area = self.map_.size[0] * self.map_.size[1]
        self.map_.hex_number = int(self.new_game_options.hex_number / 100 *
                                   map_area)

        if self.new_game_options.players_number > self.map_.hex_number:
            self.new_game_options.players_number = self.map_.hex_number

        self.map_.players = []
        self.map_.players.append(game.Player((255, 0, 0)))
        for player in range(self.new_game_options.players_number - 1):
            self.map_.players.append(
                game.Player((random.randrange(40,
                                              215), random.randrange(40, 215),
                             random.randrange(40, 215))))

        self.gameplay.die_sides_number = self.new_game_options.die_sides_number

        self.gameplay.max_dice = self.new_game_options.max_dice_on_single_hex
예제 #20
0
def test_quit_game():
    p = game.Player('Player1', '1')
    q = game.Player('Player2', '2')
    r = game.Player('Player3', '3')
    g = game.Game(p, q, r)

    assert g.status == 'IN_PROGRESS'

    g.quit(p)

    # can't play if you already quit
    with pytest.raises(ValueError):
        g.play(p, 0)

    # make sure other players can play
    g.play(q, 1)
    g.play(r, 1)

    # only 1 player left, so that player wins
    g.quit(q)
    assert g.status == 'DONE'
    assert g.winner == r
예제 #21
0
def main():
    logging.basicConfig(level=logging.INFO)

    keyboard = controller.Keyboard()
    mouse = controller.Mouse()
    player = game.Player(keyboard, mouse)
    bobber_finder = get_bobber_finder()

    player.init()

    for i in range(20):
        print('attempt ' + str(i))
        fishing(player, bobber_finder)
예제 #22
0
 def setUp(self):
     self.manager = game.Manager(game.Configuration())
     self.manager._deck_factory = in_order_deck_factory
     # We'll create players in postiions 0, 2, 4
     for idx in range(5):
         self.manager.add_player(game.Player("name{}".format(idx), 0))
     for idx in [1, 3]:
         self.manager.remove_player(idx)
     # Add the recorder last because we don't care about the add/remove events.
     self.recorder = game.RecordingListener()
     self.manager.add_listener(self.recorder)
     # we do long string diffs
     self.maxDiff = None
예제 #23
0
    async def inventory(self, ctx):
        player = game.Player(ctx.author)
        inventory = player.get_inventory_contents()

        embed = self.create_embed(
            ctx.author,
            title="Inventory",
        )

        for item in inventory:
            embed.add_field(name=f"{item.name} \"*{item.entity_id}*\"",
                            value=item.desc)

        await ctx.send(embed=embed)
예제 #24
0
    def test_remove_player(self):
        self.manager.add_player(game.Player("name0", 0))
        self.manager.add_player(game.Player("name1", 1000))
        self.manager.add_player(game.Player("name2", 2000))

        # We clear the recorder here because we don't care what
        # happened before the thing we wanted to test.
        self.recorder.clear()

        removed = self.manager.remove_player(1)
        self.assertEqual("name1", removed.name)
        self.assertEqual(1000, removed.stack)
        self.assertEqual(1, removed.position)

        self.assertEqual(1, len(self.recorder.events))
        self.assertEqual(
            "Event(EventType.PLAYER_REMOVED, player=Player(name1, 1000, 1))",
            str(self.recorder.events[0]))

        with self.assertRaises(game.NoSuchPlayerError):
            self.manager.remove_player(4)

        with self.assertRaises(game.NoSuchPlayerError):
            self.manager.remove_player(9999)
예제 #25
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('commands', type=str, nargs='+')
    args = parser.parse_args(sys.argv[1:])

    cwd = os.getcwd()

    players = [game.Player(i, cwd, cmd) for i, cmd in enumerate(args.commands)]
    g = game.Game(players)
    try:
        g.play()
        for p in g.players:
            print('Player {}: {}'.format(p.pk, p.wealth))
    finally:
        for p in g.players:
            p.cleanup()
예제 #26
0
    def __init__(self):
        pygame.init()
        players = [game.Player((255, 0, 0))]

        resolution = pygame.display.Info()

        self.window_size = (resolution.current_w, resolution.current_h)

        self.map_ = map.Map((5, 5), 10, players, 4, 32, self.window_size)
        self.map_.create_map()

        self.gameplay = game.Gameplay(self.map_, 6, 2000, 8)
        self.graphics = graphics.Graphics(self.map_, self.gameplay,
                                          self.window_size)
        self.event_handler = events.EventHandler(self.map_, self.graphics,
                                                 self.gameplay)
예제 #27
0
    def setUp(self):
        self.manager = game.Manager(game.Configuration(max_players=4,
                                                       game_type=game.GameType.LIMIT,
                                                       limits=[10,20],
                                                       blinds=[5, 10]))
        self.manager._deck_factory = in_order_deck_factory
        # We'll create players in postiions 0, 1, 2
        for idx in range(3):
            self.manager.add_player(game.Player("name{}".format(idx), 1000))

        # Button will be advanced to 0
        self.manager.button_pos = 3
        self.recorder = game.RecordingListener()
        self.manager.add_listener(self.recorder)
        # we do long string diffs
        self.maxDiff = None
예제 #28
0
def start_game(player_count):
    players.clear()

    print("start game {} {} {} {}".format(pi.read(PLAYER0_HOOK_PIN),
                                          pi.read(PLAYER1_HOOK_PIN),
                                          pi.read(PLAYER2_HOOK_PIN),
                                          pi.read(PLAYER3_HOOK_PIN)))
    if (pi.read(PLAYER0_HOOK_PIN) == 1) or \
        (pi.read(PLAYER1_HOOK_PIN) == 1) or \
        (pi.read(PLAYER2_HOOK_PIN) == 1) or \
        (pi.read(PLAYER3_HOOK_PIN) == 1):
        Text(app,
             text="All Phones Must Be On HOOK",
             size=65,
             font=font,
             grid=[0, 2],
             color=main_font_color,
             align='center')
        return

    clear_screen()

    message_index = randint(0, len(phrases) - 1)
    message = phrases[message_index]

    Text(app,
         text=message,
         size=font_size,
         font=font,
         color=phrase_color,
         grid=[0, 0, 3, 1],
         align='left')
    Text(app,
         text="1 - Undo     0 - Space",
         size=int(font_size / 2),
         font=font,
         color=phrase_color,
         grid=[2, 10],
         align='bottom')

    for i in range(player_count):
        print("creating player {}".format(i))
        players.append(game.Player(i, app, message))

    print("player count {}".format(len(players)))
예제 #29
0
def create_player():
    """ Creates a new player based on JSON sent and adds the new player to the database. Associates based on logged in user_id. """
    new_player_request = request.get_json()
    name = new_player_request['name']
    player_type = new_player_request['type']
    mutation_id = random.choice(game.Mutation.query.all()).mutation_id
    player_class = game.Player_Class.query.filter(
        game.Player_Class.name == player_type).one()
    new_player = game.Player(user_id=session['user_id'],
                             name=name,
                             mutation_id=mutation_id,
                             alive=True,
                             score=0,
                             stats=player_class.base_stats,
                             exp=0,
                             level=1,
                             player_class=player_class.class_id)
    game.db.session.add(new_player)
    game.db.session.commit()
    return ""  # this does return nothing, but feels weird
예제 #30
0
def new_player_handler(client_socket):
    print("new_player_handler")
    player = game.Player()

    current_game = add_player_to_game(player)
    while True:
        if current_game.game_started:
            data = protocol_commands.pack_join_reply(keys.PLAY)
            client_socket.send(data)
            if (protocol_commands.is_it_ok(client_socket.recv(2))):
                threading.Thread(target=client_send_handler,
                                 args=[client_socket, player,
                                       current_game]).start()
                threading.Thread(target=client_recv_handler,
                                 args=[client_socket, player,
                                       current_game]).start()
                break
        else:
            client_socket.send(protocol_commands.pack_join_reply(keys.WAIT))
            client_socket.recv(2)