Python GameControl.get_events Exemples

Exemple #1

Fichier : test_game_control.py Projet : neuront/sgs

    assert_eq(card.SPADE, cards[1]['suit'])
# player 2's round, beginning only
assert_eq(2, events[7]['player'])
assert_eq(2, len(events[7]['draw']))
if True: # just indent for a nice appearance, card list verifying
    cards = events[7]['draw']
    assert_eq(16, cards[0]['id'])
    assert_eq('dodge', cards[0]['name'])
    assert_eq(4, cards[0]['rank'])
    assert_eq(card.HEART, cards[0]['suit'])
    assert_eq(17, cards[1]['id'])
    assert_eq('dodge', cards[1]['name'])
    assert_eq(5, cards[1]['rank'])
    assert_eq(card.HEART, cards[1]['suit'])

player0_events = gc.get_events(players[0].token, 0)
assert_eq(8, len(player0_events))
# game started
assert_eq(events[0]['player'], player0_events[0]['player'])
assert_eq(events[0]['draw'], player0_events[0]['draw'])
assert_eq(events[1]['player'], player0_events[1]['player'])
assert_eq(4, player0_events[1]['draw'])
assert_eq(events[2]['player'], player0_events[2]['player'])
assert_eq(4, player0_events[2]['draw'])
# player 0's round
assert_eq(events[3]['player'], player0_events[3]['player'])
assert_eq(events[3]['draw'], player0_events[3]['draw'])
assert_eq(events[4]['player'], player0_events[4]['player'])
assert_eq(events[4]['discard'], player0_events[4]['discard'])
# player 1's round
assert_eq(events[5]['player'], player0_events[5]['player'])

Exemple #2

Fichier : test_heavenly_scent.py Projet : linluxiang/sgs

assert_eq({
              'code': ret_code.BAD_REQUEST,
              'reason': ret_code.BR_WRONG_ARG % 'wrong cards',
          }, result)

result = gc.player_act({
                           'token': players[0].token,
                           'targets': [players[1].player_id],
                           'discard': [2, 3],
                       })
assert_eq({
              'code': ret_code.BAD_REQUEST,
              'reason': ret_code.BR_WRONG_ARG % 'wrong cards',
          }, result)

last_event_id = len(gc.get_events(players[0].token, 0)) # until discard a card
# cards:
# name         | rank | id | suit

# rattan armor | 2    | 1  | CLUB <- equipped
# slash        | 3    | 2  | HEART <- discard this
# slash        | 4    | 3  | HEART
# slash        | 10   | 9  | CLUB

# rattan armor | 2    | 4  | SPADE
# fire attack  | 7    | 6  | HEART
# duel         | 8    | 7  | HEART
# dodge        | 12   | 11 | HEART
result = gc.player_act({
                           'token': players[0].token,
                           'targets': [players[1].player_id],

Exemple #3

})
assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
    'token': players[0].token,
    'show': [2],
})
assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
    'token': players[1].token,
    'discard': [15],
})
assert_eq(ret_code.OK, result['code'])

last_event_id = len(gc.get_events(players[0].token, 0))  # until brink of death

# cards:
# name         | rank | id | suit

# rattan armor | 2    | 0  | CLUB <- equipped
# slash        | 2    | 1  | SPADE
# slash        | 3    | 2  | HEART
# peach        | 4    | 3  | HEART

# slash        | 5    | 4  | CLUB
# peach        | 8    | 7  | HEART <- rescue
result = gc.player_act({
    'token': players[1].token,
    'method': 'peach',
    'play': [7],

Exemple #4

            test_data.CardInfo('duel', 1, card.SPADE),
            test_data.CardInfo('zhangba serpent spear', 2, card.SPADE),
            test_data.CardInfo('slash', 3, card.DIAMOND),
            test_data.CardInfo('dodge', 4, card.DIAMOND),
            test_data.CardInfo('slash', 5, card.CLUB),
            test_data.CardInfo('sabotage', 6, card.HEART),
            test_data.CardInfo('dodge', 7, card.DIAMOND),
            test_data.CardInfo('slash', 8, card.DIAMOND),
            test_data.CardInfo('duel', 9, card.SPADE),
            test_data.CardInfo('zhangba serpent spear', 10, card.HEART),
        ])), pc, ActionStack())
players = [Player(91, 4), Player(1729, 4)]
map(lambda p: pc.add_player(p), players)
gc.start()

last_event_id = len(gc.get_events(players[0].token, 0))  # until getting cards

result = gc.player_act({
    'token': players[0].token,
    'action': 'equip',
    'use': [1],
})
assert_eq(ret_code.OK, result['code'])
p0_events = gc.get_events(players[0].token, last_event_id)
assert_eq(1, len(p0_events))
if True:  # just indent for a nice appearance
    event = p0_events[0]
    assert_eq(players[0].player_id, event['player'])
    assert_eq('zhangba serpent spear', event['equip']['name'])
    assert_eq(2, event['equip']['rank'])
    assert_eq(card.SPADE, event['equip']['suit'])

Exemple #5

Fichier : test_peach.py Projet : neuront/sgs

    },
    'abort': 'allow',
    'players': [players[1].player_id],
}, gc.hint(players[1].token))

result = gc.player_act({
    'token': players[1].token,
    'action': 'peach',
    'use': [4],
})
assert_eq({
    'code': ret_code.BAD_REQUEST,
    'reason': ret_code.BR_WRONG_ARG % 'wrong cards',
}, result)

last_event_id = len(gc.get_events(players[0].token, 0)) # about to use peach

result = gc.player_act({
    'token': players[1].token,
    'action': 'card',
    'use': [5],
})
assert_eq(ret_code.OK, result['code'])

p0_events = gc.get_events(players[0].token, last_event_id)
assert_eq(2, len(p0_events))
if True: # just indent for a nice appearance
    event = p0_events[0]
    assert_eq(players[1].player_id, event['user'])
    assert_eq(1, len(event['targets']))
    assert_eq(players[1].player_id, event['targets'][0])

Exemple #6

Fichier : test_fire_attack_to_player_with_equipment_only.py Projet : linluxiang/sgs

                       })
assert_eq(ret_code.OK, result['code'])

# sabotage all in-hand cards of player 0
for i in range(0, 3):
    result = gc.player_act({
                               'token': players[1].token,
                               'action': 'sabotage',
                               'targets': [players[0].player_id],
                               'use': [5 + i],
                           })
    assert_eq(ret_code.OK, result['code'])
    result = gc.player_act({
                               'token': players[1].token,
                               'sabotage': 'cards',
                           })
    assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
                           'token': players[1].token,
                           'action': 'fire attack',
                           'targets': [players[0].player_id],
                           'use': [4],
                       })
assert_eq({
              'code': ret_code.BAD_REQUEST,
              'reason': ret_code.BR_WRONG_ARG % 'forbid target no card',
          }, result)

last_event_id = len(gc.get_events(players[0].token, 0)) # until getting cards

Exemple #7

Fichier : test_brink_of_death_and_rescue.py Projet : neuront/sgs

assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
                           'token': players[0].token,
                           'discard': [2],
                       })
assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
                           'token': players[1].token,
                           'method': 'discard',
                           'discard': [15],
                       })
assert_eq(ret_code.OK, result['code'])

last_event_id = len(gc.get_events(players[0].token, 0)) # until brink of death

assert_eq({
              'code': ret_code.OK,
              'action': 'discard',
              'players': [players[1].player_id],
          }, gc.hint(players[0].token))
assert_eq(gc.hint(players[0].token), gc.hint(players[2].token))
assert_eq({
    'code': ret_code.OK,
    'action': 'discard',
    'methods': {
        'peach': {
            'require': ['fix card count'],
            'card count': 1,
            'cards': [7],

Exemple #8

Fichier : test_duel.py Projet : linluxiang/sgs

            test_data.CardInfo('slash', 3, card.DIAMOND),
            test_data.CardInfo('duel', 4, card.SPADE),

            test_data.CardInfo('slash', 5, card.CLUB),
            test_data.CardInfo('fire attack', 6, card.HEART),
            test_data.CardInfo('dodge', 7, card.DIAMOND),
            test_data.CardInfo('slash', 8, card.DIAMOND),

            test_data.CardInfo('duel', 9, card.SPADE),
            test_data.CardInfo('slash', 10, card.SPADE),
     ])), pc, ActionStack())
players = [Player(91, 4), Player(1729, 4)]
map(lambda p: pc.add_player(p), players)
gc.start()

last_event_id = len(gc.get_events(players[0].token, 0)) # until getting cards

# cards:
# name        | rank (id = rank - 1) | suit

# duel        | 1                    | SPADE   <- use this to duel
# fire attack | 2                    | HEART
# slash       | 3                    | DIAMOND
# duel        | 4                    | SPADE
# duel        | 9                    | SPADE
# slash       | 10                   | SPADE

# slash       | 5                    | CLUB
# fire attack | 6                    | HEART
# dodge       | 7                    | DIAMOND
# slash       | 8                    | DIAMOND

Exemple #9

Fichier : test_dragon_heart_martial_saint_slash_response.py Projet : neuront/sgs

# duel         | 4                    | SPADE
# duel         | 9                    | SPADE
# slash        | 10                   | SPADE

# slash        | 5                    | CLUB
# arson attack | 6                    | HEART
# dodge        | 7                    | DIAMOND
# slash        | 8                    | DIAMOND
result = gc.player_act({
                          'token': players[0].token,
                          'action': 'card',
                          'targets': [players[1].player_id],
                          'use': [0],
                      })
assert_eq(ret_code.OK, result['code'])
last_event_id = len(gc.get_events(players[0].token, 0)) # until duel

result = gc.player_act({
                          'token': players[1].token,
                          'method': 'dragon heart',
                          'discard': [7],
                      })
assert_eq({
              'code': ret_code.BAD_REQUEST,
              'reason': ret_code.BR_WRONG_ARG % 'wrong cards',
          }, result)

result = gc.player_act({
                          'token': players[1].token,
                          'method': 'martial saint',
                          'discard': [7],

Exemple #10

Fichier : test_fire_attack_to_player_with_equipment_only.py Projet : linluxiang/sgs

assert_eq(ret_code.OK, result['code'])

# sabotage all in-hand cards of player 0
for i in range(0, 3):
    result = gc.player_act({
        'token': players[1].token,
        'action': 'sabotage',
        'targets': [players[0].player_id],
        'use': [5 + i],
    })
    assert_eq(ret_code.OK, result['code'])
    result = gc.player_act({
        'token': players[1].token,
        'sabotage': 'cards',
    })
    assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
    'token': players[1].token,
    'action': 'fire attack',
    'targets': [players[0].player_id],
    'use': [4],
})
assert_eq(
    {
        'code': ret_code.BAD_REQUEST,
        'reason': ret_code.BR_WRONG_ARG % 'forbid target no card',
    }, result)

last_event_id = len(gc.get_events(players[0].token, 0))  # until getting cards

Exemple #11

Fichier : test_suicide.py Projet : linluxiang/sgs

result = gc.player_act({
                           'token': players[0].token,
                           'method': 'give up',
                           'play': [],
                       })
assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
                           'token': players[1].token,
                           'method': 'give up',
                           'play': [],
                       })
assert_eq(ret_code.OK, result['code'])

last_event_id = len(gc.get_events(players[0].token, 0)) # until player2

result = gc.player_act({
                           'token': players[2].token,
                           'method': 'give up',
                           'play': [],
                       })
assert_eq(ret_code.OK, result['code'])

p0_events = gc.get_events(players[0].token, last_event_id)
assert_eq(2, len(p0_events))
if True: # just indent for a nice appearance
    event = p0_events[0]
    assert_eq(players[0].player_id, event['player'])
    assert_eq('PlayerKilled', event['type'])
    event = p0_events[1]

Exemple #12

Fichier : test_slash.py Projet : neuront/sgs

        8: {
            'require': ['fix target'],
            'target count': 1,
            'targets': [1],
        },
        9: {
            'require': ['fix target'],
            'target count': 1,
            'targets': [1],
        },
    },
    'abort': 'allow',
    'players': [players[0].player_id],
}, gc.hint(players[0].token))

last_event_id = len(gc.get_events(players[0].token, 0)) # until started

result = gc.player_act({
    'token': players[0].token,
    'action': 'card',
    'targets': [players[1].player_id],
    'use': [0],
})
assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
    'token': players[1].token,
    'method': 'dodge',
    'discard': [4],
})
assert_eq(ret_code.OK, result['code'])

Exemple #13

Fichier : test_rattan_armor.py Projet : neuront/sgs

            test_data.CardInfo('steal', 5, card.CLUB),
            test_data.CardInfo('arson attack', 6, card.HEART),
            test_data.CardInfo('dodge', 7, card.HEART),
            test_data.CardInfo('duel', 8, card.HEART),

            test_data.CardInfo('slash', 9, card.SPADE),
            test_data.CardInfo('slash', 10, card.CLUB),

            test_data.CardInfo('arson attack', 11, card.CLUB),
            test_data.CardInfo('dodge', 12, card.HEART),
     ])), pc, ActionStack())
players = [Player(91, 8), Player(1729, 8)]
map(lambda p: pc.add_player(p), players)
gc.start()

last_event_id = len(gc.get_events(players[0].token, 0)) # until getting cards

# cards:
# name         | rank | id | suit

# rattan armor | 2    | 0  | CLUB <- equip this
# rattan armor | 2    | 1  | SPADE <-  and this
# slash        | 3    | 2  | HEART
# slash        | 4    | 3  | HEART
# slash        | 9    | 8  | SPADE
# slash        | 10   | 9  | CLUB

# steal        | 5    | 4  | CLUB
# arson attack | 6    | 5  | HEART
# dodge        | 7    | 6  | HEART
# duel         | 8    | 7  | HEART

Exemple #14

Fichier : test_merciless.py Projet : linluxiang/sgs

# dodge        | 12   | 11 | HEART <-discard this
result = gc.player_act({
                           'token': players[1].token,
                           'action': 'fire attack',
                           'targets': [players[0].player_id],
                           'use': [5],
                       })
assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
                           'token': players[0].token,
                           'show': [2],
                       })
assert_eq(ret_code.OK, result['code'])

last_event_id = len(gc.get_events(players[0].token, 0)) # until show a card

result = gc.player_act({
                           'token': players[1].token,
                           'discard': [11],
                       })
assert_eq(ret_code.OK, result['code'])

p0_events = gc.get_events(players[0].token, last_event_id)
assert_eq(2, len(p0_events))
if True: # just indent for a nice appearance
    event = p0_events[0]
    assert_eq(1, len(event['discard']))
    assert_eq('dodge', event['discard'][0]['name'])
    assert_eq(12, event['discard'][0]['rank'])
    assert_eq(card.HEART, event['discard'][0]['suit'])

Exemple #15

Fichier : test_zhangba_serpent_spear.py Projet : neuront/sgs

    test_data.CardInfo('slash', 3, card.DIAMOND),
    test_data.CardInfo('dodge', 4, card.DIAMOND),

    test_data.CardInfo('slash', 5, card.CLUB),
    test_data.CardInfo('sabotage', 6, card.HEART),
    test_data.CardInfo('dodge', 7, card.DIAMOND),
    test_data.CardInfo('slash', 8, card.DIAMOND),

    test_data.CardInfo('duel', 9, card.SPADE),
    test_data.CardInfo('zhangba serpent spear', 10, card.HEART),
])), pc, ActionStack())
players = [Player(91, 4), Player(1729, 4)]
map(lambda p: pc.add_player(p), players)
gc.start()

last_event_id = len(gc.get_events(players[0].token, 0)) # until getting cards

assert_eq({
    'code': ret_code.OK,
    'action': 'use',
    'card': {
        0: {
            'require': ['fix target'],
            'target count': 1,
            'targets': [1],
        },
        1: { 'require': ['implicit target'] },
        2: {
            'require': ['fix target'],
            'target count': 1,
            'targets': [1],

Exemple #16

Fichier : test_vermilion_feather_fan.py Projet : neuront/sgs

    test_data.CardInfo('slash', 3, card.DIAMOND),
    test_data.CardInfo('dodge', 4, card.DIAMOND),

    test_data.CardInfo('slash', 5, card.CLUB),
    test_data.CardInfo('slash', 6, card.HEART),
    test_data.CardInfo('dodge', 7, card.DIAMOND),
    test_data.CardInfo('slash', 8, card.DIAMOND),

    test_data.CardInfo('duel', 9, card.SPADE),
    test_data.CardInfo('thunder slash', 10, card.HEART),
])), pc, ActionStack())
players = [Player(91, 4), Player(1729, 4)]
map(lambda p: pc.add_player(p), players)
gc.start()

last_event_id = len(gc.get_events(players[0].token, 0)) # until getting cards

assert_eq({
    'code': ret_code.OK,
    'action': 'use',
    'card': {
        0: { 'require': ['implicit target'] },
        1: {
            'require': ['fix target'],
            'target count': 1,
            'targets': [1],
        },
        2: {
            'require': ['fix target'],
            'target count': 1,
            'targets': [1],

Exemple #17

# dodge        | 12   | 11 | HEART <-discard this
result = gc.player_act({
    'token': players[1].token,
    'action': 'fire attack',
    'targets': [players[0].player_id],
    'use': [5],
})
assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
    'token': players[0].token,
    'show': [2],
})
assert_eq(ret_code.OK, result['code'])

last_event_id = len(gc.get_events(players[0].token, 0))  # until show a card

result = gc.player_act({
    'token': players[1].token,
    'discard': [11],
})
assert_eq(ret_code.OK, result['code'])

p0_events = gc.get_events(players[0].token, last_event_id)
assert_eq(2, len(p0_events))
if True:  # just indent for a nice appearance
    event = p0_events[0]
    assert_eq(1, len(event['discard']))
    assert_eq('dodge', event['discard'][0]['name'])
    assert_eq(12, event['discard'][0]['rank'])
    assert_eq(card.HEART, event['discard'][0]['suit'])

Exemple #18

Fichier : test_arson_attack.py Projet : neuront/sgs

            test_data.CardInfo('slash', 5, card.CLUB),
            test_data.CardInfo('arson attack', 6, card.HEART),
            test_data.CardInfo('dodge', 7, card.DIAMOND),
            test_data.CardInfo('dodge', 8, card.DIAMOND),

            test_data.CardInfo('slash', 9, card.SPADE),
            test_data.CardInfo('slash', 10, card.SPADE),

            test_data.CardInfo('dodge', 11, card.HEART),
            test_data.CardInfo('dodge', 12, card.DIAMOND),
     ])), pc, ActionStack())
players = [Player(91, 4), Player(1729, 4)]
map(lambda p: pc.add_player(p), players)
gc.start()

last_event_id = len(gc.get_events(players[0].token, 0)) # until getting cards

assert_eq({
    'code': ret_code.OK,
    'action': 'use',
    'card': {
        0: {
            'require': ['fix target'],
            'target count': 1,
            'targets': [1],
        },
        1: {
            'require': ['fix target'],
            'target count': 1,
            'targets': [0, 1],
        },

Exemple #19

Fichier : test_suicide.py Projet : linluxiang/sgs

result = gc.player_act({
    'token': players[0].token,
    'method': 'give up',
    'play': [],
})
assert_eq(ret_code.OK, result['code'])

result = gc.player_act({
    'token': players[1].token,
    'method': 'give up',
    'play': [],
})
assert_eq(ret_code.OK, result['code'])

last_event_id = len(gc.get_events(players[0].token, 0))  # until player2

result = gc.player_act({
    'token': players[2].token,
    'method': 'give up',
    'play': [],
})
assert_eq(ret_code.OK, result['code'])

p0_events = gc.get_events(players[0].token, last_event_id)
assert_eq(2, len(p0_events))
if True:  # just indent for a nice appearance
    event = p0_events[0]
    assert_eq(players[0].player_id, event['player'])
    assert_eq('PlayerKilled', event['type'])
    event = p0_events[1]

Exemple #20

Fichier : test_steal.py Projet : linluxiang/sgs

                test_data.CardInfo("slash", 1, card.CLUB),
                test_data.CardInfo("steal", 9, card.HEART),
                test_data.CardInfo("steal", 10, card.CLUB),
                test_data.CardInfo("steal", 9, card.HEART),
                test_data.CardInfo("steal", 10, card.CLUB),
            ]
        )
    ),
    pc,
    ActionStack(),
)
players = [Player(19, 3), Player(91, 4), Player(1729, 4)]
map(lambda p: pc.add_player(p), players)
gc.start()

last_event_id = len(gc.get_events(players[0].token, 0))  # until getting cards

# cards:
# name     | rank | id | suit

# -chitu   | 5    | 0  | HEART
# -dawan   | 13   | 1  | SPADE
# +jueying | 5    | 2  | SPADE
# slash    | 1    | 3  | CLUB
# steal    | 9    | 12 | HEART <- use this
# steal    | 10   | 13 | CLUB

# steal    | 7    | 4  | CLUB
# duel     | 8    | 5  | DIAMOND
# -zixing  | 13   | 6  | DIAMOND
# +dilu    | 5    | 7  | CLUB

Exemple #21

        'code': ret_code.BAD_REQUEST,
        'reason': ret_code.BR_WRONG_ARG % 'wrong cards',
    }, result)

result = gc.player_act({
    'token': players[0].token,
    'targets': [players[1].player_id],
    'discard': [2, 3],
})
assert_eq(
    {
        'code': ret_code.BAD_REQUEST,
        'reason': ret_code.BR_WRONG_ARG % 'wrong cards',
    }, result)

last_event_id = len(gc.get_events(players[0].token, 0))  # until discard a card
# cards:
# name         | rank | id | suit

# rattan armor | 2    | 1  | CLUB <- equipped
# slash        | 3    | 2  | HEART <- discard this
# slash        | 4    | 3  | HEART
# slash        | 10   | 9  | CLUB

# rattan armor | 2    | 4  | SPADE
# fire attack  | 7    | 6  | HEART
# duel         | 8    | 7  | HEART
# dodge        | 12   | 11 | HEART
result = gc.player_act({
    'token': players[0].token,
    'targets': [players[1].player_id],