techwire/bang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add game save

Browse Source
This commit is contained in:
Alberto Xamin 2023-01-20 20:57:30 +00:00
parent 3f44093560
commit 2b4643b237
16 changed files with 317 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
backend/bang/cards.py
View File

@ -4,6 +4,7 @@ import bang.expansions.high_noon.card_events as ceh
from abc import ABC, abstractmethod from abc import ABC, abstractmethod
from enum import IntEnum from enum import IntEnum
import bang.roles as r import bang.roles as r
from globals import G
class Suit(IntEnum): class Suit(IntEnum):
DIAMONDS = 0 # ♦ DIAMONDS = 0 # ♦
@ -84,10 +85,10 @@ class Card(ABC):
player.equipment.append(self) player.equipment.append(self)
self.can_be_used_now = False self.can_be_used_now = False
if against: if against:
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_play_card_against|{player.name}|{self.name}|{against}') data=f'_play_card_against|{player.name}|{self.name}|{against}')
else: else:
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_play_card|{player.name}|{self.name}') data=f'_play_card|{player.name}|{self.name}')
return True return True
@ -154,7 +155,7 @@ class Prigione(Card):
return False return False
if against != None and not isinstance(player.game.get_player_named(against).role, r.Sheriff): if against != None and not isinstance(player.game.get_player_named(against).role, r.Sheriff):
self.can_be_used_now = False self.can_be_used_now = False
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_play_card_against|{player.name}|{self.name}|{against}') data=f'_play_card_against|{player.name}|{self.name}|{against}')
player.game.get_player_named(against).equipment.append(self) player.game.get_player_named(against).equipment.append(self)
player.game.get_player_named(against).notify_self() player.game.get_player_named(against).notify_self()
@ -268,7 +269,7 @@ class Birra(Card):
player.lives = min(player.lives+1, player.max_lives) player.lives = min(player.lives+1, player.max_lives)
return True return True
elif len(player.game.get_alive_players()) == 2 or player.lives == player.max_lives: elif len(player.game.get_alive_players()) == 2 or player.lives == player.max_lives:
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_spilled_beer|{player.name}|{self.name}') data=f'_spilled_beer|{player.name}|{self.name}')
return True return True
return False return False
@ -305,7 +306,7 @@ class Diligenza(Card):
# self.desc_eng = "Draw 2 cards from the deck." # self.desc_eng = "Draw 2 cards from the deck."
def play_card(self, player, against, _with=None): def play_card(self, player, against, _with=None):
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_diligenza|{player.name}|{self.name}') data=f'_diligenza|{player.name}|{self.name}')
for i in range(2): for i in range(2):
player.hand.append(player.game.deck.draw(True)) player.hand.append(player.game.deck.draw(True))
@ -382,7 +383,7 @@ class Mancato(Card):
return False return False
if player.game.check_event(ceh.Sermone): if player.game.check_event(ceh.Sermone):
return False return False
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_special_calamity|{player.name}|{self.name}|{against}') data=f'_special_calamity|{player.name}|{self.name}|{against}')
player.bang_used += 1 player.bang_used += 1
player.has_played_bang = True if not player.game.check_event(ceh.Sparatoria) else player.bang_used > 1 player.has_played_bang = True if not player.game.check_event(ceh.Sparatoria) else player.bang_used > 1
@ -421,7 +422,7 @@ class Saloon(Card):
self.alt_text = "👥🍺" self.alt_text = "👥🍺"
def play_card(self, player, against, _with=None): def play_card(self, player, against, _with=None):
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_saloon|{player.name}|{self.name}') data=f'_saloon|{player.name}|{self.name}')
for p in player.game.get_alive_players(): for p in player.game.get_alive_players():
p.lives = min(p.lives+1, p.max_lives) p.lives = min(p.lives+1, p.max_lives)
@ -438,7 +439,7 @@ class WellsFargo(Card):
self.alt_text = "🎴🎴🎴" self.alt_text = "🎴🎴🎴"
def play_card(self, player, against, _with=None): def play_card(self, player, against, _with=None):
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_wellsfargo|{player.name}|{self.name}') data=f'_wellsfargo|{player.name}|{self.name}')
for i in range(3): for i in range(3):
player.hand.append(player.game.deck.draw(True)) player.hand.append(player.game.deck.draw(True))

3
backend/bang/characters.py
View File

@ -1,6 +1,7 @@
from abc import ABC, abstractmethod from abc import ABC, abstractmethod
from bang.expansions import * from bang.expansions import *
from typing import List from typing import List
from globals import G
class Character(ABC): class Character(ABC):
def __init__(self, name: str, max_lives: int, sight_mod: int = 0, visibility_mod: int = 0, pick_mod: int = 0, desc: str = ''): def __init__(self, name: str, max_lives: int, sight_mod: int = 0, visibility_mod: int = 0, pick_mod: int = 0, desc: str = ''):
@ -25,7 +26,7 @@ class Character(ABC):
import bang.expansions.high_noon.card_events as ceh import bang.expansions.high_noon.card_events as ceh
if player.game.check_event(ceh.Sbornia): if player.game.check_event(ceh.Sbornia):
return False return False
player.sio.emit('chat_message', room=player.game.name, data=f'_use_special|{player.name}|{self.name}') G.sio.emit('chat_message', room=player.game.name, data=f'_use_special|{player.name}|{self.name}')
return True return True
class BartCassidy(Character): class BartCassidy(Character):

7
backend/bang/expansions/dodge_city/cards.py
View File

@ -1,5 +1,6 @@
from bang.cards import * from bang.cards import *
import bang.expansions.fistful_of_cards.card_events as ce import bang.expansions.fistful_of_cards.card_events as ce
from globals import G
class Binocolo(Mirino): class Binocolo(Mirino):
def __init__(self, suit, number): def __init__(self, suit, number):
@ -88,7 +89,7 @@ class Rissa(CatBalou):
player.event_type = 'rissa' player.event_type = 'rissa'
print(f'rissa targets: {player.rissa_targets}') print(f'rissa targets: {player.rissa_targets}')
super().play_card(player, against=player.rissa_targets.pop(0).name) super().play_card(player, against=player.rissa_targets.pop(0).name)
player.sio.emit('chat_message', room=player.game.name, data=f'_play_card|{player.name}|{self.name}') G.sio.emit('chat_message', room=player.game.name, data=f'_play_card|{player.name}|{self.name}')
return True return True
return False return False
@ -123,7 +124,7 @@ class Tequila(Card):
def play_card(self, player, against, _with=None): def play_card(self, player, against, _with=None):
if against != None and _with != None: if against != None and _with != None:
player.sio.emit('chat_message', room=player.game.name, data=f'_play_card_for|{player.name}|{self.name}|{against}') G.sio.emit('chat_message', room=player.game.name, data=f'_play_card_for|{player.name}|{self.name}|{against}')
player.game.deck.scrap(_with) player.game.deck.scrap(_with)
player.game.get_player_named(against).lives = min(player.game.get_player_named(against).lives+1, player.game.get_player_named(against).max_lives) player.game.get_player_named(against).lives = min(player.game.get_player_named(against).lives+1, player.game.get_player_named(against).max_lives)
player.game.get_player_named(against).notify_self() player.game.get_player_named(against).notify_self()
@ -322,7 +323,7 @@ class CanCan(CatBalou):
def play_card(self, player, against, _with=None): def play_card(self, player, against, _with=None):
if self.can_be_used_now: if self.can_be_used_now:
player.sio.emit('chat_message', room=player.game.name, data=f'_play_card_against|{player.name}|{self.name}|{against}') G.sio.emit('chat_message', room=player.game.name, data=f'_play_card_against|{player.name}|{self.name}|{against}')
return super().play_card(player, against) return super().play_card(player, against)
else: else:
if not self.is_duplicate_card(player) and not player.game.check_event(ce.IlGiudice): if not self.is_duplicate_card(player) and not player.game.check_event(ce.IlGiudice):

15
backend/bang/expansions/gold_rush/shop_cards.py
View File

@ -1,6 +1,7 @@
from bang.cards import * from bang.cards import *
import bang.roles as r import bang.roles as r
import bang.players as pl import bang.players as pl
from globals import G
class ShopCardKind(IntEnum): class ShopCardKind(IntEnum):
BROWN = 0 # Se l’equipaggiamento ha il bordo marrone, applicane subito l’effetto e poi scartalo. BROWN = 0 # Se l’equipaggiamento ha il bordo marrone, applicane subito l’effetto e poi scartalo.
@ -16,14 +17,14 @@ class ShopCard(Card):
def play_card(self, player, against, _with=None): def play_card(self, player, against, _with=None):
if self.kind == ShopCardKind.BROWN: if self.kind == ShopCardKind.BROWN:
player.sio.emit('chat_message', room=player.game.name, data=f'_purchase_card|{player.name}|{self.name}') G.sio.emit('chat_message', room=player.game.name, data=f'_purchase_card|{player.name}|{self.name}')
return True return True
elif self.kind == ShopCardKind.BLACK: # equip it elif self.kind == ShopCardKind.BLACK: # equip it
if not self.is_duplicate_card(player): if not self.is_duplicate_card(player):
self.reset_card() self.reset_card()
self.can_be_used_now = True self.can_be_used_now = True
player.gold_rush_equipment.append(self) player.gold_rush_equipment.append(self)
player.sio.emit('chat_message', room=player.game.name, data=f'_purchase_card|{player.name}|{self.name}') G.sio.emit('chat_message', room=player.game.name, data=f'_purchase_card|{player.name}|{self.name}')
return True return True
else: else:
return False return False
@ -102,7 +103,7 @@ class Rum(ShopCard):
num = 5 if player.character.check(player.game, c.LuckyDuke) else 4 num = 5 if player.character.check(player.game, c.LuckyDuke) else 4
for i in range(num): for i in range(num):
c = player.game.deck.pick_and_scrap() c = player.game.deck.pick_and_scrap()
player.sio.emit('chat_message', room=player.game.name, data=f'_flipped|{player.name}|{c.name}|{c.num_suit()}') G.sio.emit('chat_message', room=player.game.name, data=f'_flipped|{player.name}|{c.name}|{c.num_suit()}')
suits.add(c.suit) suits.add(c.suit)
player.lives = min(player.lives+len(suits), player.max_lives) player.lives = min(player.lives+len(suits), player.max_lives)
return super().play_card(player, against, _with) return super().play_card(player, against, _with)
@ -113,7 +114,7 @@ class UnionPacific(ShopCard):
self.icon = '🚆️' self.icon = '🚆️'
def play_card(self, player, against=None, _with=None): def play_card(self, player, against=None, _with=None):
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_UnionPacific|{player.name}|{self.name}') data=f'_UnionPacific|{player.name}|{self.name}')
for i in range(4): for i in range(4):
player.hand.append(player.game.deck.draw(True)) player.hand.append(player.game.deck.draw(True))
@ -162,7 +163,7 @@ class Ricercato(ShopCard):
self.can_target_self = True self.can_target_self = True
def play_card(self, player, against=None, _with=None): def play_card(self, player, against=None, _with=None):
player.sio.emit('chat_message', room=player.game.name, data=f'_purchase_card|{player.name}|{self.name}') G.sio.emit('chat_message', room=player.game.name, data=f'_purchase_card|{player.name}|{self.name}')
player.available_cards = [{ player.available_cards = [{
'name': p.name, 'name': p.name,
'icon': p.role.icon if(player.game.initial_players == 3) else '🤠', 'icon': p.role.icon if(player.game.initial_players == 3) else '🤠',
@ -187,7 +188,7 @@ class Setaccio(ShopCard):
return super().play_card(player, against, _with) return super().play_card(player, against, _with)
else: else:
if player.gold_nuggets >= 1 and player.setaccio_count < 2: if player.gold_nuggets >= 1 and player.setaccio_count < 2:
player.sio.emit('chat_message', room=player.game.name, data=f'_play_card|{player.name}|{self.name}') G.sio.emit('chat_message', room=player.game.name, data=f'_play_card|{player.name}|{self.name}')
player.gold_nuggets -= 1 player.gold_nuggets -= 1
player.setaccio_count += 1 player.setaccio_count += 1
player.hand.append(player.game.deck.draw(True)) player.hand.append(player.game.deck.draw(True))
@ -224,7 +225,7 @@ class Zaino(ShopCard):
return super().play_card(player, against, _with) return super().play_card(player, against, _with)
else: else:
if player.gold_nuggets >= 2: if player.gold_nuggets >= 2:
player.sio.emit('chat_message', room=player.game.name, data=f'_play_card|{player.name}|{self.name}') G.sio.emit('chat_message', room=player.game.name, data=f'_play_card|{player.name}|{self.name}')
player.gold_nuggets -= 2 player.gold_nuggets -= 2
player.lives = min(player.lives + 1, player.max_lives) player.lives = min(player.lives + 1, player.max_lives)
player.notify_self() player.notify_self()

5
backend/bang/expansions/the_valley_of_shadows/cards.py
View File

@ -3,6 +3,7 @@ import bang.roles as r
import bang.players as pl import bang.players as pl
from bang.cards import Card, Suit, Bang, Mancato from bang.cards import Card, Suit, Bang, Mancato
import bang.expansions.fistful_of_cards.card_events as ce import bang.expansions.fistful_of_cards.card_events as ce
from globals import G
class Fantasma(Card): class Fantasma(Card):
def __init__(self, suit, number): def __init__(self, suit, number):
@ -46,7 +47,7 @@ class SerpenteASonagli(Card):
return False return False
if against != None: if against != None:
self.can_be_used_now = False self.can_be_used_now = False
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_play_card_against|{player.name}|{self.name}|{against}') data=f'_play_card_against|{player.name}|{self.name}|{against}')
player.game.get_player_named(against).equipment.append(self) player.game.get_player_named(against).equipment.append(self)
player.game.get_player_named(against).notify_self() player.game.get_player_named(against).notify_self()
@ -69,7 +70,7 @@ class Taglia(Card):
return False return False
if against != None: if against != None:
self.can_be_used_now = False self.can_be_used_now = False
player.sio.emit('chat_message', room=player.game.name, G.sio.emit('chat_message', room=player.game.name,
data=f'_play_card_against|{player.name}|{self.name}|{against}') data=f'_play_card_against|{player.name}|{self.name}|{against}')
player.game.get_player_named(against).equipment.append(self) player.game.get_player_named(against).equipment.append(self)
player.game.get_player_named(against).notify_self() player.game.get_player_named(against).notify_self()

67
backend/bang/game.py
View File

@ -15,6 +15,8 @@ import bang.expansions.high_noon.card_events as ceh
import bang.expansions.gold_rush.shop_cards as grc import bang.expansions.gold_rush.shop_cards as grc
import bang.expansions.gold_rush.characters as grch import bang.expansions.gold_rush.characters as grch
from metrics import Metrics from metrics import Metrics
from globals import G
debug_commands = [ debug_commands = [
{'cmd':'/debug', 'help':'Toggles the debug mode'}, {'cmd':'/debug', 'help':'Toggles the debug mode'},
@ -45,9 +47,8 @@ debug_commands = [
] ]
class Game: class Game:
def __init__(self, name, sio:socketio): def __init__(self, name):
super().__init__() super().__init__()
self.sio = sio
self.name = name self.name = name
self.players: List[pl.Player] = [] self.players: List[pl.Player] = []
self.spectators: List[pl.Player] = [] self.spectators: List[pl.Player] = []
@ -134,7 +135,7 @@ class Game:
self.expansions = json.loads(cmd[4].replace("'",'"')) self.expansions = json.loads(cmd[4].replace("'",'"'))
pnames = json.loads(cmd[3].replace("'",'"')) pnames = json.loads(cmd[3].replace("'",'"'))
for p in pnames: for p in pnames:
self.add_player(pl.Player(p, p, DummySocket(self.sio), bot=False)) self.add_player(pl.Player(p, p, DummySocket(G.sio), bot=False))
continue continue
if cmd[1] == 'start_game': if cmd[1] == 'start_game':
self.start_game(int(cmd[2])) self.start_game(int(cmd[2]))
@ -181,7 +182,7 @@ class Game:
def notify_room(self, sid=None): def notify_room(self, sid=None):
if any((p.character == None for p in self.players)) or sid: if any((p.character == None for p in self.players)) or sid:
self.sio.emit('room', room=self.name if not sid else sid, data={ G.sio.emit('room', room=self.name if not sid else sid, data={
'name': self.name, 'name': self.name,
'started': self.started, 'started': self.started,
'players': [{'name':p.name, 'ready': p.character != None, 'is_bot': p.is_bot, 'avatar': p.avatar} for p in self.players], 'players': [{'name':p.name, 'ready': p.character != None, 'is_bot': p.is_bot, 'avatar': p.avatar} for p in self.players],
@ -192,12 +193,12 @@ class Game:
'available_expansions': self.available_expansions, 'available_expansions': self.available_expansions,
'is_replay': self.is_replay, 'is_replay': self.is_replay,
}) })
self.sio.emit('debug', room=self.name, data=self.debug) G.sio.emit('debug', room=self.name, data=self.debug)
if self.debug: if self.debug:
self.sio.emit('commands', room=self.name, data=[x for x in debug_commands if 'admin' not in x]) G.sio.emit('commands', room=self.name, data=[x for x in debug_commands if 'admin' not in x])
else: else:
self.sio.emit('commands', room=self.name, data=[{'cmd':'/debug', 'help':'Toggles the debug mode'}]) G.sio.emit('commands', room=self.name, data=[{'cmd':'/debug', 'help':'Toggles the debug mode'}])
self.sio.emit('spectators', room=self.name, data=len(self.spectators)) G.sio.emit('spectators', room=self.name, data=len(self.spectators))
def toggle_expansion(self, expansion_name): def toggle_expansion(self, expansion_name):
if not self.started: if not self.started:
@ -235,7 +236,7 @@ class Game:
self.players.append(player) self.players.append(player)
print(f'{self.name}: Added player {player.name} to game') print(f'{self.name}: Added player {player.name} to game')
self.notify_room() self.notify_room()
self.sio.emit('chat_message', room=self.name, data=f'_joined|{player.name}') G.sio.emit('chat_message', room=self.name, data=f'_joined|{player.name}')
def set_private(self): def set_private(self):
if not self.is_changing_pwd: if not self.is_changing_pwd:
@ -254,7 +255,7 @@ class Game:
if not any((p.character == None for p in self.players)): if not any((p.character == None for p in self.players)):
for i in range(len(self.players)): for i in range(len(self.players)):
print(self.name, self.players[i].name, self.players[i].character) print(self.name, self.players[i].name, self.players[i].character)
self.sio.emit('chat_message', room=self.name, data=f'_choose_character|{self.players[i].name}|{self.players[i].character.name}') G.sio.emit('chat_message', room=self.name, data=f'_choose_character|{self.players[i].name}|{self.players[i].character.name}')
self.players[i].prepare() self.players[i].prepare()
for k in range(self.players[i].max_lives): for k in range(self.players[i].max_lives):
self.players[i].hand.append(self.deck.draw()) self.players[i].hand.append(self.deck.draw())
@ -265,7 +266,7 @@ class Game:
for x in current_roles: for x in current_roles:
if (x not in cr): if (x not in cr):
cr += '|' +x + '|' + str(current_roles.count(x)) cr += '|' +x + '|' + str(current_roles.count(x))
self.sio.emit('chat_message', room=self.name, data=f'_allroles{cr}') G.sio.emit('chat_message', room=self.name, data=f'_allroles{cr}')
self.play_turn() self.play_turn()
def choose_characters(self): def choose_characters(self):
@ -286,8 +287,8 @@ class Game:
self.rpc_log = [f';players;{len(self.players)};{[p.name for p in self.players]};{self.expansions}', f';start_game;{SEED}'] self.rpc_log = [f';players;{len(self.players)};{[p.name for p in self.players]};{self.expansions}', f';start_game;{SEED}']
self.rng = random.Random(SEED) self.rng = random.Random(SEED)
self.players_map = {c.name: i for i, c in enumerate(self.players)} self.players_map = {c.name: i for i, c in enumerate(self.players)}
self.sio.emit('chat_message', room=self.name, data=f'_starting') G.sio.emit('chat_message', room=self.name, data=f'_starting')
self.sio.emit('start', room=self.name) G.sio.emit('start', room=self.name)
self.started = True self.started = True
self.someone_won = False self.someone_won = False
self.attack_in_progress = False self.attack_in_progress = False
@ -319,7 +320,7 @@ class Game:
self.players[i].set_role(available_roles[i]) self.players[i].set_role(available_roles[i])
if isinstance(available_roles[i], roles.Sheriff) or (len(available_roles) == 3 and isinstance(available_roles[i], roles.Vice)): if isinstance(available_roles[i], roles.Sheriff) or (len(available_roles) == 3 and isinstance(available_roles[i], roles.Vice)):
if isinstance(available_roles[i], roles.Sheriff): if isinstance(available_roles[i], roles.Sheriff):
self.sio.emit('chat_message', room=self.name, data=f'_sheriff|{self.players[i].name}') G.sio.emit('chat_message', room=self.name, data=f'_sheriff|{self.players[i].name}')
self.turn = i self.turn = i
self.players[i].notify_self() self.players[i].notify_self()
self.notify_event_card() self.notify_event_card()
@ -420,13 +421,13 @@ class Game:
self.players[self.turn].pending_action = pl.PendingAction.CHOOSE self.players[self.turn].pending_action = pl.PendingAction.CHOOSE
self.players[self.turn].choose_text = 'choose_card_to_get' self.players[self.turn].choose_text = 'choose_card_to_get'
self.players[self.turn].available_cards = self.available_cards self.players[self.turn].available_cards = self.available_cards
self.sio.emit('emporio', room=self.name, data=json.dumps( G.sio.emit('emporio', room=self.name, data=json.dumps(
{'name':self.players[self.turn].name,'cards': self.available_cards}, default=lambda o: o.__dict__)) {'name':self.players[self.turn].name,'cards': self.available_cards}, default=lambda o: o.__dict__))
self.players[self.turn].notify_self() self.players[self.turn].notify_self()
def respond_emporio(self, player, i): def respond_emporio(self, player, i):
card = self.available_cards.pop(i) card = self.available_cards.pop(i)
player.sio.emit('chat_message', room=self.name, data=f'_choose_emporio|{player.name}|{card.name}') G.sio.emit('chat_message', room=self.name, data=f'_choose_emporio|{player.name}|{card.name}')
player.hand.append(card) player.hand.append(card)
player.available_cards = [] player.available_cards = []
player.pending_action = pl.PendingAction.WAIT player.pending_action = pl.PendingAction.WAIT
@ -436,18 +437,18 @@ class Game:
if len(self.available_cards) == 1: if len(self.available_cards) == 1:
nextPlayer.hand.append(self.available_cards.pop()) nextPlayer.hand.append(self.available_cards.pop())
nextPlayer.notify_self() nextPlayer.notify_self()
self.sio.emit('emporio', room=self.name, data='{"name":"","cards":[]}') G.sio.emit('emporio', room=self.name, data='{"name":"","cards":[]}')
self.players[self.turn].pending_action = pl.PendingAction.PLAY self.players[self.turn].pending_action = pl.PendingAction.PLAY
self.players[self.turn].notify_self() self.players[self.turn].notify_self()
elif nextPlayer == self.players[self.turn]: elif nextPlayer == self.players[self.turn]:
self.sio.emit('emporio', room=self.name, data='{"name":"","cards":[]}') G.sio.emit('emporio', room=self.name, data='{"name":"","cards":[]}')
self.players[self.turn].pending_action = pl.PendingAction.PLAY self.players[self.turn].pending_action = pl.PendingAction.PLAY
self.players[self.turn].notify_self() self.players[self.turn].notify_self()
else: else:
nextPlayer.pending_action = pl.PendingAction.CHOOSE nextPlayer.pending_action = pl.PendingAction.CHOOSE
nextPlayer.choose_text = 'choose_card_to_get' nextPlayer.choose_text = 'choose_card_to_get'
nextPlayer.available_cards = self.available_cards nextPlayer.available_cards = self.available_cards
self.sio.emit('emporio', room=self.name, data=json.dumps( G.sio.emit('emporio', room=self.name, data=json.dumps(
{'name':nextPlayer.name,'cards': self.available_cards}, default=lambda o: o.__dict__)) {'name':nextPlayer.name,'cards': self.available_cards}, default=lambda o: o.__dict__))
nextPlayer.notify_self() nextPlayer.notify_self()
@ -533,15 +534,15 @@ class Game:
if p.win_status and not (isinstance(p.role, roles.Renegade) and p.is_dead): if p.win_status and not (isinstance(p.role, roles.Renegade) and p.is_dead):
if not self.someone_won: if not self.someone_won:
self.someone_won = True self.someone_won = True
self.sio.emit('chat_message', room=self.name, data=f'_won|{p.name}|{p.role.name}') G.sio.emit('chat_message', room=self.name, data=f'_won|{p.name}|{p.role.name}')
if not self.is_replay: if not self.is_replay:
Metrics.send_metric('player_win', points=[1], tags=[f"char:{p.character.name}", f"role:{p.role.name}"]) Metrics.send_metric('player_win', points=[1], tags=[f"char:{p.character.name}", f"role:{p.role.name}"])
p.notify_self() p.notify_self()
if hasattr(self.sio, 'is_fake'): if hasattr(G.sio, 'is_fake'):
print('announces_winners(): Running for tests, you will have to call reset manually!') print('announces_winners(): Running for tests, you will have to call reset manually!')
return return
for i in range(5): for i in range(5):
self.sio.emit('chat_message', room=self.name, data=f'_lobby_reset|{5-i}') G.sio.emit('chat_message', room=self.name, data=f'_lobby_reset|{5-i}')
eventlet.sleep(1) eventlet.sleep(1)
return self.reset() return self.reset()
@ -575,7 +576,7 @@ class Game:
self.deck.flip_event() self.deck.flip_event()
if len(self.deck.event_cards) > 0 and self.deck.event_cards[0] != None: if len(self.deck.event_cards) > 0 and self.deck.event_cards[0] != None:
print(f'{self.name}: flip new event {self.deck.event_cards[0].name}') print(f'{self.name}: flip new event {self.deck.event_cards[0].name}')
self.sio.emit('chat_message', room=self.name, data={'color': f'orange','text':f'_flip_event|{self.deck.event_cards[0].name}'}) G.sio.emit('chat_message', room=self.name, data={'color': f'orange','text':f'_flip_event|{self.deck.event_cards[0].name}'})
if self.check_event(ce.DeadMan): if self.check_event(ce.DeadMan):
self.did_resuscitate_deadman = False self.did_resuscitate_deadman = False
elif self.check_event(ce.RouletteRussa): elif self.check_event(ce.RouletteRussa):
@ -592,7 +593,7 @@ class Game:
for p in hurt_players: for p in hurt_players:
if p.lives != p.max_lives: if p.lives != p.max_lives:
p.lives += 1 p.lives += 1
self.sio.emit('chat_message', room=self.name, data=f'_doctor_heal|{p.name}') G.sio.emit('chat_message', room=self.name, data=f'_doctor_heal|{p.name}')
p.notify_self() p.notify_self()
elif self.check_event(ceh.IDalton): elif self.check_event(ceh.IDalton):
self.waiting_for = 0 self.waiting_for = 0
@ -633,29 +634,29 @@ class Game:
if len(self.deck.event_cards) > 0: if len(self.deck.event_cards) > 0:
room = self.name if sid == None else sid room = self.name if sid == None else sid
if self.deck.event_cards[0] != None: if self.deck.event_cards[0] != None:
self.sio.emit('event_card', room=room, data=self.deck.event_cards[0].__dict__) G.sio.emit('event_card', room=room, data=self.deck.event_cards[0].__dict__)
else: else:
self.sio.emit('event_card', room=room, data=None) G.sio.emit('event_card', room=room, data=None)
def notify_gold_rush_shop(self, sid=None): def notify_gold_rush_shop(self, sid=None):
if 'gold_rush' in self.expansions and self.deck and self.deck.shop_cards and len(self.deck.shop_cards) > 0: if 'gold_rush' in self.expansions and self.deck and self.deck.shop_cards and len(self.deck.shop_cards) > 0:
room = self.name if sid == None else sid room = self.name if sid == None else sid
print(f'{self.name}: gold_rush_shop room={room}, data={self.deck.shop_cards}') print(f'{self.name}: gold_rush_shop room={room}, data={self.deck.shop_cards}')
self.sio.emit('gold_rush_shop', room=room, data=json.dumps(self.deck.shop_cards, default=lambda o: o.__dict__)) G.sio.emit('gold_rush_shop', room=room, data=json.dumps(self.deck.shop_cards, default=lambda o: o.__dict__))
def notify_scrap_pile(self, sid=None): def notify_scrap_pile(self, sid=None):
print(f'{self.name}: scrap') print(f'{self.name}: scrap')
room = self.name if sid == None else sid room = self.name if sid == None else sid
if self.deck.peek_scrap_pile(): if self.deck.peek_scrap_pile():
self.sio.emit('scrap', room=room, data=self.deck.peek_scrap_pile().__dict__) G.sio.emit('scrap', room=room, data=self.deck.peek_scrap_pile().__dict__)
else: else:
self.sio.emit('scrap', room=room, data=None) G.sio.emit('scrap', room=room, data=None)
def handle_disconnect(self, player: pl.Player): def handle_disconnect(self, player: pl.Player):
print(f'{self.name}: player {player.name} left the game') print(f'{self.name}: player {player.name} left the game')
if player in self.spectators: if player in self.spectators:
self.spectators.remove(player) self.spectators.remove(player)
self.sio.emit('spectators', room=self.name, data=len(self.spectators)) G.sio.emit('spectators', room=self.name, data=len(self.spectators))
return False return False
if player.is_bot and not self.started: if player.is_bot and not self.started:
player.game = None player.game = None
@ -735,9 +736,9 @@ class Game:
# if not disconnected: # if not disconnected:
# self.dead_players.append(corpse) # self.dead_players.append(corpse)
self.notify_room() self.notify_room()
self.sio.emit('chat_message', room=self.name, data=f'_died|{player.name}') G.sio.emit('chat_message', room=self.name, data=f'_died|{player.name}')
if self.started: if self.started:
self.sio.emit('chat_message', room=self.name, data=f'_died_role|{player.name}|{player.role.name}') G.sio.emit('chat_message', room=self.name, data=f'_died_role|{player.name}|{player.role.name}')
for p in self.players: for p in self.players:
if not p.is_bot: if not p.is_bot:
p.notify_self() p.notify_self()
@ -854,4 +855,4 @@ class Game:
'is_ghost': p.is_ghost, 'is_ghost': p.is_ghost,
'is_bot': p.is_bot, 'is_bot': p.is_bot,
} for p in self.get_alive_players()] } for p in self.get_alive_players()]
self.sio.emit('players_update', room=self.name, data=data) G.sio.emit('players_update', room=self.name, data=data)

109
backend/bang/players.py
View File

@ -16,6 +16,7 @@ import bang.expansions.the_valley_of_shadows.cards as tvosc
import eventlet import eventlet
from typing import List from typing import List
from metrics import Metrics from metrics import Metrics
from globals import G
robot_pictures = [ robot_pictures = [
'https://i.imgur.com/40rAFIb.jpg', 'https://i.imgur.com/40rAFIb.jpg',
@ -63,25 +64,24 @@ class Player:
else: else:
self.avatar = f'https://cdn.discordapp.com/avatars/{res["id"]}/{res["avatar"]}.png' self.avatar = f'https://cdn.discordapp.com/avatars/{res["id"]}/{res["avatar"]}.png'
if self.game: if self.game:
self.sio.emit('chat_message', room=self.game.name, data=f'_change_username|{self.name}|{res["username"]}') G.sio.emit('chat_message', room=self.game.name, data=f'_change_username|{self.name}|{res["username"]}')
self.name = res['username'] self.name = res['username']
self.discord_id = res['id'] self.discord_id = res['id']
if self.is_admin(): if self.is_admin():
if self.game: self.game.feature_flags() if self.game: self.game.feature_flags()
self.sio.emit('chat_message', room=self.sid, data={'color':'green', 'text':'(you are admin)'}) G.sio.emit('chat_message', room=self.sid, data={'color':'green', 'text':'(you are admin)'})
if self.game: if self.game:
self.game.notify_room() self.game.notify_room()
self.sio.emit('me', data=self.name, room=self.sid) G.sio.emit('me', data=self.name, room=self.sid)
else: else:
print('error getting avatar', r.status_code, r.text) print('error getting avatar', r.status_code, r.text)
print(r) print(r)
def __init__(self, name, sid, sio, bot=False, discord_token=None): def __init__(self, name, sid, bot=False, discord_token=None):
import bang.game as g import bang.game as g
super().__init__() super().__init__()
self.name = name self.name = name
self.sid = sid self.sid = sid
self.sio = sio
self.is_bot = bot self.is_bot = bot
self.discord_token = discord_token self.discord_token = discord_token
self.discord_id = None self.discord_id = None
@ -89,7 +89,7 @@ class Player:
if self.is_bot: if self.is_bot:
self.avatar = robot_pictures[randrange(len(robot_pictures))] self.avatar = robot_pictures[randrange(len(robot_pictures))]
if self.discord_token: if self.discord_token:
sio.start_background_task(self.get_avatar) G.sio.start_background_task(self.get_avatar)
self.game: g = None self.game: g = None
self.reset() self.reset()
@ -155,7 +155,7 @@ class Player:
def set_role(self, role: r.Role): def set_role(self, role: r.Role):
self.role = role self.role = role
print(f'{self.name}: I am a {role.name}, my goal is "{role.goal}"') print(f'{self.name}: I am a {role.name}, my goal is "{role.goal}"')
self.sio.emit('role', room=self.sid, data=json.dumps( G.sio.emit('role', room=self.sid, data=json.dumps(
role, default=lambda o: o.__dict__)) role, default=lambda o: o.__dict__))
def set_character(self, character: str): def set_character(self, character: str):
@ -174,14 +174,14 @@ class Player:
self.real_character = self.character self.real_character = self.character
self.available_characters = [] self.available_characters = []
print(f'{self.name}: I chose character {self.character.name}') print(f'{self.name}: I chose character {self.character.name}')
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_did_choose_character|{self.name}') data=f'_did_choose_character|{self.name}')
self.game.notify_character_selection() self.game.notify_character_selection()
elif self.real_character and isinstance(self.real_character, chd.VeraCuster): elif self.real_character and isinstance(self.real_character, chd.VeraCuster):
self.character = next( self.character = next(
x for x in self.available_characters if x.name == character) x for x in self.available_characters if x.name == character)
self.available_characters = [] self.available_characters = []
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_did_choose_character|{self.name}') data=f'_did_choose_character|{self.name}')
self.pending_action = PendingAction.DRAW self.pending_action = PendingAction.DRAW
self.notify_self() self.notify_self()
@ -199,7 +199,7 @@ class Player:
self.available_characters = available self.available_characters = available
print(f'{self.name}: I have to choose between {available}') print(f'{self.name}: I have to choose between {available}')
if not self.is_bot: if not self.is_bot:
self.sio.emit('characters', room=self.sid, data=json.dumps( G.sio.emit('characters', room=self.sid, data=json.dumps(
available, default=lambda o: o.__dict__)) available, default=lambda o: o.__dict__))
else: else:
char_name = available[randrange(0, len(available))].name char_name = available[randrange(0, len(available))].name
@ -217,7 +217,7 @@ class Player:
'message':message 'message':message
} }
print('notifying card') print('notifying card')
self.sio.emit('notify_card', room=self.sid, data=mess) G.sio.emit('notify_card', room=self.sid, data=mess)
def notify_self(self): def notify_self(self):
if any((True for c in self.equipment if isinstance(c, tvosc.Fantasma))): if any((True for c in self.equipment if isinstance(c, tvosc.Fantasma))):
@ -272,7 +272,6 @@ class Player:
ser = self.__dict__.copy() ser = self.__dict__.copy()
ser.pop('game') ser.pop('game')
ser.pop('sio')
ser.pop('sid') ser.pop('sid')
ser.pop('on_pick_cb') ser.pop('on_pick_cb')
ser.pop('discord_token') ser.pop('discord_token')
@ -292,16 +291,16 @@ class Player:
self.pending_action = PendingAction.WAIT self.pending_action = PendingAction.WAIT
ser['hand'] = [] ser['hand'] = []
ser['equipment'] = [] ser['equipment'] = []
self.sio.emit('self', room=self.sid, data=json.dumps(ser, default=lambda o: o.__dict__)) G.sio.emit('self', room=self.sid, data=json.dumps(ser, default=lambda o: o.__dict__))
self.game.player_death(self) self.game.player_death(self)
if self.game and self.game.started: # falso quando un bot viene eliminato dalla partita if self.game and self.game.started: # falso quando un bot viene eliminato dalla partita
self.sio.emit('self_vis', room=self.sid, data=json.dumps(self.game.get_visible_players(self), default=lambda o: o.__dict__)) G.sio.emit('self_vis', room=self.sid, data=json.dumps(self.game.get_visible_players(self), default=lambda o: o.__dict__))
self.game.notify_all() self.game.notify_all()
self.sio.emit('self', room=self.sid, data=json.dumps(ser, default=lambda o: o.__dict__)) G.sio.emit('self', room=self.sid, data=json.dumps(ser, default=lambda o: o.__dict__))
def bot_spin(self): def bot_spin(self):
while self.is_bot and self.game != None and not self.game.shutting_down: while self.is_bot and self.game != None and not self.game.shutting_down:
eventlet.sleep(max(0.2, uniform(self.game.bot_speed/2-0.1, self.game.bot_speed))) G.sio.sleep(max(0.2, uniform(self.game.bot_speed/2-0.1, self.game.bot_speed)))
if self.lives > 0 or self.is_ghost: if self.lives > 0 or self.is_ghost:
self.bot_logic() self.bot_logic()
@ -441,7 +440,7 @@ class Player:
self.is_playing_ranch = False self.is_playing_ranch = False
self.can_play_vendetta = can_play_vendetta self.can_play_vendetta = can_play_vendetta
if not again: if not again:
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_turn|{self.name}') data=f'_turn|{self.name}')
print(f'{self.name}: I was notified that it is my turn') print(f'{self.name}: I was notified that it is my turn')
self.was_shot = False self.was_shot = False
@ -461,7 +460,7 @@ class Player:
self.hand.append(self.game.deck.draw(True)) self.hand.append(self.game.deck.draw(True))
if self.character.check(self.game, chars.BartCassidy) and self.lives > 0: if self.character.check(self.game, chars.BartCassidy) and self.lives > 0:
self.hand.append(self.game.deck.draw(True)) self.hand.append(self.game.deck.draw(True))
self.sio.emit('chat_message', room=self.game.name, data=f'_special_bart_cassidy|{self.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_special_bart_cassidy|{self.name}')
self.heal_if_needed() self.heal_if_needed()
if self.lives <= 0: if self.lives <= 0:
return self.notify_self() return self.notify_self()
@ -557,11 +556,11 @@ class Player:
for i in range(num): for i in range(num):
if i == 0 and pile == 'scrap' and self.character.check(self.game, chars.PedroRamirez): if i == 0 and pile == 'scrap' and self.character.check(self.game, chars.PedroRamirez):
self.hand.append(self.game.deck.draw_from_scrap_pile()) self.hand.append(self.game.deck.draw_from_scrap_pile())
self.sio.emit('chat_message', room=self.game.name, data=f'_draw_from_scrap|{self.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_draw_from_scrap|{self.name}')
elif i == 0 and type(pile) == str and pile != self.name and pile in self.game.players_map and self.character.check(self.game, chars.JesseJones) and len(self.game.get_player_named(pile).hand) > 0: elif i == 0 and type(pile) == str and pile != self.name and pile in self.game.players_map and self.character.check(self.game, chars.JesseJones) and len(self.game.get_player_named(pile).hand) > 0:
self.hand.append(self.game.get_player_named(pile).hand.pop( randrange(0, len(self.game.get_player_named(pile).hand)))) self.hand.append(self.game.get_player_named(pile).hand.pop( randrange(0, len(self.game.get_player_named(pile).hand))))
self.game.get_player_named(pile).notify_self() self.game.get_player_named(pile).notify_self()
self.sio.emit('chat_message', room=self.game.name, data=f'_draw_from_player|{self.name}|{pile}') G.sio.emit('chat_message', room=self.game.name, data=f'_draw_from_player|{self.name}|{pile}')
elif i == 1: elif i == 1:
card: cs.Card = self.game.deck.draw() card: cs.Card = self.game.deck.draw()
if (self.character.check(self.game, chars.BlackJack) or self.game.check_event(ce.LeggeDelWest)): if (self.character.check(self.game, chars.BlackJack) or self.game.check_event(ce.LeggeDelWest)):
@ -602,7 +601,7 @@ class Player:
pickable_cards -= 1 pickable_cards -= 1
picked: cs.Card = self.game.deck.pick_and_scrap() picked: cs.Card = self.game.deck.pick_and_scrap()
print(f'Did pick {picked}') print(f'Did pick {picked}')
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}') data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}')
if picked.check_suit(self.game, [cs.Suit.SPADES]) and 2 <= picked.number <= 9 and pickable_cards == 0: if picked.check_suit(self.game, [cs.Suit.SPADES]) and 2 <= picked.number <= 9 and pickable_cards == 0:
self.lives -= 3 self.lives -= 3
@ -616,12 +615,12 @@ class Player:
self.hand.append(self.game.deck.draw()) self.hand.append(self.game.deck.draw())
self.attacker = None self.attacker = None
self.game.deck.scrap(self.equipment.pop(i), True) self.game.deck.scrap(self.equipment.pop(i), True)
self.sio.emit('chat_message', room=self.game.name, data=f'_explode|{self.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_explode|{self.name}')
self.heal_if_needed() self.heal_if_needed()
if self.character.check(self.game, chars.BartCassidy) and self.lives > 0: if self.character.check(self.game, chars.BartCassidy) and self.lives > 0:
for i in range(3): for i in range(3):
self.hand.append(self.game.deck.draw(True)) self.hand.append(self.game.deck.draw(True))
self.sio.emit('chat_message', room=self.game.name, data=f'_special_bart_cassidy|{self.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_special_bart_cassidy|{self.name}')
print(f'{self.name} Boom, -3 hp') print(f'{self.name} Boom, -3 hp')
break break
else: else:
@ -637,16 +636,16 @@ class Player:
pickable_cards -= 1 pickable_cards -= 1
picked: cs.Card = self.game.deck.pick_and_scrap() picked: cs.Card = self.game.deck.pick_and_scrap()
print(f'Did pick {picked}') print(f'Did pick {picked}')
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}') data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}')
if not picked.check_suit(self.game, [cs.Suit.HEARTS]) and pickable_cards == 0: if not picked.check_suit(self.game, [cs.Suit.HEARTS]) and pickable_cards == 0:
self.game.deck.scrap(self.equipment.pop(i), True) self.game.deck.scrap(self.equipment.pop(i), True)
self.sio.emit('chat_message', room=self.game.name, data=f'_prison_turn|{self.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_prison_turn|{self.name}')
self.end_turn(forced=True) self.end_turn(forced=True)
return return
elif pickable_cards == 0: elif pickable_cards == 0:
self.game.deck.scrap(self.equipment.pop(i), True) self.game.deck.scrap(self.equipment.pop(i), True)
self.sio.emit('chat_message', room=self.game.name, data=f'_prison_free|{self.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_prison_free|{self.name}')
break break
break break
for i in range(len(self.equipment)): for i in range(len(self.equipment)):
@ -655,13 +654,13 @@ class Player:
pickable_cards -= 1 pickable_cards -= 1
picked: cs.Card = self.game.deck.pick_and_scrap() picked: cs.Card = self.game.deck.pick_and_scrap()
print(f'Did pick {picked}') print(f'Did pick {picked}')
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}') data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}')
if not picked.check_suit(self.game, [cs.Suit.SPADES]): if not picked.check_suit(self.game, [cs.Suit.SPADES]):
break break
elif pickable_cards == 0: elif pickable_cards == 0:
self.lives -= 1 self.lives -= 1
self.sio.emit('chat_message', room=self.game.name, data=f'_snake_bit|{self.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_snake_bit|{self.name}')
break break
if any((isinstance(c, cs.Prigione) for c in self.equipment)): if any((isinstance(c, cs.Prigione) for c in self.equipment)):
self.notify_self() #TODO perchè solo le prigioni? e multiple dinamiti come si comportano con veracuster? self.notify_self() #TODO perchè solo le prigioni? e multiple dinamiti come si comportano con veracuster?
@ -725,7 +724,7 @@ class Player:
self.hand.insert(hand_index, card) self.hand.insert(hand_index, card)
if withCard: if withCard:
self.hand.insert(_with, withCard) self.hand.insert(_with, withCard)
self.sio.emit('cant_play_card', room=self.sid) G.sio.emit('cant_play_card', room=self.sid)
elif (card.usable_next_turn and card.can_be_used_now) or (isinstance(card, grc.ShopCard) and card.kind == grc.ShopCardKind.BLACK): elif (card.usable_next_turn and card.can_be_used_now) or (isinstance(card, grc.ShopCard) and card.kind == grc.ShopCardKind.BLACK):
if did_play_card: if did_play_card:
self.game.deck.scrap(card, True) self.game.deck.scrap(card, True)
@ -773,7 +772,7 @@ class Player:
self.notify_self() self.notify_self()
elif self.choose_text == 'choose_ricercato': elif self.choose_text == 'choose_ricercato':
player = self.game.get_player_named(self.available_cards[card_index]['name']) player = self.game.get_player_named(self.available_cards[card_index]['name'])
player.sio.emit('chat_message', room=player.game.name, data=f'_play_card_against|{self.name}|Ricercato|{player.name}') G.sio.emit('chat_message', room=player.game.name, data=f'_play_card_against|{self.name}|Ricercato|{player.name}')
if any((isinstance(c, grc.Ricercato) for c in player.gold_rush_equipment)): if any((isinstance(c, grc.Ricercato) for c in player.gold_rush_equipment)):
self.game.deck.shop_deck.append(grc.Ricercato()) self.game.deck.shop_deck.append(grc.Ricercato())
else: else:
@ -793,20 +792,20 @@ class Player:
self.notify_self() self.notify_self()
elif self.choose_text == 'choose_bicchierino': elif self.choose_text == 'choose_bicchierino':
player = self.game.get_player_named(self.available_cards[card_index]['name']) player = self.game.get_player_named(self.available_cards[card_index]['name'])
self.sio.emit('chat_message', room=self.game.name, data=f'_play_card_for|{self.name}|{"Bicchierino"}|{player.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_play_card_for|{self.name}|{"Bicchierino"}|{player.name}')
player.lives = min(player.lives+1, player.max_lives) player.lives = min(player.lives+1, player.max_lives)
self.pending_action = PendingAction.PLAY self.pending_action = PendingAction.PLAY
self.notify_self() self.notify_self()
elif self.choose_text == 'choose_birra_function': elif self.choose_text == 'choose_birra_function':
if card_index == 0: if card_index == 0:
self.gold_nuggets += 1 self.gold_nuggets += 1
self.sio.emit('chat_message', room=self.game.name, data=f'_get_nugget|{self.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_get_nugget|{self.name}')
else: else:
cs.Birra(1,1).play_card(self, skipChecks=True) cs.Birra(1,1).play_card(self, skipChecks=True)
self.pending_action = PendingAction.PLAY self.pending_action = PendingAction.PLAY
self.notify_self() self.notify_self()
elif self.choose_text == 'choose_bottiglia': elif self.choose_text == 'choose_bottiglia':
self.sio.emit('chat_message', room=self.game.name, data=f'_play_card|{self.name}|{"Bottiglia"}') G.sio.emit('chat_message', room=self.game.name, data=f'_play_card|{self.name}|{"Bottiglia"}')
if isinstance(self.available_cards[card_index], cs.Birra): if isinstance(self.available_cards[card_index], cs.Birra):
self.lives = min(self.lives+1, self.max_lives) self.lives = min(self.lives+1, self.max_lives)
else: else:
@ -814,7 +813,7 @@ class Player:
self.pending_action = PendingAction.PLAY self.pending_action = PendingAction.PLAY
self.notify_self() self.notify_self()
elif self.choose_text == 'choose_complice': elif self.choose_text == 'choose_complice':
self.sio.emit('chat_message', room=self.game.name, data=f'_play_card|{self.name}|{"Bottiglia"}') G.sio.emit('chat_message', room=self.game.name, data=f'_play_card|{self.name}|{"Bottiglia"}')
self.hand.append(self.available_cards[card_index]) self.hand.append(self.available_cards[card_index])
self.pending_action = PendingAction.PLAY self.pending_action = PendingAction.PLAY
self.notify_self() self.notify_self()
@ -835,7 +834,7 @@ class Player:
player = self.game.get_player_named(self.choose_text.split('|')[1]) player = self.game.get_player_named(self.choose_text.split('|')[1])
player.gold_rush_equipment.remove(self.available_cards[card_index]) player.gold_rush_equipment.remove(self.available_cards[card_index])
self.game.deck.shop_deck.append(self.available_cards[card_index]) self.game.deck.shop_deck.append(self.available_cards[card_index])
self.sio.emit('chat_message', room=self.game.name, data=f'_gold_rush_pay_discard|{self.name}|{player.name}|{self.available_cards[card_index].name}') G.sio.emit('chat_message', room=self.game.name, data=f'_gold_rush_pay_discard|{self.name}|{player.name}|{self.available_cards[card_index].name}')
player.notify_self() player.notify_self()
self.pending_action = PendingAction.PLAY self.pending_action = PendingAction.PLAY
self.notify_self() self.notify_self()
@ -845,7 +844,7 @@ class Player:
player.equipment.append(self.game.deck.scrap_pile.pop(-1)) player.equipment.append(self.game.deck.scrap_pile.pop(-1))
player.notify_self() player.notify_self()
self.game.notify_all() self.game.notify_all()
self.sio.emit('chat_message', room=player.game.name, data=f'_play_card_against|{self.name}|Fantasma|{player.name}') G.sio.emit('chat_message', room=player.game.name, data=f'_play_card_against|{self.name}|Fantasma|{player.name}')
self.pending_action = PendingAction.PLAY self.pending_action = PendingAction.PLAY
self.notify_self() self.notify_self()
elif 'choose_sventagliata' in self.choose_text: elif 'choose_sventagliata' in self.choose_text:
@ -854,8 +853,8 @@ class Player:
player = self.game.get_player_named(self.available_cards[card_index]['name']) player = self.game.get_player_named(self.available_cards[card_index]['name'])
player.game.attack(self, og, card_name='Sventagliata') player.game.attack(self, og, card_name='Sventagliata')
player.game.attack(self, player.name, card_name='Sventagliata') player.game.attack(self, player.name, card_name='Sventagliata')
self.sio.emit('chat_message', room=player.game.name, data=f'_play_card_against|{self.name}|Sventagliata|{og}') G.sio.emit('chat_message', room=player.game.name, data=f'_play_card_against|{self.name}|Sventagliata|{og}')
self.sio.emit('chat_message', room=player.game.name, data=f'_play_card_against|{self.name}|Sventagliata|{player.name}') G.sio.emit('chat_message', room=player.game.name, data=f'_play_card_against|{self.name}|Sventagliata|{player.name}')
self.pending_action = PendingAction.PLAY self.pending_action = PendingAction.PLAY
self.notify_self() self.notify_self()
elif 'choose_tornado' in self.choose_text: elif 'choose_tornado' in self.choose_text:
@ -899,11 +898,11 @@ class Player:
self.real_character = self.character self.real_character = self.character
self.max_lives = self.character.max_lives + self.role.health_mod self.max_lives = self.character.max_lives + self.role.health_mod
self.lives = 2 self.lives = 2
self.sio.emit('chat_message', room=self.game.name, data=f'_choose_character|{self.name}|{self.character.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_choose_character|{self.name}|{self.character.name}')
self.play_turn(again = True) self.play_turn(again = True)
elif self.game.check_event(ceh.Manette) and self.choose_text == 'choose_manette': elif self.game.check_event(ceh.Manette) and self.choose_text == 'choose_manette':
self.committed_suit_manette = cs.Suit(card_index) self.committed_suit_manette = cs.Suit(card_index)
self.sio.emit('chat_message', room=self.game.name, data=f'_choose_manette|{self.name}|{"♦♣♥♠"[card_index]}') G.sio.emit('chat_message', room=self.game.name, data=f'_choose_manette|{self.name}|{"♦♣♥♠"[card_index]}')
self.pending_action = PendingAction.PLAY self.pending_action = PendingAction.PLAY
self.notify_self() self.notify_self()
elif self.is_giving_life and self.game.check_event(ce.FratelliDiSangue): elif self.is_giving_life and self.game.check_event(ce.FratelliDiSangue):
@ -918,7 +917,7 @@ class Player:
if any((isinstance(c, grc.Stivali) for c in self.gold_rush_equipment)): if any((isinstance(c, grc.Stivali) for c in self.gold_rush_equipment)):
self.hand.append(self.game.deck.draw()) self.hand.append(self.game.deck.draw())
player.notify_self() player.notify_self()
self.sio.emit('chat_message', room=self.game.name, data=f'_fratelli_sangue|{self.name}|{player.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_fratelli_sangue|{self.name}|{player.name}')
except: pass except: pass
self.play_turn(again = True) self.play_turn(again = True)
elif self.is_using_checchino and self.game.check_event(ce.Cecchino): elif self.is_using_checchino and self.game.check_event(ce.Cecchino):
@ -975,15 +974,15 @@ class Player:
elif self.is_drawing and self.game.check_event(ce.Peyote): elif self.is_drawing and self.game.check_event(ce.Peyote):
self.is_drawing = False self.is_drawing = False
card = self.game.deck.draw() card = self.game.deck.draw()
self.sio.emit('chat_message', room=self.game.name, data=f"_guess|{self.name}|{self.available_cards[card_index]['icon']}") G.sio.emit('chat_message', room=self.game.name, data=f"_guess|{self.name}|{self.available_cards[card_index]['icon']}")
self.available_cards = [] self.available_cards = []
if card_index == card.suit%2: if card_index == card.suit%2:
self.hand.append(card) self.hand.append(card)
self.sio.emit('chat_message', room=self.game.name, data=f"_guess_right|{self.name}") G.sio.emit('chat_message', room=self.game.name, data=f"_guess_right|{self.name}")
self.pending_action = PendingAction.DRAW self.pending_action = PendingAction.DRAW
else: else:
self.game.deck.scrap(card) self.game.deck.scrap(card)
self.sio.emit('chat_message', room=self.game.name, data=f"_guess_wrong|{self.name}") G.sio.emit('chat_message', room=self.game.name, data=f"_guess_wrong|{self.name}")
self.pending_action = PendingAction.PLAY self.pending_action = PendingAction.PLAY
self.notify_self() self.notify_self()
# specifico per personaggio # specifico per personaggio
@ -1051,7 +1050,7 @@ class Player:
pickable_cards -= 1 pickable_cards -= 1
picked: cs.Card = self.game.deck.pick_and_scrap() picked: cs.Card = self.game.deck.pick_and_scrap()
print(f'Did pick {picked}') print(f'Did pick {picked}')
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}') data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}')
if picked.check_suit(self.game, [cs.Suit.HEARTS]): if picked.check_suit(self.game, [cs.Suit.HEARTS]):
self.mancato_needed -= 1 self.mancato_needed -= 1
@ -1081,7 +1080,7 @@ class Player:
pickable_cards -= 1 pickable_cards -= 1
picked: cs.Card = self.game.deck.pick_and_scrap() picked: cs.Card = self.game.deck.pick_and_scrap()
print(f'Did pick {picked}') print(f'Did pick {picked}')
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}') data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}')
if picked.check_suit(self.game, [cs.Suit.HEARTS]): if picked.check_suit(self.game, [cs.Suit.HEARTS]):
self.mancato_needed -= 1 self.mancato_needed -= 1
@ -1213,34 +1212,34 @@ class Player:
self.lives += 1 if not self.character.check(self.game, chd.TequilaJoe) else 2 self.lives += 1 if not self.character.check(self.game, chd.TequilaJoe) else 2
self.lives = min(self.lives, self.max_lives) self.lives = min(self.lives, self.max_lives)
self.game.deck.scrap(self.hand.pop(i), True) self.game.deck.scrap(self.hand.pop(i), True)
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_beer_save|{self.name}') data=f'_beer_save|{self.name}')
break break
def take_damage_response(self): def take_damage_response(self):
self.lives -= 1 self.lives -= 1
self.sio.emit('hurt', room=self.sid, data=f'') G.sio.emit('hurt', room=self.sid, data=f'')
if self.lives > 0: if self.lives > 0:
if self.character.check(self.game, chars.BartCassidy): if self.character.check(self.game, chars.BartCassidy):
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_special_bart_cassidy|{self.name}') data=f'_special_bart_cassidy|{self.name}')
self.hand.append(self.game.deck.draw(True)) self.hand.append(self.game.deck.draw(True))
elif self.character.check(self.game, chars.ElGringo) and self.attacker and self.attacker in self.game.get_alive_players() and len(self.attacker.hand) > 0: elif self.character.check(self.game, chars.ElGringo) and self.attacker and self.attacker in self.game.get_alive_players() and len(self.attacker.hand) > 0:
self.hand.append(self.attacker.hand.pop(randrange(0, len(self.attacker.hand)))) self.hand.append(self.attacker.hand.pop(randrange(0, len(self.attacker.hand))))
self.hand[-1].reset_card() self.hand[-1].reset_card()
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_special_el_gringo|{self.name}|{self.attacker.name}') data=f'_special_el_gringo|{self.name}|{self.attacker.name}')
self.attacker.notify_self() self.attacker.notify_self()
if isinstance(self.attacker, Player) and not self.game.check_event(ce.Lazo): if isinstance(self.attacker, Player) and not self.game.check_event(ce.Lazo):
if any((isinstance(c, tvosc.Taglia) for c in self.equipment)): if any((isinstance(c, tvosc.Taglia) for c in self.equipment)):
self.attacker.hand.append(self.game.deck.draw(True)) self.attacker.hand.append(self.game.deck.draw(True))
self.sio.emit('chat_message', room=self.game.name, G.sio.emit('chat_message', room=self.game.name,
data=f'_taglia_reward|{self.name}|{self.attacker.name}') data=f'_taglia_reward|{self.name}|{self.attacker.name}')
self.attacker.notify_self() self.attacker.notify_self()
if len(self.hand) > 0 and any((isinstance(cd, tvosc.Shotgun) for cd in self.attacker.equipment)): if len(self.hand) > 0 and any((isinstance(cd, tvosc.Shotgun) for cd in self.attacker.equipment)):
c = self.hand.pop(randrange(0, len(self.hand))) c = self.hand.pop(randrange(0, len(self.hand)))
self.game.deck.scrap(c, True) self.game.deck.scrap(c, True)
self.sio.emit('chat_message', room=self.game.name, data=f'_shotgun_scrap|{self.name}|{c.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_shotgun_scrap|{self.name}|{c.name}')
if self.attacker and 'gold_rush' in self.game.expansions: if self.attacker and 'gold_rush' in self.game.expansions:
if (isinstance(self.attacker, Player)): if (isinstance(self.attacker, Player)):
self.attacker.gold_nuggets += 1 self.attacker.gold_nuggets += 1
@ -1285,7 +1284,7 @@ class Player:
self.hand.append(self.game.deck.draw(True)) self.hand.append(self.game.deck.draw(True))
card.use_card(self) card.use_card(self)
print(f'{self.game.name}: {self.name} responded with {card.name}') print(f'{self.game.name}: {self.name} responded with {card.name}')
self.sio.emit('chat_message', room=self.game.name, data=f'_respond|{self.name}|{card.name}') G.sio.emit('chat_message', room=self.game.name, data=f'_respond|{self.name}|{card.name}')
self.game.deck.scrap(card, True) self.game.deck.scrap(card, True)
self.notify_self() self.notify_self()
self.mancato_needed -= 1 self.mancato_needed -= 1
@ -1448,14 +1447,14 @@ class Player:
##Vendetta## ##Vendetta##
if not forced and self.game.check_event(ce.Vendetta) and self.can_play_vendetta: if not forced and self.game.check_event(ce.Vendetta) and self.can_play_vendetta:
picked: cs.Card = self.game.deck.pick_and_scrap() picked: cs.Card = self.game.deck.pick_and_scrap()
self.sio.emit('chat_message', room=self.game.name, data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}') G.sio.emit('chat_message', room=self.game.name, data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}')
if picked.check_suit(self.game, [cs.Suit.HEARTS]): if picked.check_suit(self.game, [cs.Suit.HEARTS]):
self.play_turn(can_play_vendetta=False) self.play_turn(can_play_vendetta=False)
return return
##Don Bell## ##Don Bell##
if not forced and self.character.check(self.game, grch.DonBell) and self.can_play_again_don_bell: if not forced and self.character.check(self.game, grch.DonBell) and self.can_play_again_don_bell:
picked: cs.Card = self.game.deck.pick_and_scrap() picked: cs.Card = self.game.deck.pick_and_scrap()
self.sio.emit('chat_message', room=self.game.name, data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}') G.sio.emit('chat_message', room=self.game.name, data=f'_flipped|{self.name}|{picked.name}|{picked.num_suit()}')
self.can_play_again_don_bell = False self.can_play_again_don_bell = False
if picked.check_suit(self.game, [cs.Suit.HEARTS, cs.Suit.DIAMONDS]): if picked.check_suit(self.game, [cs.Suit.HEARTS, cs.Suit.DIAMONDS]):
self.play_turn(can_play_vendetta=False) self.play_turn(can_play_vendetta=False)

6
backend/globals.py Normal file
View File

@ -0,0 +1,6 @@
class G:
sio = None
def __init__(self):
pass

35
backend/server.py
View File

@ -20,10 +20,12 @@ sys.setrecursionlimit(10**6) # this should prevents bots from stopping
import logging import logging
logging.basicConfig(filename='out.log', level='ERROR') logging.basicConfig(filename='out.log', level='ERROR')
from functools import wraps from functools import wraps
from globals import G
Metrics.init() Metrics.init()
sio = socketio.Server(cors_allowed_origins="*") sio = socketio.Server(cors_allowed_origins="*")
G.sio = sio
static_files={ static_files={
'/': {'content_type': 'text/html', 'filename': 'index.html'}, '/': {'content_type': 'text/html', 'filename': 'index.html'},
@ -114,7 +116,7 @@ def set_username(sid, username):
ses = sio.get_session(sid) ses = sio.get_session(sid)
if not isinstance(ses, Player): if not isinstance(ses, Player):
dt = username["discord_token"] if 'discord_token' in username else None dt = username["discord_token"] if 'discord_token' in username else None
sio.save_session(sid, Player(username["name"], sid, sio, discord_token=dt)) sio.save_session(sid, Player(username["name"], sid, discord_token=dt))
print(f'{sid} is now {username}') print(f'{sid} is now {username}')
advertise_lobbies() advertise_lobbies()
elif ses.game == None or not ses.game.started: elif ses.game == None or not ses.game.started:
@ -138,7 +140,7 @@ def get_me(sid, room):
sio.get_session(sid).game.notify_room() sio.get_session(sid).game.notify_room()
else: else:
dt = room["discord_token"] if 'discord_token' in room else None dt = room["discord_token"] if 'discord_token' in room else None
sio.save_session(sid, Player('player', sid, sio, discord_token=dt)) sio.save_session(sid, Player('player', sid, discord_token=dt))
if 'replay' in room and room['replay'] != None: if 'replay' in room and room['replay'] != None:
create_room(sid, room['replay']) create_room(sid, room['replay'])
sid = sio.get_session(sid) sid = sio.get_session(sid)
@ -160,9 +162,9 @@ def get_me(sid, room):
join_room(sid, room) join_room(sid, room)
elif len(de_games) == 1 and de_games[0].started: elif len(de_games) == 1 and de_games[0].started:
print('room exists') print('room exists')
if room['username'] != None and any((p.name == room['username'] for p in de_games[0].players if (p.is_bot or (dt != None and p.discord_token == dt)))): if room['username'] != None and any((p.name == room['username'] for p in de_games[0].players if (p.is_bot or (dt != None and p.discord_token == dt) or p.sid == None))):
print('getting inside the bot') print('getting inside the bot')
bot = [p for p in de_games[0].players if p.is_bot and p.name == room['username'] ][0] bot = [p for p in de_games[0].players if (p.is_bot or (dt != None and p.discord_token == dt) or p.sid == None) and p.name == room['username']][0]
bot.sid = sid bot.sid = sid
bot.is_bot = False bot.is_bot = False
sio.enter_room(sid, de_games[0].name) sio.enter_room(sid, de_games[0].name)
@ -225,7 +227,7 @@ def create_room(sid, room_name):
room_name += f'_{random.randint(0,100)}' room_name += f'_{random.randint(0,100)}'
sio.leave_room(sid, 'lobby') sio.leave_room(sid, 'lobby')
sio.enter_room(sid, room_name) sio.enter_room(sid, room_name)
g = Game(room_name, sio) g = Game(room_name)
g.add_player(sio.get_session(sid)) g.add_player(sio.get_session(sid))
if room_name in blacklist: if room_name in blacklist:
g.is_hidden = True g.is_hidden = True
@ -436,12 +438,12 @@ def chat_message(sid, msg, pl=None):
if '/addbot' in msg and not ses.game.started: if '/addbot' in msg and not ses.game.started:
if len(msg.split()) > 1: if len(msg.split()) > 1:
# for _ in range(int(msg.split()[1])): # for _ in range(int(msg.split()[1])):
# ses.game.add_player(Player(f'AI_{random.randint(0,1000)}', 'bot', sio, bot=True)) # ses.game.add_player(Player(f'AI_{random.randint(0,1000)}', 'bot', bot=True))
sio.emit('chat_message', room=ses.game.name, data={'color': f'red','text':f'Only 1 bot at the time'}) sio.emit('chat_message', room=ses.game.name, data={'color': f'red','text':f'Only 1 bot at the time'})
else: else:
bot = Player(f'AI_{random.randint(0,10)}', 'bot', sio, bot=True) bot = Player(f'AI_{random.randint(0,10)}', 'bot', bot=True)
while any((p for p in ses.game.players if p.name == bot.name)): while any((p for p in ses.game.players if p.name == bot.name)):
bot = Player(f'AI_{random.randint(0,10)}', 'bot', sio, bot=True) bot = Player(f'AI_{random.randint(0,10)}', 'bot', bot=True)
ses.game.add_player(bot) ses.game.add_player(bot)
bot.bot_spin() bot.bot_spin()
return return
@ -763,6 +765,7 @@ def discord_auth(sid, data):
if res.status_code == 200: if res.status_code == 200:
sio.emit('discord_auth_succ', room=sid, data=res.json()) sio.emit('discord_auth_succ', room=sid, data=res.json())
def pool_metrics(): def pool_metrics():
sio.sleep(60) sio.sleep(60)
Metrics.send_metric('lobbies', points=[sum(not g.is_replay for g in games)]) Metrics.send_metric('lobbies', points=[sum(not g.is_replay for g in games)])
@ -790,7 +793,23 @@ class CustomProxyFix(object):
discord_ci = '1059452581027532880' discord_ci = '1059452581027532880'
discord_cs = 'Mc8ZlMQhayzi1eOqWFtGHs3L0iXCzaEu' discord_cs = 'Mc8ZlMQhayzi1eOqWFtGHs3L0iXCzaEu'
import pickle
def save_games():
sio.sleep(2)
with open('games.pickle', 'wb') as f:
pickle.dump([g for g in games if g.started], f)
save_games()
if __name__ == '__main__': if __name__ == '__main__':
if os.path.exists('games.pickle'):
with open('games.pickle', 'rb') as file:
games = pickle.load(file)
for g in games:
for p in g.players:
if p.sid != 'bot':
p.sid = None
else:
sio.start_background_task(p.bot_spin)
sio.start_background_task(save_games)
sio.start_background_task(pool_metrics) sio.start_background_task(pool_metrics)
eventlet.wsgi.server(eventlet.listen(('', 5001)), CustomProxyFix(app)) eventlet.wsgi.server(eventlet.listen(('', 5001)), CustomProxyFix(app))

3
backend/tests/__init__.py
View File

@ -0,0 +1,3 @@
from tests.dummy_socket import DummySocket
from globals import G
G.sio = DummySocket()

121
backend/tests/cards_test.py
View File

@ -1,16 +1,15 @@
from random import randint from random import randint
from bang.characters import Character from bang.characters import Character
from bang.cards import * from bang.cards import *
from tests.dummy_socket import DummySocket
from bang.deck import Deck from bang.deck import Deck
from bang.game import Game from bang.game import Game
from bang.players import Player, PendingAction from bang.players import Player, PendingAction
# test card Barile # test card Barile
def test_barile(): def test_barile():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)] ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -43,9 +42,9 @@ def test_barile():
#test card Volcanic #test card Volcanic
def test_volcanic(): def test_volcanic():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)] ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -67,9 +66,9 @@ def test_volcanic():
# test card Dinamite # test card Dinamite
def test_dinamite(): def test_dinamite():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)] ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -103,9 +102,9 @@ def test_dinamite():
# test mirino # test mirino
def test_mirino(): def test_mirino():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(4)] ps = [Player(f'p{i}', f'p{i}') for i in range(4)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -121,9 +120,9 @@ def test_mirino():
# test mustang # test mustang
def test_mustang(): def test_mustang():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)] ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -139,9 +138,9 @@ def test_mustang():
# test Prigione # test Prigione
def test_prigione(): def test_prigione():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(4)] ps = [Player(f'p{i}', f'p{i}') for i in range(4)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -171,9 +170,9 @@ def test_prigione():
# test all weapons ranges # test all weapons ranges
def test_all_weapons(): def test_all_weapons():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(4)] ps = [Player(f'p{i}', f'p{i}') for i in range(4)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -195,9 +194,9 @@ def test_all_weapons():
# test bang # test bang
def test_bang(): def test_bang():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -214,9 +213,9 @@ def test_bang():
# test birra # test birra
def test_birra_2p(): def test_birra_2p():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -231,9 +230,9 @@ def test_birra_2p():
# test birra # test birra
def test_birra_3p(): def test_birra_3p():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)] ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -262,9 +261,9 @@ def test_birra_3p():
# test CatBalou # test CatBalou
def test_catbalou(): def test_catbalou():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -282,9 +281,9 @@ def test_catbalou():
# test Diligenza # test Diligenza
def test_diligenza(): def test_diligenza():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(4)] ps = [Player(f'p{i}', f'p{i}') for i in range(4)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -298,9 +297,9 @@ def test_diligenza():
# test Duello # test Duello
def test_duello(): def test_duello():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -326,9 +325,9 @@ def test_duello():
# test Emporio # test Emporio
def test_emporio(): def test_emporio():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(7)] ps = [Player(f'p{i}', f'p{i}') for i in range(7)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -352,9 +351,9 @@ def test_emporio():
# test Gatling # test Gatling
def test_gatling(): def test_gatling():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(7)] ps = [Player(f'p{i}', f'p{i}') for i in range(7)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -386,9 +385,9 @@ def test_gatling():
# test Indiani # test Indiani
def test_indiani(): def test_indiani():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(7)] ps = [Player(f'p{i}', f'p{i}') for i in range(7)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -420,9 +419,9 @@ def test_indiani():
# test Mancato # test Mancato
def test_mancato(): def test_mancato():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -442,9 +441,9 @@ def test_mancato():
# test Panico # test Panico
def test_panico(): def test_panico():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -461,9 +460,9 @@ def test_panico():
# test Saloon # test Saloon
def test_saloon(): def test_saloon():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(8)] ps = [Player(f'p{i}', f'p{i}') for i in range(8)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -480,9 +479,9 @@ def test_saloon():
# test WellsFargo # test WellsFargo
def test_wells_fargo(): def test_wells_fargo():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(4)] ps = [Player(f'p{i}', f'p{i}') for i in range(4)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()

97
backend/tests/character_test.py
View File

@ -1,15 +1,14 @@
from random import randint from random import randint
from bang.characters import * from bang.characters import *
from tests.dummy_socket import DummySocket
from bang.deck import Deck from bang.deck import Deck
from bang.game import Game from bang.game import Game
from bang.players import Player, PendingAction from bang.players import Player, PendingAction
from bang.cards import * from bang.cards import *
def test_bartcassidy(): def test_bartcassidy():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -29,9 +28,9 @@ def test_bartcassidy():
assert len(g.players[(g.turn+1)%2].hand) == 1 assert len(g.players[(g.turn+1)%2].hand) == 1
def test_blackjack(): def test_blackjack():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(1)] ps = [Player(f'p{i}', f'p{i}') for i in range(1)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -62,9 +61,9 @@ def test_blackjack():
g.players[g.turn].end_turn() g.players[g.turn].end_turn()
def test_calamityjanet(): def test_calamityjanet():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -89,9 +88,9 @@ def test_calamityjanet():
assert g.players[(g.turn+1)%2].lives == 1 assert g.players[(g.turn+1)%2].lives == 1
def test_ElGringo(): def test_ElGringo():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -112,9 +111,9 @@ def test_ElGringo():
assert len(g.players[g.turn].hand) == 0 assert len(g.players[g.turn].hand) == 0
def test_JesseJones(): def test_JesseJones():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -133,9 +132,9 @@ def test_JesseJones():
assert len(g.players[g.turn].hand) == 2 assert len(g.players[g.turn].hand) == 2
def test_Jourdonnais(): def test_Jourdonnais():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -153,9 +152,9 @@ def test_Jourdonnais():
assert g.players[(g.turn+1)%2].pending_action == PendingAction.PICK assert g.players[(g.turn+1)%2].pending_action == PendingAction.PICK
def test_KitCarlson(): def test_KitCarlson():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -176,9 +175,9 @@ def test_KitCarlson():
assert g.players[g.turn].pending_action == PendingAction.PLAY assert g.players[g.turn].pending_action == PendingAction.PLAY
def test_LuckyDuke(): def test_LuckyDuke():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -198,9 +197,9 @@ def test_LuckyDuke():
assert g.players[g.turn].pending_action == PendingAction.DRAW assert g.players[g.turn].pending_action == PendingAction.DRAW
def test_PaulRegret(): def test_PaulRegret():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -214,9 +213,9 @@ def test_PaulRegret():
assert pls[0]['dist'] > g.players[0].get_sight() assert pls[0]['dist'] > g.players[0].get_sight()
def test_PedroRamirez(): def test_PedroRamirez():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -237,9 +236,9 @@ def test_PedroRamirez():
assert isinstance(g.players[g.turn].hand[0], Bang) assert isinstance(g.players[g.turn].hand[0], Bang)
def test_RoseDoolan(): def test_RoseDoolan():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -256,9 +255,9 @@ def test_RoseDoolan():
assert pls[0]['dist'] <= g.players[1].get_sight() assert pls[0]['dist'] <= g.players[1].get_sight()
def test_SidKetchum(): def test_SidKetchum():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -278,9 +277,9 @@ def test_SidKetchum():
assert g.players[g.turn].lives == 2 assert g.players[g.turn].lives == 2
def test_SlabTheKiller(): def test_SlabTheKiller():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -301,9 +300,9 @@ def test_SlabTheKiller():
assert g.players[(g.turn+1)%2].lives == 3 assert g.players[(g.turn+1)%2].lives == 3
def test_SuzyLafayette(): def test_SuzyLafayette():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -318,9 +317,9 @@ def test_SuzyLafayette():
g.players[g.turn].end_turn() g.players[g.turn].end_turn()
def test_VultureSam(): def test_VultureSam():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)] ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -341,9 +340,9 @@ def test_VultureSam():
return return
def test_WillyTheKid(): def test_WillyTheKid():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()

8
backend/tests/deck_test.py
View File

@ -3,7 +3,7 @@ from bang.deck import Deck
from bang.game import Game from bang.game import Game
def test_card_flip(): def test_card_flip():
g = Game('test', DummySocket()) g = Game('test')
g.deck = Deck(g) g.deck = Deck(g)
l = len(g.deck.cards) l = len(g.deck.cards)
assert g.deck.pick_and_scrap() != None assert g.deck.pick_and_scrap() != None
@ -11,7 +11,7 @@ def test_card_flip():
assert len(g.deck.scrap_pile) == 1 assert len(g.deck.scrap_pile) == 1
def test_draw(): def test_draw():
g = Game('test', DummySocket()) g = Game('test')
g.deck = Deck(g) g.deck = Deck(g)
l = len(g.deck.cards) l = len(g.deck.cards)
assert g.deck.draw(True) != None assert g.deck.draw(True) != None
@ -19,7 +19,7 @@ def test_draw():
assert len(g.deck.scrap_pile) == 0 assert len(g.deck.scrap_pile) == 0
def test_reshuffle(): def test_reshuffle():
g = Game('test', DummySocket()) g = Game('test')
g.deck = Deck(g) g.deck = Deck(g)
l = len(g.deck.cards) l = len(g.deck.cards)
for i in range(80): for i in range(80):
@ -28,7 +28,7 @@ def test_reshuffle():
assert len(g.deck.scrap_pile) == 1 assert len(g.deck.scrap_pile) == 1
def test_draw_from_scrap(): def test_draw_from_scrap():
g = Game('test', DummySocket()) g = Game('test')
g.deck = Deck(g) g.deck = Deck(g)
l = len(g.deck.cards) l = len(g.deck.cards)
assert g.deck.pick_and_scrap() != None assert g.deck.pick_and_scrap() != None

43
backend/tests/game_test.py
View File

@ -1,4 +1,3 @@
from tests.dummy_socket import DummySocket
from bang.deck import Deck from bang.deck import Deck
from bang.game import Game from bang.game import Game
from bang.players import Player, PendingAction from bang.players import Player, PendingAction
@ -7,13 +6,13 @@ from bang.cards import *
# test that game can start # test that game can start
def test_game_start(): def test_game_start():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
p1 = Player('p1', 'p1', sio) p1 = Player('p1', 'p1')
g.add_player(p1) g.add_player(p1)
p2 = Player('p2', 'p2', sio) p2 = Player('p2', 'p2')
g.add_player(p2) g.add_player(p2)
p3 = Player('p3', 'p3', sio) p3 = Player('p3', 'p3')
g.add_player(p3) g.add_player(p3)
assert p1.role == None assert p1.role == None
assert p2.role == None assert p2.role == None
@ -37,20 +36,20 @@ def test_game_start():
# test that dodge_city is added to games with more than 8 players # test that dodge_city is added to games with more than 8 players
def test_dodge_city(): def test_dodge_city():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
for i in range(9): for i in range(9):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
assert 'dodge_city' in g.expansions assert 'dodge_city' in g.expansions
# test that a game with 2 players has only renegade as role # test that a game with 2 players has only renegade as role
def test_renegade_only(): def test_renegade_only():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
p1 = Player('p1', 'p1', sio) p1 = Player('p1', 'p1')
g.add_player(p1) g.add_player(p1)
p2 = Player('p2', 'p2', sio) p2 = Player('p2', 'p2')
g.add_player(p2) g.add_player(p2)
g.start_game() g.start_game()
assert isinstance(g.players[0].role, Renegade) assert isinstance(g.players[0].role, Renegade)
@ -58,10 +57,10 @@ def test_renegade_only():
# test that a game with 3 player has Renegade, Vice and Outlaw as roles # test that a game with 3 player has Renegade, Vice and Outlaw as roles
def test_renegade_vice_outlaw(): def test_renegade_vice_outlaw():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
for i in range(3): for i in range(3):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
roles = {p.role.name for p in g.players} roles = {p.role.name for p in g.players}
@ -69,10 +68,10 @@ def test_renegade_vice_outlaw():
# test that a game with 4 players has all roles except the deputy # test that a game with 4 players has all roles except the deputy
def test_4_players_roles(): def test_4_players_roles():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
for i in range(4): for i in range(4):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
roles = {p.role.name for p in g.players} roles = {p.role.name for p in g.players}
@ -80,10 +79,10 @@ def test_4_players_roles():
# test that a game with 5 players has all roles # test that a game with 5 players has all roles
def test_5_players_roles(): def test_5_players_roles():
sio = DummySocket()
g = Game('test', sio) g = Game('test')
for i in range(5): for i in range(5):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
roles = {p.role.name for p in g.players} roles = {p.role.name for p in g.players}

36
backend/tests/roles_test.py
View File

@ -1,5 +1,4 @@
from bang.characters import Character from bang.characters import Character
from tests.dummy_socket import DummySocket
from bang.deck import Deck from bang.deck import Deck
from bang.game import Game from bang.game import Game
from bang.players import Player, PendingAction from bang.players import Player, PendingAction
@ -8,10 +7,9 @@ from bang.cards import *
# test that a game with 3 player the deputy kills renegade and wins # test that a game with 3 player the deputy kills renegade and wins
def test_3p_deputy_win(): def test_3p_deputy_win():
sio = DummySocket() g = Game('test')
g = Game('test', sio)
for i in range(3): for i in range(3):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
for p in g.players: for p in g.players:
@ -33,10 +31,9 @@ def test_3p_deputy_win():
# test that a game with 3 player the renegade kills the outlaw and wins # test that a game with 3 player the renegade kills the outlaw and wins
def test_3p_renegade_win(): def test_3p_renegade_win():
sio = DummySocket() g = Game('test')
g = Game('test', sio)
for i in range(3): for i in range(3):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
for p in g.players: for p in g.players:
@ -60,10 +57,9 @@ def test_3p_renegade_win():
# test that a game with 3 player the outlaw kills the deputy and wins # test that a game with 3 player the outlaw kills the deputy and wins
def test_3p_outlaw_win(): def test_3p_outlaw_win():
sio = DummySocket() g = Game('test')
g = Game('test', sio)
for i in range(3): for i in range(3):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
for p in g.players: for p in g.players:
@ -87,10 +83,9 @@ def test_3p_outlaw_win():
# test that a game with 4 player the outlaw kills the sheriff and win # test that a game with 4 player the outlaw kills the sheriff and win
def test_4p_outlaw_win(): def test_4p_outlaw_win():
sio = DummySocket() g = Game('test')
g = Game('test', sio)
for i in range(4): for i in range(4):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
for p in g.players: for p in g.players:
@ -116,10 +111,9 @@ def test_4p_outlaw_win():
# test that a game with 5 player the renegade kills all the other players and wins # test that a game with 5 player the renegade kills all the other players and wins
def test_5p_renegade_gatling_win(): def test_5p_renegade_gatling_win():
sio = DummySocket() g = Game('test')
g = Game('test', sio)
for i in range(5): for i in range(5):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
for p in g.players: for p in g.players:
@ -148,10 +142,9 @@ def test_5p_renegade_gatling_win():
# test that a game with 5 player the renegade kills all the other players and wins # test that a game with 5 player the renegade kills all the other players and wins
def test_5p_renegade_indiani_win(): def test_5p_renegade_indiani_win():
sio = DummySocket() g = Game('test')
g = Game('test', sio)
for i in range(5): for i in range(5):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
for p in g.players: for p in g.players:
@ -180,10 +173,9 @@ def test_5p_renegade_indiani_win():
# test that a game with 5 player the renegade kills the sheriff but it isn't the last alive player and the outlaws wins # test that a game with 5 player the renegade kills the sheriff but it isn't the last alive player and the outlaws wins
def test_5p_outlaw_death_win(): def test_5p_outlaw_death_win():
sio = DummySocket() g = Game('test')
g = Game('test', sio)
for i in range(5): for i in range(5):
p = Player(f'p{i}', f'p{i}', sio) p = Player(f'p{i}', f'p{i}')
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
for p in g.players: for p in g.players:

51
backend/tests/valley_of_shadows_test.py
View File

@ -1,7 +1,6 @@
from random import randint from random import randint
from bang.characters import Character from bang.characters import Character
from bang.expansions.the_valley_of_shadows.cards import * from bang.expansions.the_valley_of_shadows.cards import *
from tests.dummy_socket import DummySocket
from bang.deck import Deck from bang.deck import Deck
from bang.game import Game from bang.game import Game
from bang.players import Player, PendingAction from bang.players import Player, PendingAction
@ -9,9 +8,8 @@ import bang.cards as cs
# test UltimoGiro # test UltimoGiro
def test_ultimo_giro(): def test_ultimo_giro():
sio = DummySocket() g = Game('test')
g = Game('test', sio) ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -28,9 +26,8 @@ def test_ultimo_giro():
# test Tomahawk # test Tomahawk
def test_tomahawk(): def test_tomahawk():
sio = DummySocket() g = Game('test')
g = Game('test', sio) ps = [Player(f'p{i}', f'p{i}') for i in range(6)]
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(6)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -48,9 +45,8 @@ def test_tomahawk():
# test Fantasma # test Fantasma
def test_fantasma(): def test_fantasma():
sio = DummySocket() g = Game('test')
g = Game('test', sio) ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -73,9 +69,8 @@ def test_fantasma():
# test SerpenteASonagli # test SerpenteASonagli
def test_serpente_a_sonagli(): def test_serpente_a_sonagli():
sio = DummySocket() g = Game('test')
g = Game('test', sio) ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -107,10 +102,9 @@ def test_serpente_a_sonagli():
# test RitornoDiFiamma # test RitornoDiFiamma
def test_ritorno_di_fiamma(): def test_ritorno_di_fiamma():
sio = DummySocket() g = Game('test')
g = Game('test', sio)
g.expansions = ['the_valley_of_shadows'] g.expansions = ['the_valley_of_shadows']
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)] ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -144,9 +138,8 @@ def test_ritorno_di_fiamma():
# test RitornoDiFiamma with gatling # test RitornoDiFiamma with gatling
def test_ritorno_di_fiamma_gatling(): def test_ritorno_di_fiamma_gatling():
sio = DummySocket() g = Game('test')
g = Game('test', sio) ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)]
g.expansions = ['the_valley_of_shadows'] g.expansions = ['the_valley_of_shadows']
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
@ -177,9 +170,8 @@ def test_ritorno_di_fiamma_gatling():
# test Taglia # test Taglia
def test_taglia(): def test_taglia():
sio = DummySocket() g = Game('test')
g = Game('test', sio) ps = [Player(f'p{i}', f'p{i}') for i in range(3)]
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(3)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -201,9 +193,8 @@ def test_taglia():
# test Bandidos # test Bandidos
def test_bandidos(): def test_bandidos():
sio = DummySocket() g = Game('test')
g = Game('test', sio) ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -233,9 +224,8 @@ def test_bandidos():
# test Poker # test Poker
def test_poker(): def test_poker():
sio = DummySocket() g = Game('test')
g = Game('test', sio) ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()
@ -265,9 +255,8 @@ def test_poker():
# test Tornado # test Tornado
def test_tornado(): def test_tornado():
sio = DummySocket() g = Game('test')
g = Game('test', sio) ps = [Player(f'p{i}', f'p{i}') for i in range(2)]
ps = [Player(f'p{i}', f'p{i}', sio) for i in range(2)]
for p in ps: for p in ps:
g.add_player(p) g.add_player(p)
g.start_game() g.start_game()