Python GameControl.player_act Exemples, core.src.game_control.GameControl.player_act Python Exemples

Exemple #1

0

Afficher le fichier

Fichier : test_merciless.py Projet : linluxiang/sgs

# name         | rank | id | suit

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

# slash        | 5    | 4  | CLUB
# fire attack  | 6    | 5  | HEART
# duel         | 7    | 6  | HEART
# duel         | 8    | 7  | HEART
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'equip',
                           'use': [1],
                       })
assert_eq(ret_code.OK, result['code'])

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

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

Exemple #2

0

Afficher le fichier

Fichier : test_fury_pith.py Projet : linluxiang/sgs

# cards:
# name     | rank | id | suit

# +jueying | 1    | 0  | SPADE
# duel     | 2    | 1  | HEART <- use this
# duel     | 3    | 2  | HEART
# duel     | 4    | 3  | HEART
# duel     | 9    | 8  | HEART
# duel     | 10   | 9  | HEART

# dodge    | 5    | 4  | DIAMOND
# slash    | 6    | 5  | HEART
# slash    | 7    | 6  | HEART
# slash    | 8    | 7  | HEART
result = gc.player_act({"token": players[0].token, "action": "duel", "targets": [players[1].player_id], "use": [1]})
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": "give up", "play": []})
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[1].player_id, event["victim"])
    assert_eq(1, event["damage"])
    assert_eq("normal", event["category"])
p1_events = gc.get_events(players[1].token, last_event_id)

Exemple #3

0

Afficher le fichier

Fichier : test_game_control.py Projet : neuront/sgs

            test_data.CardInfo('slash', 10, card.SPADE),
            test_data.CardInfo('slash', 11, card.SPADE),
            test_data.CardInfo('slash', 12, card.SPADE),
            test_data.CardInfo('slash', 13, card.SPADE),
            test_data.CardInfo('dodge', 1, card.HEART),
            test_data.CardInfo('dodge', 2, card.HEART),
            test_data.CardInfo('dodge', 3, card.HEART),
            test_data.CardInfo('dodge', 4, card.HEART),
            test_data.CardInfo('dodge', 5, card.HEART),
     ])), pc, ActionStack())
players = [fake_player.Player(6), fake_player.Player(24),
           fake_player.Player(1729)]
map(lambda p: pc.add_player(p), players)
gc.start()
assert_eq(200, gc.player_act({
                                 'token': players[0].token,
                                 'action': 'abort',
                             })['code'])
assert_eq(200, gc.player_act({
                                 'token': players[0].token,
                                 'discard': [0, 1],
                             })['code'])
assert_eq(200, gc.player_act({
                                 'token': players[1].token,
                                 'action': 'abort',
                             })['code'])
assert_eq(200, gc.player_act({
                                 'token': players[1].token,
                                 'discard': [4, 5],
                             })['code'])

events = gc.events.as_log()

Exemple #4

0

Afficher le fichier

# name         | rank | id | suit

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

# slash        | 5    | 4  | CLUB
# fire attack  | 6    | 5  | HEART
# duel         | 7    | 6  | HEART
# duel         | 8    | 7  | HEART
result = gc.player_act({
    'token': players[0].token,
    'action': 'equip',
    'use': [1],
})
assert_eq(ret_code.OK, result['code'])

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

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

Exemple #5

0

Afficher le fichier

# slash                 | 1    | 3  | CLUB
# +zhuahuangfeidian     | 5    | 12 | HEART
# zhangba serpent spear | 7    | 13 | HEART

# -zixing               | 13   | 4  | DIAMOND
# +dilu                 | 5    | 5  | CLUB
# +hualiu               | 5    | 6  | DIAMOND
# duel                  | 2    | 7  | SPADE

# sabotage              | 3    | 8  | HEART
# dodge                 | 4    | 9  | DIAMOND
# slash                 | 5    | 10 | DIAMOND
# slash                 | 6    | 11 | SPADE
result = gc.player_act({
                          'token': players[0].token,
                          'action': 'equip',
                          'use': [0],
                      })
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('-chitu', event['equip']['name'])
    assert_eq(5, event['equip']['rank'])
    assert_eq(card.HEART, event['equip']['suit'])
    assert_eq(0, event['equip']['id'])
p1_events = gc.get_events(players[1].token, last_event_id)
assert_eq(1, len(p1_events))
if True: # just indent for a nice appearance

Exemple #6

0

Afficher le fichier

Fichier : test_arson_attack.py Projet : neuront/sgs

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

# slash        | 1                    | SPADE
# arson attack | 2                    | HEART <- use this
# dodge        | 3                    | DIAMOND
# arson attack | 4                    | HEART
# slash        | 9                    | SPADE
# slash        | 10                   | SPADE

# slash        | 5                    | CLUB
# arson attack | 6                    | HEART
# dodge        | 7                    | DIAMOND
# dodge        | 8                    | DIAMOND
result = gc.player_act({
        'token': players[0].token,
        'action': 'card',
        'targets': [players[1].player_id],
        '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['user'])
    assert_eq(1, len(event['targets']))
    assert_eq(players[1].player_id, event['targets'][0])
    assert_eq('arson attack', event['action'])
    assert_eq(1, len(event['use']))
    assert_eq('arson attack', event['use'][0]['name'])
    assert_eq(2, event['use'][0]['rank'])

Exemple #7

0

Afficher le fichier

Fichier : test_fire_attack_to_player_with_equipment_only.py Projet : linluxiang/sgs

            test_data.CardInfo('sabotage', 7, card.DIAMOND),
            test_data.CardInfo('sabotage', 8, card.DIAMOND),

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

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

result = gc.player_act({
                           'token': players[0].token,
                           'action': 'equip',
                           'use': [0],
                       })
assert_eq(ret_code.OK, result['code'])
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'give up',
                       })
assert_eq(ret_code.OK, result['code'])
result = gc.player_act({
                           'token': players[0].token,
                           'discard': [2, 3],
                       })
assert_eq(ret_code.OK, result['code'])

# player 0 show the weapon

Exemple #8

0

Afficher le fichier

Fichier : test_steal.py Projet : neuront/sgs

# 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
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'card',
                           'targets': [players[1].player_id],
                           'use': [12],
                       })
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['user'])
    assert_eq(1, len(event['targets']))
    assert_eq(players[1].player_id, event['targets'][0])
    assert_eq('steal', event['action'])
    assert_eq(1, len(event['use']))
    assert_eq('steal', event['use'][0]['name'])
    assert_eq(9, event['use'][0]['rank'])
    assert_eq(card.HEART, event['use'][0]['suit'])

Exemple #9

0

Afficher le fichier

Fichier : test_fire_attack.py Projet : linluxiang/sgs

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

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

# slash       | 5                    | CLUB
# fire attack | 6                    | HEART
# dodge       | 7                    | DIAMOND
# dodge       | 8                    | DIAMOND
result = gc.player_act({
        'token': players[0].token,
        'action': 'fire attack',
        'targets': [players[1].player_id],
        '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['user'])
    assert_eq(1, len(event['targets']))
    assert_eq(players[1].player_id, event['targets'][0])
    assert_eq('fire attack', event['action'])
    assert_eq(1, len(event['use']))
    assert_eq('fire attack', event['use'][0]['name'])
    assert_eq(2, event['use'][0]['rank'])
    assert_eq(card.HEART, event['use'][0]['suit'])

Exemple #10

0

Afficher le fichier

Fichier : test_no_onhand_region_if_no_cards.py Projet : neuront/sgs

                test_data.CardInfo("sabotage", 8, card.DIAMOND),
                test_data.CardInfo("sabotage", 9, card.HEART),
                test_data.CardInfo("sabotage", 10, card.CLUB),
                test_data.CardInfo("sabotage", 11, card.HEART),
                test_data.CardInfo("sabotage", 12, card.CLUB),
            ]
        )
    ),
    pc,
    ActionStack(),
)
players = [Player(91, 1), Player(1729, 4)]
map(lambda p: pc.add_player(p), players)
gc.start()

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

result = gc.player_act({"token": players[0].token, "action": "abort"})
assert_eq(ret_code.OK, result["code"])

result = gc.player_act({"token": players[0].token, "method": "discard", "discard": [2, 3, 8, 9]})
assert_eq(ret_code.OK, result["code"])

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

assert_eq({"code": ret_code.OK, "action": "region", "players": [players[1].player_id]}, gc.hint(players[0].token))
assert_eq(
    {"code": ret_code.OK, "action": "region", "regions": ["onhand", "armor"], "players": [players[1].player_id]},
    gc.hint(players[1].token),

Exemple #11

0

Afficher le fichier

Fichier : test_sabotage.py Projet : linluxiang/sgs

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

# sabotage | 1                    | SPADE   <- use this to duel
# sabotage | 2                    | SPADE
# sabotage | 3                    | SPADE
# sabotage | 4                    | SPADE
# sabotage | 9                    | HEART
# sabotage | 10                   | CLUB

# slash    | 5                    | SPADE   <- discard this
# dodge    | 6                    | HEART
# slash    | 7                    | CLUB
# dodge    | 8                    | DIAMOND
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'sabotage',
                           'targets': [players[1].player_id],
                           'use': [0],
                       })
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['user'])
    assert_eq(1, len(event['targets']))
    assert_eq(players[1].player_id, event['targets'][0])
    assert_eq('sabotage', event['action'])
    assert_eq(1, len(event['use']))
    assert_eq('sabotage', event['use'][0]['name'])
    assert_eq(1, event['use'][0]['rank'])
    assert_eq(card.SPADE, event['use'][0]['suit'])

Exemple #12

0

Afficher le fichier

Fichier : test_bequeathed_strategy.py Projet : neuront/sgs

# name         | rank | id | suit

# slash        | 1    | 0  | SPADE <- show & discard this
# rattan armor | 2    | 1  | CLUB <- equip this
# arson attack  | 3    | 2  | HEART <- use this
# slash        | 4    | 3  | HEART
# slash        | 9    | 8  | SPADE
# slash        | 10   | 9  | CLUB

# dodge        | 5    | 4  | HEART
# dodge        | 6    | 5  | HEART
# dodge        | 7    | 6  | HEART
# dodge        | 8    | 7  | HEART
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'card',
                           'use': [1],
                       })
assert_eq(ret_code.OK, result['code'])

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

result = gc.player_act({
                           'token': players[0].token,
                           'discard': [0],

Exemple #13

0

Afficher le fichier

Fichier : test_rattan_armor.py Projet : neuront/sgs

# 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
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'equip',
                           'use': [0],
                       })
assert_eq(ret_code.OK, result['code'])

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

result = gc.player_act({
                           'token': players[0].token,
                           'action': 'equip',
                           'use': [9],

Exemple #14

0

Afficher le fichier

Fichier : test_brink_of_death_and_rescue.py Projet : linluxiang/sgs

# name         | rank | id | suit

# rattan armor | 2    | 0  | CLUB <- equip this
# slash        | 2    | 1  | SPADE
# slash        | 3    | 2  | HEART
# peach        | 4    | 3  | HEART
# slash        | 13   | 12 | SPADE <- discard this
# slash        | 1    | 13 | CLUB  <- and this

# slash        | 5    | 4  | CLUB
# fire attack  | 6    | 5  | HEART
# fire attack  | 7    | 6  | HEART
# peach        | 8    | 7  | HEART
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'equip',
                           'use': [0],
                       })
assert_eq(ret_code.OK, result['code'])

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

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

Exemple #15

0

Afficher le fichier

Fichier : test_dragon_heart_martial_saint_slash_response.py Projet : linluxiang/sgs

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

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

result = gc.player_act({
                          'token': players[0].token,
                          'action': 'duel',
                          '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',
                          'play': [7],
                      })
assert_eq({
              'code': ret_code.BAD_REQUEST,
              'reason': ret_code.BR_WRONG_ARG % 'wrong cards',
          }, result)

Exemple #16

0

Afficher le fichier

Fichier : test_sabotage.py Projet : neuront/sgs

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

# sabotage | 1                    | SPADE   <- use this to duel
# sabotage | 2                    | SPADE
# sabotage | 3                    | SPADE
# sabotage | 4                    | SPADE
# sabotage | 9                    | HEART
# sabotage | 10                   | CLUB

# slash    | 5                    | SPADE   <- discard this
# dodge    | 6                    | HEART
# slash    | 7                    | CLUB
# dodge    | 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"])
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["user"])
    assert_eq(1, len(event["targets"]))
    assert_eq(players[1].player_id, event["targets"][0])
    assert_eq("sabotage", event["action"])
    assert_eq(1, len(event["use"]))
    assert_eq("sabotage", event["use"][0]["name"])
    assert_eq(1, event["use"][0]["rank"])
    assert_eq(card.SPADE, event["use"][0]["suit"])
    assert_eq(0, event["use"][0]["id"])
p1_events = gc.get_events(players[1].token, last_event_id)

Exemple #17

0

Afficher le fichier

# 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
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'steal',
                           'targets': [players[1].player_id],
                           'use': [12],
                       })
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['user'])
    assert_eq(1, len(event['targets']))
    assert_eq(players[1].player_id, event['targets'][0])
    assert_eq('steal', event['action'])
    assert_eq(1, len(event['use']))
    assert_eq('steal', event['use'][0]['name'])
    assert_eq(9, event['use'][0]['rank'])
    assert_eq(card.HEART, event['use'][0]['suit'])

Exemple #18

0

Afficher le fichier

Fichier : test_fury_pith.py Projet : neuront/sgs

# name     | rank | id | suit

# +jueying | 1    | 0  | SPADE
# duel     | 2    | 1  | HEART <- use this
# duel     | 3    | 2  | HEART
# duel     | 4    | 3  | HEART
# duel     | 9    | 8  | HEART
# duel     | 10   | 9  | HEART

# dodge    | 5    | 4  | DIAMOND
# slash    | 6    | 5  | HEART
# slash    | 7    | 6  | HEART
# slash    | 8    | 7  | HEART
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'duel',
                           'targets': [players[1].player_id],
                           'use': [1],
                       })
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': 'abort',
                       })
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

Exemple #19

0

Afficher le fichier

Fichier : test_peach.py Projet : neuront/sgs

            test_data.CardInfo('peach', 7, card.DIAMOND),
            test_data.CardInfo('peach', 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, 5), Player(1729, 4)]
map(lambda p: pc.add_player(p), players)
gc.start()

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': 'abort',
})
assert_eq(ret_code.OK, result['code'])

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

Exemple #20

0

Afficher le fichier

Fichier : test_bequeathed_strategy.py Projet : linluxiang/sgs

# name         | rank | id | suit

# slash        | 1    | 0  | SPADE <- show & discard this
# rattan armor | 2    | 1  | CLUB <- equip this
# fire attack  | 3    | 2  | HEART <- use this
# slash        | 4    | 3  | HEART
# slash        | 9    | 8  | SPADE
# slash        | 10   | 9  | CLUB

# dodge        | 5    | 4  | HEART
# dodge        | 6    | 5  | HEART
# dodge        | 7    | 6  | HEART
# dodge        | 8    | 7  | HEART
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'equip',
                           'use': [1],
                       })
assert_eq(ret_code.OK, result['code'])

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

result = gc.player_act({
                           'token': players[0].token,
                           'show': [0],

Exemple #21

0

Afficher le fichier

Fichier : test_zhangba_serpent_spear.py Projet : neuront/sgs

            'targets': [1],
        },
        9: { 'require': ['implicit target'] },
    },
    'abort': 'allow',
    'players': [players[0].player_id],
}, gc.hint(players[0].token))
assert_eq({
    'code': ret_code.OK,
    'action': 'use',
    'players': [players[0].player_id],
}, gc.hint(players[1].token))

result = gc.player_act({
    'token': players[0].token,
    'action': 'card',
    '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'])
    assert_eq(1, event['equip']['id'])
p1_events = gc.get_events(players[1].token, last_event_id)
assert_eq(1, len(p1_events))
if True: # just indent for a nice appearance

Exemple #22

0

Afficher le fichier

Fichier : test_player.py Projet : neuront/sgs

            'require': ['fix target'],
            'target count': 1,
            'targets': [1],
        },
    },
    'abort': 'allow',
    'players': [players[0].player_id],
}, gc.hint(players[0].token))
assert_eq({
    'code': ret_code.OK,
    'action': 'use',
    'players': [players[0].player_id],
}, gc.hint(players[1].token))

result = gc.player_act({
        'token': players[0].token,
        'action': 'abort',
    })

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

Exemple #23

0

Afficher le fichier

Fichier : test_suicide.py Projet : linluxiang/sgs

players = [Player(19, 1), Player(91, 1), Player(1729, 1)]
map(lambda p: pc.add_player(p), players)
gc.start()

# cards:
# name        | rank | id | suit

# fire attack | 1    | 0  | HEART <- use this
# slash       | 2    | 1  | SPADE <- show and discard this
# slash       | 3    | 2  | HEART
# slash       | 4    | 3  | HEART
# slash       | 13   | 12 | CLUB
# slash       | 1    | 13 | CLUB
result = gc.player_act({
    'token': players[0].token,
    'action': 'fire attack',
    'targets': [players[0].player_id],
    'use': [0],
})
assert_eq(ret_code.OK, result['code'])

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

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

Exemple #24

0

Afficher le fichier

Fichier : test_bequeathed_strategy.py Projet : linluxiang/sgs

# name         | rank | id | suit

# slash        | 1    | 0  | SPADE <- show & discard this
# rattan armor | 2    | 1  | CLUB <- equip this
# fire attack  | 3    | 2  | HEART <- use this
# slash        | 4    | 3  | HEART
# slash        | 9    | 8  | SPADE
# slash        | 10   | 9  | CLUB

# dodge        | 5    | 4  | HEART
# dodge        | 6    | 5  | HEART
# dodge        | 7    | 6  | HEART
# dodge        | 8    | 7  | HEART
result = gc.player_act({
    'token': players[0].token,
    'action': 'equip',
    'use': [1],
})
assert_eq(ret_code.OK, result['code'])

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

result = gc.player_act({
    'token': players[0].token,
    'show': [0],

Exemple #25

0

Afficher le fichier

# name         | rank | id | suit

# rattan armor | 2    | 0  | CLUB <- equip this
# slash        | 2    | 1  | SPADE
# slash        | 3    | 2  | HEART
# peach        | 4    | 3  | HEART
# slash        | 13   | 12 | SPADE <- discard this
# slash        | 1    | 13 | CLUB  <- and this

# slash        | 5    | 4  | CLUB
# fire attack  | 6    | 5  | HEART
# fire attack  | 7    | 6  | HEART
# peach        | 8    | 7  | HEART
result = gc.player_act({
    'token': players[0].token,
    'action': 'equip',
    'use': [0],
})
assert_eq(ret_code.OK, result['code'])

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

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

Exemple #26

0

Afficher le fichier

Fichier : test_slash.py Projet : neuront/sgs

        },
        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'])

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]

Exemple #27

0

Afficher le fichier

            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'])
    assert_eq(1, event['equip']['id'])
p1_events = gc.get_events(players[1].token, last_event_id)
assert_eq(1, len(p1_events))
if True:  # just indent for a nice appearance

Exemple #28

0

Afficher le fichier

Fichier : test_distance_horses.py Projet : neuront/sgs

# slash                 | 1    | 3  | CLUB
# +zhuahuangfeidian     | 5    | 12 | HEART
# zhangba serpent spear | 7    | 13 | HEART

# -zixing               | 13   | 4  | DIAMOND
# +dilu                 | 5    | 5  | CLUB
# +hualiu               | 5    | 6  | DIAMOND
# duel                  | 2    | 7  | SPADE

# sabotage              | 3    | 8  | HEART
# dodge                 | 4    | 9  | DIAMOND
# slash                 | 5    | 10 | DIAMOND
# slash                 | 6    | 11 | SPADE
result = gc.player_act({
                          'token': players[0].token,
                          'action': 'card',
                          'use': [0],
                      })
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('-chitu', event['equip']['name'])
    assert_eq(5, event['equip']['rank'])
    assert_eq(card.HEART, event['equip']['suit'])
    assert_eq(0, event['equip']['id'])
p1_events = gc.get_events(players[1].token, last_event_id)
assert_eq(1, len(p1_events))
if True: # just indent for a nice appearance

Exemple #29

0

Afficher le fichier

Fichier : test_heavenly_scent.py Projet : linluxiang/sgs

# name         | rank | id | suit

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

# rattan armor | 2    | 4  | SPADE
# fire attack  | 6    | 5  | HEART
# fire attack  | 7    | 6  | HEART
# duel         | 8    | 7  | HEART
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'equip',
                           'use': [1],
                       })
assert_eq(ret_code.OK, result['code'])

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

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

Exemple #30

0

Afficher le fichier

Fichier : test_suicide.py Projet : linluxiang/sgs

players = [Player(19, 1), Player(91, 1), Player(1729, 1)]
map(lambda p: pc.add_player(p), players)
gc.start()

# cards:
# name        | rank | id | suit

# fire attack | 1    | 0  | HEART <- use this
# slash       | 2    | 1  | SPADE <- show and discard this
# slash       | 3    | 2  | HEART
# slash       | 4    | 3  | HEART
# slash       | 13   | 12 | CLUB
# slash       | 1    | 13 | CLUB
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'fire attack',
                           'targets': [players[0].player_id],
                           'use': [0],
                       })
assert_eq(ret_code.OK, result['code'])

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

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

Exemple #31

0

Afficher le fichier

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

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

# slash       | 5                    | CLUB
# fire attack | 6                    | HEART
# dodge       | 7                    | DIAMOND
# dodge       | 8                    | DIAMOND
result = gc.player_act({
    'token': players[0].token,
    'action': 'fire attack',
    'targets': [players[1].player_id],
    '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['user'])
    assert_eq(1, len(event['targets']))
    assert_eq(players[1].player_id, event['targets'][0])
    assert_eq('fire attack', event['action'])
    assert_eq(1, len(event['use']))
    assert_eq('fire attack', event['use'][0]['name'])
    assert_eq(2, event['use'][0]['rank'])
    assert_eq(card.HEART, event['use'][0]['suit'])

Exemple #32

0

Afficher le fichier

Fichier : test_dragon_heart_martial_saint_slash_response.py Projet : neuront/sgs

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

# duel         | 1                    | SPADE   <- use this to duel
# arson attack | 2                    | HEART
# slash        | 3                    | CLUB
# 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)

Exemple #33

0

Afficher le fichier

Fichier : test_vermilion_feather_fan.py Projet : neuront/sgs

            'target count': 1,
            'targets': [1],
        },
    },
    'abort': 'allow',
    'players': [players[0].player_id],
}, gc.hint(players[0].token))
assert_eq({
    'code': ret_code.OK,
    'action': 'use',
    'players': [players[0].player_id],
}, gc.hint(players[1].token))

result = gc.player_act({
    'token': players[0].token,
    'action': 'card',
    'use': [0],
})
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('vermilion feather fan', event['equip']['name'])
    assert_eq(1, event['equip']['rank'])
    assert_eq(card.DIAMOND, event['equip']['suit'])
    assert_eq(0, event['equip']['id'])
p1_events = gc.get_events(players[1].token, last_event_id)
assert_eq(1, len(p1_events))

Exemple #34

0

Afficher le fichier

Fichier : test_fire_attack_to_player_with_equipment_only.py Projet : linluxiang/sgs

            test_data.CardInfo('fire attack', 5, card.CLUB),
            test_data.CardInfo('sabotage', 6, card.HEART),
            test_data.CardInfo('sabotage', 7, card.DIAMOND),
            test_data.CardInfo('sabotage', 8, card.DIAMOND),
            test_data.CardInfo('slash', 9, card.SPADE),
            test_data.CardInfo('slash', 10, card.SPADE),
            test_data.CardInfo('fire attack', 11, card.HEART),
            test_data.CardInfo('sabotage', 12, card.DIAMOND),
        ])), pc, ActionStack())
players = [Player(91, 3), Player(1729, 4)]
map(lambda p: pc.add_player(p), players)
gc.start()

result = gc.player_act({
    'token': players[0].token,
    'action': 'equip',
    'use': [0],
})
assert_eq(ret_code.OK, result['code'])
result = gc.player_act({
    'token': players[0].token,
    'action': 'give up',
})
assert_eq(ret_code.OK, result['code'])
result = gc.player_act({
    'token': players[0].token,
    'discard': [2, 3],
})
assert_eq(ret_code.OK, result['code'])

# player 0 show the weapon

Exemple #35

0

Afficher le fichier

Fichier : test_duel.py Projet : linluxiang/sgs

# 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
result = gc.player_act({
        'token': players[0].token,
        'action': 'duel',
        'targets': [players[1].player_id],
        'use': [0],
    })
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['user'])
    assert_eq(1, len(event['targets']))
    assert_eq(players[1].player_id, event['targets'][0])
    assert_eq('duel', event['action'])
    assert_eq(1, len(event['use']))
    assert_eq('duel', event['use'][0]['name'])
    assert_eq(1, event['use'][0]['rank'])
    assert_eq(card.SPADE, event['use'][0]['suit'])

Exemple #36

0

Afficher le fichier

Fichier : test_brink_of_death_and_rescue.py Projet : neuront/sgs

# name         | rank | id | suit

# rattan armor | 2    | 0  | CLUB <- equip this
# slash        | 2    | 1  | SPADE
# slash        | 3    | 2  | HEART
# peach        | 4    | 3  | HEART
# slash        | 13   | 12 | SPADE <- discard this
# slash        | 1    | 13 | CLUB  <- and this

# slash        | 5    | 4  | CLUB
# arson attack | 6    | 5  | HEART
# arson attack | 7    | 6  | HEART
# peach        | 8    | 7  | HEART
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'equip',
                           'use': [0],
                       })
assert_eq(ret_code.OK, result['code'])

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

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

Exemple #37

0

Afficher le fichier

Fichier : test_surprise_raid.py Projet : neuront/sgs

            'target count': 1,
            'targets': [1],
        },
    },
    'abort': 'allow',
    'players': [players[0].player_id],
}, gc.hint(players[0].token))
assert_eq({
    'code': ret_code.OK,
    'action': 'use',
    'players': [players[0].player_id],
}, gc.hint(players[1].token))

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

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

Exemple #38

0

Afficher le fichier

Fichier : test_youth_beauty.py Projet : neuront/sgs

# name         | rank | id | suit

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

# rattan armor | 2    | 4  | SPADE
# arson attack | 6    | 5  | HEART
# arson attack | 7    | 6  | HEART
# duel         | 8    | 7  | HEART
result = gc.player_act({
                           'token': players[0].token,
                           'action': 'equip',
                           'use': [1],
                       })
assert_eq(ret_code.OK, result['code'])

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

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

Exemple #39

0

Afficher le fichier

Fichier : test_steal.py Projet : linluxiang/sgs

# 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
result = gc.player_act({"token": players[0].token, "action": "steal", "targets": [players[1].player_id], "use": [12]})
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["user"])
    assert_eq(1, len(event["targets"]))
    assert_eq(players[1].player_id, event["targets"][0])
    assert_eq("steal", event["action"])
    assert_eq(1, len(event["use"]))
    assert_eq("steal", event["use"][0]["name"])
    assert_eq(9, event["use"][0]["rank"])
    assert_eq(card.HEART, event["use"][0]["suit"])
    assert_eq(12, event["use"][0]["id"])
p1_events = gc.get_events(players[1].token, last_event_id)

Exemple #40

0

Afficher le fichier

# name         | rank | id | suit

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

# rattan armor | 2    | 4  | SPADE
# fire attack  | 6    | 5  | HEART
# fire attack  | 7    | 6  | HEART
# duel         | 8    | 7  | HEART
result = gc.player_act({
    'token': players[0].token,
    'action': 'equip',
    'use': [1],
})
assert_eq(ret_code.OK, result['code'])

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

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