def __init__(self, **kwargs):
# List of final players who will play.
self.saved_players = Players()
# [{'player_id':'$840eb76e-aa1b-4345-978c-21919d189001s','player_names':['bob','carl'], 'cards':[]]
# Collect data of potential players
self.potential_players = Players()
self.lock = Lock()
self.VICTIM_IP = kwargs.get('victim_ip')
self.SNIFF_INF = kwargs.get('sniff_inf')
self.console_cb = kwargs.get('console_cb')
self.status_cb = kwargs.get('status_cb')
self.player_cb = kwargs.get('player_cb')
self.GATEWAY_IP = kwargs.get('gateway_ip', self.getGatewayIp())
self.VICTIM_MAC = kwargs.get('victim_mac', get_mac_address(hostname=f'{self.VICTIM_IP}'))
self.GATEWAY_MAC = kwargs.get('gateway_mac', get_mac_address(hostname=f'{self.GATEWAY_IP}'))
self.MY_IP = kwargs.get('my_ip', self.getIpAddress(self.SNIFF_INF))
self.SNIFF_INF_MAC = kwargs.get('sniff_inf_mac', get_mac_address(interface=self.SNIFF_INF))
self.game_state = GAME_STATES['INIT']
self.game_actions = []
self.pkt_count = 0
self.console = ''
self.game_state_cb = {}
self.set_capture_type(conf)
def playAddPlayersToGame(self, pkt):
# This message indicates that the game and final list of players have started
final_players_found = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_PLAYERS_QUEUED)
if final_players_found and len(final_players_found) > 0:
self.finalizePlayers(self.potential_players, final_players_found)
# Erase potential_players
self.potential_players = Players()
def finalizePlayers(self, potential_players:Players, player_ids:[] = []):
'''Match player_ids to saved_players and return Players()
Params:
potential_players Players object.
players_ids list of [(message, player_id)]. Must be less than total number of possible players in game (5).
'''
# Update console with player_ids found
for message, player_id in player_ids:
self.game_state = GAME_STATES['STARTED']
self.updateConsole(f'{message}: {player_id}')
# temp_players = Players() # Doesn't work. Need to explicitly set players to []
temp_players = Players(players=[])
self.updateConsole(f'finalizePlayers temp_players size is {len(temp_players.players)}')
# Match player_id with Players.players list and copy to new Players().
for message, final_player_id in player_ids:
if player:= potential_players.get_player(final_player_id):
# Reset player hand
player.hand = {b'Defuse0.0'}
temp_players.save_player(player)
idx = temp_players.get_index(player.player_id)
# Wipe any gui forms if exist.
self.updateConsole((
f'finalizePlayers match found: {player.names} {idx} '
f'out of {len(temp_players.players)} list {len(player_ids)}'))
def __init__(self):
name = NameGenerator.Generator().generateName()
print 'Game name: ' + name
self.eventQueue = EventQueue()
self.dispatcher = Dispatcher()
self._setupEvents()
self.players = Players(name)
self.hand = CardHandler.Hand(self.eventQueue)
self.cardServer = Communication(ServerSettings.ADDR)
self.noCardOnTable = False
self.leftHand = None
self.rigthHand = None
def main():
#asking main parameters
print("\n#### WELCOME TO COUPE ####")
n_players = input("Please insert the number of players 3-4: ")
while n_players != "3":
if n_players != "4":
n_players = input("Yoy must give a valid number: ")
else:
break
n_players = int(n_players)
player = []
game = []
count = 0
while count < n_players:
game.append(Game(2, [], []))
name = input("Please insert the " + str(count + 1) +
" name in the clockwise direction: ")
player.append(Players(name))
count += 1
#gaming
kill = 0 #if this is 1, the game is over
play = 1
player_turn = 1
turned_cards = [] #cards that have been turned
breaker = 0
while breaker < n_players:
turned_cards.append(["X", "X"])
breaker += 1
#setting cards and mazes
counter = 0
while counter < len(player):
game[counter].cards = player[0].Player_cards()
counter += 1
for value in game:
value.maze = player[game.index(value)].Return_deck()
while kill != 1:
if player_turn == n_players + 1:
player_turn = 1
if player[player_turn - 1].cards > 0:
print("\n|__-< COUPE >-__|\n")
print("\nPlay N° ", play)
print(str(player[player_turn - 1].name) + " is playing")
#turned cards
print("\nThe turned cards of players are: ")
countdown = 0
while countdown < len(player):
print(
player[countdown].name + str(": ") +
str(turned_cards[countdown]) + " - Coins: ",
game[countdown].coins)
countdown += 1
Card_watcher = input(
'\nWould you like to see your cards (yes/no): ')
while Card_watcher != "yes" and Card_watcher != "no":
Card_watcher = input(
'\nYou must give a valid answer to see your cards(yes/no): '
)
if Card_watcher == "yes":
print('Your cards are ' + str(game[player_turn - 1].cards))
other_players = []
for value in player:
if value.name != player[player_turn - 1].name:
if value.cards > 0:
other_players.append(value.name)
#automatic coup
legality = 1
if game[player_turn - 1].coins >= 10:
print('You have to performe coup')
action = "coup"
else:
#asking actions to the playing player
print(
"\nActions= income, foreign aid, coup, taxes, murder, extorsion, change"
)
action = input("What action are you going to performe: ")
while action != "income" and action != "foreign aid" and action != "coup" and action != "taxes" and action != "murder" and action != "extorsion" and action != "change":
print(
"Actions= income, foreign aid, coup, taxes, murder, extorsion, change"
)
action = input("You must give a valid action: ")
#counterattack and challenges
if action == "foreign aid" or action == "murder" or action == "extorsion" or action == "change":
counterattacks = []
challenges = []
for value in other_players:
answer = input(
value +
", you can: challenge, counterattack or pass: "******"challenge" and answer != "counterattack" and answer != "pass":
print(
"you can: challenge, counterattack or pass: "******", you must give a valid input: ")
print("")
if answer == "challenge":
challenges.append(value)
elif answer == "counterattack":
counterattacks.append(value)
if len(counterattacks) > 1:
index1 = random.randint(0, len(counterattacks) - 1)
counterattacker = counterattacks[index1]
elif len(counterattacks) == 1:
counterattacker = counterattacks[0]
else:
counterattacker = 0 #no counterattacker
if len(challenges) > 1:
index2 = random.randint(0, len(challenges) - 1)
challenger = challenges[index2]
elif len(challenges) == 1:
challenger = challenges[0]
else:
challenger = 0 #no challenger
if len(counterattacks) > 1:
print("The final counterattacker is " +
counterattacker)
if len(challenges) > 1:
print("The final challenger is " + challenger)
#challenging
if challenger != 0:
#useful parameters
action_influence = game[player_turn -
1].Influence(action)
player_name = player[player_turn - 1].name
player_cards = game[player_turn - 1].cards
challenger_cards = []
value = 0
while value < len(player):
if player[value].name == challenger:
for element in game[value].cards:
challenger_cards.append(element)
challenger_name = player[value].name
value += 1
#challenge
print(player_name + ", you have been challenged by " +
challenger_name)
if action_influence not in player_cards:
card_to_turn = game[player_turn - 1].Solution(
player_name, player_cards)
#player looses card
player[player_turn - 1].cards -= 1
turned_cards[player_turn - 1].append(card_to_turn)
turned_cards[player_turn - 1].pop(0)
for value in game:
if card_to_turn in value.cards:
index = value.cards.index(card_to_turn)
value.cards.pop(index)
legality = 0
else:
card_to_turn = game[player_turn - 1].Solution(
challenger_name, challenger_cards)
#challenger looses card
counter_index = 0
for value in player:
if value.name == challenger_name:
value.cards -= 1
challenger_index = counter_index
counter_index += 1
turned_cards[challenger_index].append(card_to_turn)
turned_cards[challenger_index].pop(0)
for value in game:
if card_to_turn in value.cards:
index = value.cards.index(card_to_turn)
value.cards.pop(index)
#player changes his card
new = game[player_turn -
1].Refresh(action_influence)
index_to_change = game[
player_turn - 1].cards.index(action_influence)
game[player_turn - 1].cards.pop(index_to_change)
game[player_turn - 1].cards.append(new)
#counter attacks
elif counterattacker != 0:
if action == "foreign aid" or action == "murder" or action == "extorsion":
#useful parameters
action_influence = game[player_turn -
1].Influence(action)
counteraction_influence = game[
player_turn - 1].CounterInfluence(action)
player_name = player[player_turn - 1].name
player_cards = game[player_turn - 1].cards
counterattacker_cards = []
value = 0
while value < len(player):
if player[value].name == counterattacker:
for element in game[value].cards:
counterattacker_cards.append(element)
counterattacker_name = player[value].name
value += 1
#counterattack
print(player_name +
", you have been counterattacked by " +
counterattacker_name)
defense = input(
"Would you like to challenge him (yes/no): ")
while defense != "yes" and defense != "no":
defense = input(
"You must give a valid input (yes/no): ")
#player accepts the counterattacl
if defense == "no":
if action_influence not in player_cards:
card_to_turn = game[player_turn -
1].Solution(
player_name,
player_cards)
#player looses card
player[player_turn - 1].cards -= 1
turned_cards[player_turn -
1].append(card_to_turn)
turned_cards[player_turn - 1].pop(0)
for value in game:
if card_to_turn in value.cards:
index = value.cards.index(
card_to_turn)
value.cards.pop(index)
legality = 0
if action == "murder":
game[player_turn - 1].coins -= 3
else:
card_to_turn = game[
player_turn - 1].Solution(
counterattacker_name,
counterattacker_cards)
#counterattacker looses card
counter_index = 0
for value in player:
if value.name == counterattacker_name:
value.cards -= 1
challenger_index = counter_index
counter_index += 1
turned_cards[challenger_index].append(
card_to_turn)
turned_cards[challenger_index].pop(0)
for value in game:
if card_to_turn in value.cards:
index = value.cards.index(
card_to_turn)
value.cards.pop(index)
#player changes his card
new = game[player_turn -
1].Refresh(action_influence)
index_to_change = game[
player_turn -
1].cards.index(action_influence)
game[player_turn -
1].cards.pop(index_to_change)
game[player_turn - 1].cards.append(new)
#player challenges counterattack
else:
print(
counterattacker_name +
", you have been counter challenged by " +
player_name)
if counteraction_influence not in counterattacker_cards:
card_to_turn = game[
player_turn - 1].Solution(
counterattacker_name,
counterattacker_cards)
#counterattacker looses card
counter_index = 0
for value in player:
if value.name == counterattacker_name:
value.cards -= 1
challenger_index = counter_index
counter_index += 1
turned_cards[challenger_index].append(
card_to_turn)
turned_cards[challenger_index].pop(0)
for value in game:
if card_to_turn in value.cards:
index = value.cards.index(
card_to_turn)
value.cards.pop(index)
#player changes his card
new = game[player_turn -
1].Refresh(action_influence)
index_to_change = game[
player_turn -
1].cards.index(action_influence)
game[player_turn -
1].cards.pop(index_to_change)
game[player_turn - 1].cards.append(new)
else:
card_to_turn = game[player_turn -
1].Solution(
player_name,
player_cards)
#player looses card
player[player_turn - 1].cards -= 1
turned_cards[player_turn -
1].append(card_to_turn)
turned_cards[player_turn - 1].pop(0)
for value in game:
if card_to_turn in value.cards:
index = value.cards.index(
card_to_turn)
value.cards.pop(index)
legality = 0
if action == "murder":
game[player_turn - 1].coins -= 3
if legality == 1:
#analazing actions
if action != "change":
result = game[player_turn - 1].Actions(
action, other_players)
else:
result = game[player_turn - 1].Actions(
action, game[player_turn - 1].cards)
while result == "not valid":
print(
"\nActions= income, foreign aid, coup, taxes, murder, extorsion, change"
)
action = input("You must perform a valid action: ")
if action != "change":
result = game[player_turn - 1].Actions(
action, other_players)
else:
result = game[player_turn - 1].Actions(
action, game[player_turn - 1].cards)
#execution of actions
if action == "murder":
for value in player:
if value.name == result:
index = player.index(value)
cards_to_kill = game[index].cards
print(cards_to_kill)
killed_card = input(
str(result) +
" please choose the card you want to turn over: ")
while killed_card not in cards_to_kill:
print(cards_to_kill)
killed_card = input(
"Please turn a valid card from your maze: ")
turned_cards[index].append(killed_card)
turned_cards[index].pop(0)
for value in game:
if killed_card in value.cards:
index = value.cards.index(killed_card)
value.cards.pop(index)
for value in player:
if value.name == result:
value.cards -= 1
if action == "coup":
for value in player:
if value.name == result:
index = player.index(value)
cards_to_coup = game[index].cards
print(cards_to_coup)
couped_card = input(
str(result) +
" please choose the card you want to coup: ")
while couped_card not in cards_to_coup:
print(cards_to_coup)
couped_card = input(
"Please turn a valid card from your maze: ")
turned_cards[index].append(couped_card)
turned_cards[index].pop(0)
for value in game:
if couped_card in value.cards:
index = value.cards.index(couped_card)
value.cards.pop(index)
for value in player:
if value.name == result:
value.cards -= 1
if action == "extorsion":
counter = 0
while counter < len(player):
if player[counter].name == result:
if game[counter].coins >= 2:
game[player_turn -
1].coins = game[player_turn - 1].coins + 2
elif game[counter].coins < 2:
game[player_turn -
1].coins = game[player_turn - 1].coins + 1
else:
pass
game[counter].coins = game[player_turn -
1].Steal_actions(
game[counter].coins)
counter += 1
if action == "change":
game[player_turn - 1].cards = result
play += 1
player_turn += 1
#analizing all the posible ending scenarios
if n_players == 3:
ending1 = player[0].cards == 0 and player[1].cards == 0
ending2 = player[1].cards == 0 and player[2].cards == 0
ending3 = player[0].cards == 0 and player[2].cards == 0
elif n_players == 4:
ending1 = player[0].cards == 0 and player[1].cards == 0 and player[
2].cards == 0
ending2 = player[1].cards == 0 and player[2].cards == 0 and player[
3].cards == 0
ending3 = player[2].cards == 0 and player[3].cards == 0 and player[
0].cards == 0
ending4 = player[3].cards == 0 and player[0].cards == 0 and player[
1].cards == 0
#killing cycle
if n_players == 3:
if ending1 == True:
kill = 1
winer = player[2].name
elif ending2 == True:
kill = 1
winer = player[0].name
elif ending3 == True:
kill = 1
winer = player[1].name
elif n_players == 4:
if ending1 == True:
kill = 1
winer = player[3].name
elif ending2 == True:
kill = 1
winer = player[0].name
elif ending3 == True:
kill = 1
winer = player[1].name
elif ending4 == True:
kill = 1
winer = player[2].name
print("\n GAME OVER!!")
print("The winer is :" + str(winer) + ", congratulations!")
class EkGameCheat:
def __init__(self, **kwargs):
# List of final players who will play.
self.saved_players = Players()
# [{'player_id':'$840eb76e-aa1b-4345-978c-21919d189001s','player_names':['bob','carl'], 'cards':[]]
# Collect data of potential players
self.potential_players = Players()
self.lock = Lock()
self.VICTIM_IP = kwargs.get('victim_ip')
self.SNIFF_INF = kwargs.get('sniff_inf')
self.console_cb = kwargs.get('console_cb')
self.status_cb = kwargs.get('status_cb')
self.player_cb = kwargs.get('player_cb')
self.GATEWAY_IP = kwargs.get('gateway_ip', self.getGatewayIp())
self.VICTIM_MAC = kwargs.get('victim_mac', get_mac_address(hostname=f'{self.VICTIM_IP}'))
self.GATEWAY_MAC = kwargs.get('gateway_mac', get_mac_address(hostname=f'{self.GATEWAY_IP}'))
self.MY_IP = kwargs.get('my_ip', self.getIpAddress(self.SNIFF_INF))
self.SNIFF_INF_MAC = kwargs.get('sniff_inf_mac', get_mac_address(interface=self.SNIFF_INF))
self.game_state = GAME_STATES['INIT']
self.game_actions = []
self.pkt_count = 0
self.console = ''
self.game_state_cb = {}
self.set_capture_type(conf)
def set_capture_type(self, scapy_conf):
my_os = platform.system()
if my_os == 'Linux':
scapy_conf.use_pcap = True
elif my_os == "Darwin":
# osx has issues with AF_PACKET.
# Disabling libpcap seems to fix.
scapy_conf.use_pcap = False
elif my_os == 'Windows':
raise Exception(f'Scapy packet library config setting.\nO/S {my_os} not supported')
else:
raise Exception(f'Scapy packet library config setting.\nO/S {repr(my_os)} not supported')
def updateConsole(self, message, call_back=None):
self.console = message
if call_back == None:
call_back = self.console_cb
if callable(call_back):
call_back(data = message)
def updateStatus(self, message, call_back=None):
self.console = message
if call_back == None:
call_back = self.status_cb
if callable(call_back):
call_back(data = message)
def setGameStateCb(self, state:str, cb:str=None):
if state in GAME_STATES.keys():
if callable(cb):
self.game_state_cb[state] = cb
def sendCb(self, **kwargs):
def _sendCb(pkt):
max_packet_size = 70 # bytes
if not pkt.haslayer(IP):
return
src_ip = pkt[IP].src
dst_ip = pkt[IP].dst
if dst_ip == self.MY_IP:
return
if pkt.haslayer(UDP) and pkt.haslayer(Raw) and len(pkt[IP][UDP][Raw].load) > max_packet_size:
# Increment packet count
self.pkt_count += 1
# self.updateStatus(f'Packet count {self.pkt_count}')
# TODO: Messages should be parsed in resepct to game state.
self.playOpponentChosen2(pkt)
self.playRegisterPlayers(pkt)
self.playAddPlayersToGame(pkt)
self.playCard(pkt)
self.playDrawCard(pkt)
self.playInsertCard(pkt)
self.playPlayCard(pkt)
self.playOpponentChosen(pkt)
self.playXchange(pkt)
#self.playEmote()
self.playStarted(pkt)
self.playDied(pkt)
return _sendCb
def playAddPlayersToGame(self, pkt):
# This message indicates that the game and final list of players have started
final_players_found = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_PLAYERS_QUEUED)
if final_players_found and len(final_players_found) > 0:
self.finalizePlayers(self.potential_players, final_players_found)
# Erase potential_players
self.potential_players = Players()
#message = pprint.pformat(inspect.getmembers(saved_players.players), indent=2)
#save_to_file(f'\n{len(saved_players.players)}\n{final_players_found}\n{message}', 'dump.txt')
def playCard(self, pkt):
# action, player_id, length, card. Looking for DrawFromBottom
played_card = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_PLAYCARD)
if len(played_card) > 0:
for action, player_id, length_n_card in played_card:
card = self.getNextMessage(length_n_card)
self.game_actions.append([action,player_id,card])
logging.debug(f'PLAYCARD: {action} by {self.saved_players.get_player_name(player_id)} card {card}')
self.updateConsole((
f'PLAYCARD: {action} by {self.saved_players.get_player_name(player_id)} card {card}'))
# Remove card from player hand
self.saved_players.remove_card(player_id, card)
def playDrawCard(self, pkt):
# action, player_id, len_and_card
played_card = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_DRAWCARD)
if len(played_card) > 0:
for action, player_id, length_n_card in played_card:
card = self.getNextMessage(length_n_card)
logging.debug([action,player_id, card])
self.game_actions.append([action, player_id, card])
self.saved_players.save_card(player_id, card)
self.updateConsole(f'{action} {self.saved_players.get_player_name(player_id)} {card}')
def playInsertCard(self, pkt):
# action, player_id, id, ek_pos.
played_card = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_INSERTCARD)
if len(played_card) > 0:
for action, player_id, len_n_card, ek_pos in played_card:
# Get bomb placement position
ek_pos = self.getNextMessage(ek_pos)
ek_pos = int(ek_pos) + 1 # More accurate
card = self.getNextMessage(len_n_card)
logging.debug(f'{action} by {self.saved_players.get_player_name(player_id)} {card} ek placed {ek_pos}')
self.game_actions.append([action,player_id,card, ek_pos])
self.updateConsole((
f'{action} by {self.saved_players.get_player_name(player_id)}'
f' {card} ek placed {ek_pos}'))
def playOpponentChosen2(self, pkt):
# action, player_id, id, ek_pos.
played_card = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_OPPONENTCHOSEN2)
if len(played_card) > 0:
for action, player_id, gen_id, len_n_card in played_card:
card = self.getNextMessage(len_n_card)
logging.debug(f'{action} by {self.saved_players.get_player_name(player_id)} {self.saved_players.get_player_name(gen_id)}')
self.game_actions.append([action,player_id,gen_id])
self.updateConsole((
f'playOpponentChosen2: {action} by '
f'{self.saved_players.get_player_name(player_id)} '
f'{self.saved_players.get_player_name(gen_id)}, {card}'))
def playPlayCard(self, pkt):
# Played card
played_card = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_PLAYCARD_0)
if len(played_card) > 0:
for action, player_id, length_n_card in played_card:
card = self.getNextMessage(length_n_card)
self.game_actions.append([action,player_id])
# Remove card from player hand
self.saved_players.remove_card(player_id, card)
logging.debug(f'REGEX_PLAYCARD_0: {action} by {self.saved_players.get_player_name(player_id)} card {card}')
self.updateConsole((
f'REGEX_PLAYCARD_0: {action} by '
f'{self.saved_players.get_player_name(player_id)} card {card}'))
def playOpponentChosen(self, pkt):
# Game activity 2, usually 2 player ids
# This could be something like a slap.
played_card = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_OPPONENTCHOSEN)
if len(played_card) > 0:
for action, player_id, opponent, length_and_card in played_card:
card = self.getNextMessage(length_and_card)
self.game_actions.append([player_id,card,opponent])
self.saved_players.remove_card(opponent, card)
logging.debug((
f'REGEX_OPPONENTCHOSEN1: card {card}'
f' by {self.saved_players.get_player_name(player_id)}'
f' to {self.saved_players.get_player_name(opponent)}'))
self.updateConsole((
f'playOpponentChosen: {action} card {card}'
f' by {self.saved_players.get_player_name(player_id)}'
f' to {self.saved_players.get_player_name(opponent)}'))
def playRegisterPlayers(self, pkt):
# Collect player details
found_players = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_PLAYERS)
if len(found_players) > 0:
for player_id, username, did, len_and_avatarIds in found_players:
avatarIds = self.getNextMessage(len_and_avatarIds)
new_player = Player(
player_id = player_id,
names = [username],
device_id = did,
avatar_id = avatarIds,
hand = {},
display_cb = self.player_cb,
)
self.potential_players.save_player(new_player)
logging.debug(f'Username: {username}, {player_id}, {avatarIds}, {did}')
self.updateConsole(f'Username: {username}, {player_id}, {avatarIds}, {did}')
def playXchange(self, pkt):
# action, player_id, card
played_card = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_XCHG)
if len(played_card) > 0:
for action, player_id, player_id2, length_n_card in played_card:
card = self.getNextMessage(length_n_card)
self.game_actions.append([action,player_id,card])
self.saved_players.remove_card(player_id2, card)
self.saved_players.save_card(player_id, card)
logging.debug(f'REGEX_XCHG: {action} from {self.saved_players.get_player_name(player_id2)} to {self.saved_players.get_player_name(player_id)} card {card}')
self.updateConsole((
f'REGEX_XCHG: {action} from '
f'{self.saved_players.get_player_name(player_id2)} to '
f'{self.saved_players.get_player_name(player_id)} card {card}'))
def playDied(self, pkt):
# action, player_id
for action, player_id in self.containsAll(pkt[IP][UDP][Raw].load, REGEX_DIED):
self.game_actions.append([action,player_id])
self.updateConsole(f'REGEX_DIED: {action} {self.saved_players.get_player_name(player_id)}')
def playStarted(self, pkt):
# action, player_id
for action in self.containsAll(pkt[IP][UDP][Raw].load, REGEX_STARTED):
self.game_actions.append([action])
self.updateConsole(f'REGEX_STARTED: {action}')
self.game_state = GAME_STATES['STARTED']
# Callback to ui maybe?
self.game_state_cb['STARTED']()
def playEmote(self, pkt):
# Collect player emotes
played_card = self.containsAll(pkt[IP][UDP][Raw].load, REGEX_EMOTE)
if len(played_card) > 0:
for action, player_id, emote_len_and_emote in played_card:
emote = self.getNextMessage(emote_len_and_emote)
#print(f'{action}: {get_player_name(saved_players, player_id)} sends {emote}')
# Attempt to send fake emotes TODO: wip
if (self.saved_players.get_player_name(player_id) and
self.saved_players.get_player_name(player_id)[0].decode() in 'capn'):
#pkt.show()
del pkt[IP].chksum
del pkt[UDP].chksum
del pkt[IP].len
del pkt[UDP].len
del pkt[Ether].dst
del pkt[Ether].src
#pkt[UDP].load = EMOTE_DRUNK
#sendp(pkt)
#pkt.show2() # New checksum
def finalizePlayers(self, potential_players:Players, player_ids:[] = []):
'''Match player_ids to saved_players and return Players()
Params:
potential_players Players object.
players_ids list of [(message, player_id)]. Must be less than total number of possible players in game (5).
'''
# Update console with player_ids found
for message, player_id in player_ids:
self.game_state = GAME_STATES['STARTED']
self.updateConsole(f'{message}: {player_id}')
# temp_players = Players() # Doesn't work. Need to explicitly set players to []
temp_players = Players(players=[])
self.updateConsole(f'finalizePlayers temp_players size is {len(temp_players.players)}')
# Match player_id with Players.players list and copy to new Players().
for message, final_player_id in player_ids:
if player:= potential_players.get_player(final_player_id):
# Reset player hand
player.hand = {b'Defuse0.0'}
temp_players.save_player(player)
idx = temp_players.get_index(player.player_id)
# Wipe any gui forms if exist.
self.updateConsole((
f'finalizePlayers match found: {player.names} {idx} '
f'out of {len(temp_players.players)} list {len(player_ids)}'))
self.saved_players = temp_players
class Game(object):
'''
Class for implementing player code
'''
def __init__(self):
name = NameGenerator.Generator().generateName()
print 'Game name: ' + name
self.eventQueue = EventQueue()
self.dispatcher = Dispatcher()
self._setupEvents()
self.players = Players(name)
self.hand = CardHandler.Hand(self.eventQueue)
self.cardServer = Communication(ServerSettings.ADDR)
self.noCardOnTable = False
self.leftHand = None
self.rigthHand = None
def _setupEvents(self):
self.dispatcher.register_handler(EventType.FINISH, self._finnish)
self.dispatcher.register_handler(EventType.JOIN, self.joinGame)
self.dispatcher.register_handler(EventType.ERROR, self._error)
self.dispatcher.register_handler(EventType.SOCKET_HANDLER_EXCEPTION, self._handlerException)
self.dispatcher.register_handler(EventType.DRAW, self.drawCard)
self.dispatcher.register_handler(EventType.GOT_PAIR_ON_HAND, self.discardPair)
self.dispatcher.register_handler(EventType.OUT, self.outOfCards)
self.dispatcher.register_handler(EventType.MY_TURN, self.myTurn)
self.dispatcher.register_handler(EventType.YOUR_TURN, self.yourTurn)
self.dispatcher.register_handler(EventType.OFFER_HAND, self.offerHand)
self.dispatcher.register_handler(EventType.NO_MORE_CARD_ON_TABLE, self._setNoMoreCardsOnTable)
self.dispatcher.register_handler(EventType.PICKED_CARD_FROM_RIGHT_PLAYER, self.gotCard)
def _finnish(self, event):
# Todo teardown system
print "Client is shutting down"
self.finished = True
def _handlerException(self, Event):
print "Got an socket handler exception", Event
def _error(self, event):
data = event.data
if data.has_key("msg"):
print data["msg"]
if data.has_key("fatal"):
if data["fatal"] == True:
self.eventQueue.addNewEvent(EventType.FINISH)
def _setNoMoreCardsOnTable(self, event):
self.noCardOnTable = True
@debugPrint
def start(self):
self.eventQueue.addNewEvent(EventType.JOIN)
self.finished = False
while not self.finished:
time.sleep(0.1)
for event in self.eventQueue.getAll():
self.dispatcher.dispatch(event)
@debugPrint
def myTurn(self, event):
if not self.noCardOnTable:
self.drawCard(None)
@debugPrint
def gotCard(self, event):
self.hand.addCardFromRes(event.data[DataType.RECEIVED_MESSAGE])
self.eventQueue.addNewEvent(EventType.OFFER_HAND)
# RightHandServer methods
@debugPrint
def joinGame(self, event):
'''
send: {'cmd':'join', 'nick':your_nick}
recv: {'result':'ok', 'players':['player1':[(ip, port), nick], 'player2':[(ip, port), nick], ...]}
'''
print 'Joining new game @ addr:', ServerSettings.HOST, 'port:', ServerSettings.PORT
try:
self.cardServer.connect()
cmd = {"cmd" : "join", "nick" : self.players.myName, "port" : ServerSettings.MY_PORT}
result = self.cardServer.cmd(cmd)
if result["result"] == "ok":
self.players.addPlayersFromJson(result)
else:
eventData = {"msg" : "Error: Got some kind of error from card server", "fatal" : True}
self.eventQueue.addNewEvent(EventType.ERROR, eventData)
return
except TypeError:
eventData = {"msg" : "Error: Could not parse to JSON in joinGame", "fatal" : True}
self.eventQueue.addNewEvent(EventType.ERROR, eventData)
return
except socket.error:
eventData = {"msg" : "Error: Could not connect to card server after several tries, Exiting", "fatal" : True}
self.eventQueue.addNewEvent(EventType.ERROR, eventData)
return
self._setupPlayerCom()
@debugPrint
def _setupPlayerCom(self):
print "Starting to set up connection to left and right player"
# This is the right hand server handling incoming events
self.rigthHand = RightHandServer(self.players.myAddr, self.eventQueue, self.players)
thread.start_new(self.rigthHand.run, ())
try:
self.leftHand = LeftHand(self.eventQueue, self.players)
self.leftHand.connect()
except socket.error:
eventData = {"msg" : "Error: Could not connect to left player in initial phase, Exiting", "fatal" : True}
self.eventQueue.addNewEvent(EventType.ERROR, eventData)
return
print "Connection to other players established successfully"
if self.players.myTurn:
self.eventQueue.addNewEvent(EventType.DRAW)
@debugPrint
def drawCard(self, event):
'''
send: {'cmd':'draw'}
recv: {'result':'ok'/'last_card'/'error', 'card': ['3', 'spades']}
'''
msg = {'cmd' : 'draw'}
res = self.cardServer.cmd(msg)
if res["result"] == "ok":
self.hand.addCardFromRes(res)
self.eventQueue.addNewEvent(EventType.YOUR_TURN)
return
elif res["result"] == "last_card":
print "Got Last Card"
self.hand.addCardFromRes(res)
self.noCardOnTable = True
self.eventQueue.addNewEvent(EventType.OFFER_HAND)
pass
elif res["result"] == "error":
print "got error from server"
else:
eventData = {"msg" : "Error: Got invalid response from server while trying to draw card, Exiting", "fatal" : True}
self.eventQueue.addNewEvent(EventType.ERROR, eventData)
return
@debugPrint
def discardPair(self, event):
'''
send: {'cmd':'discard', 'cards': [['3', 'spades'], ['3', 'clubs']], 'last_cards':'true'/'false'}
recv: {'result': 'ok'/'error', 'message':'ok'/error_message}
'''
pair = self.hand.removeNextPair()
print "Starting to discard pair", pair, "to cardServer"
lastCardOnHand = self.hand.lastCard()
if lastCardOnHand == True and self.noCardOnTable == True:
print "Discarded last card on hand, I am out"
self.players.out = True
self.outOfCards(None)
sys.exit()
else:
# Can't exit game if there are more cards that could be drawn from table
lastCardOnHand = False
cmd = {"cmd" : "discard", "cards" : pair, "last_card" : lastCardOnHand}
res = self.cardServer.cmd(cmd)
if res["result"] == "ok":
print "Discarded pair to server successfully"
elif res["result"] == "error":
print "got error:", res["message"]
@debugPrint
def outOfCards(self, event):
'''
send: {'cmd':'out_of_cards'}
recv: {'result':'ok'}
'''
self.players.out = True
cmd = {"cmd" : "out_of_cards"}
res = self.cardServer.cmd(cmd)
print "I am out of cards:", res
@debugPrint
def getStatus(self):
'''
send: {'cmd':'status'}
recv: {'in':['player1', 'player2', ...], 'out':{'player3'}}
'''
cmd = {"cmd" : "status"}
res = self.cardServer.cmd(cmd)
if res.has_key("out"):
self.players.setOutFromStatus(res)
#Client methods
@debugPrint
def yourTurn(self, Event):
'''
send: {'cmd':'your_turn'}
recv: {'result':'ok'}
'''
cmd = {"cmd" : "your_turn"}
res = self.leftHand.cmd(cmd)
if res["result"] == "ok":
print "End of turn, sent yourTurn to next player"
@debugPrint
def offerHand(self, event):
'''
send: {'cmd':'offer', 'num_cards':number of cards left}
recv: {'result':'ok'/'out'}
'''
count = self.hand.count()
self.noCardOnTable = True
lastCardOnHand = self.hand.lastCard()
if lastCardOnHand == True:
print "Discarded last card on hand, I am out"
self.players.out = True
self.outOfCards(None)
cmd = {"cmd" : "offer", "num_cards" : count}
self.getStatus()
for x in range(self.players.numPlayers):
res = self.leftHand.cmd(cmd)
if res.has_key("result"):
if res["result"] == "ok":
if count > 0:
self.pickCard(self.leftHand.receive(1024))
break;
elif res["result"] == "out":
outAddr = self.leftHand.getConnectionAddr()
self.getStatus()
self.players.setOutFromAddr(outAddr)
self.leftHand.close()
for x in range(self.players.numPlayers):
if self.players.getNextLeftPlayerAddr() == -1:
print "GAME OVER"
sys.exit()
return
else:
self.leftHand = LeftHand(self.eventQueue, self.players)
print "\n\n\n\n\n SUCCEFULL RECONNECTION \n\n\n\n\n\n"
self.leftHand.connect()
break
@debugPrint
def pickCard(self, res):
'''
send: {'cmd':'pick', 'card_num': the number of the card chosen (must be between 0 and
number_of_cards_left offered}
recv: {'result':'ok'/'error', 'card':['3', 'spades']}
'''
res = json.loads(res)
if res.has_key("cmd"):
if res["cmd"] == "pick":
card = self.hand.pickCard(res['card_num'])
msg = {"result" : "ok", "card" : card}
msg = json.dumps(msg)
self.leftHand.send(msg)
lastCardOnHand = self.hand.lastCard()
if lastCardOnHand == True:
print "Discarded last card on hand, I am out"
self.players.out = True
self.outOfCards(None)
# The game state is what every player can know at any given moment
game_state = Gamestate(players=players)
# Let's hand out the cards for that game
deck = Deck()
deck.shuffle()
for player in game_state.players.values():
player.get_karten(deck.getKarten())
print(
"%s: %s "
% (player.name, ", ".join([str(card) for card in player.karten]))
)
# Ok, let's play the game
play(game_state=game_state)
return game_state.winner
# Driver code
names = ["Hans", "Sepp", "Domi", "Brucki"]
random.shuffle(names)
players = {}
for i in range(4):
players[i] = Players(i, names.pop())
winner = main(players=players)
print(f"{players[winner[0]].name} und {players[winner[1]].name} haben gewonnen")
"shot_damage": SHOT_DAMAGE,
"lives": LIVES,
"respawn": 30,
"fire_rate": FIRE_RATE,
"mode": MODE,
"points_per_hit": POINTS_PER_HIT,
"points_per_kill": POINTS_PER_KILL
}
aws_client = AWS(
"server", "a213qaaw8pshxz.iot.us-east-1.amazonaws.com",
"/home/steve/Desktop/AWS_Certs/RootCA",
"/home/steve/Desktop/AWS_Certs/fc21dd6d85-private.pem.key",
"/home/steve/Desktop/AWS_Certs/fc21dd6d85-certificate.pem.crt")
Game_Players = Players()
def json_clean(jsonMessage):
if jsonMessage.endswith('\x00'):
return jsonMessage[:-1]
else:
return jsonMessage
def register_player(client, userdata, message):
message.payload = json_clean(message.payload)
jsonMessage = json.loads(message.payload)
player_name = jsonMessage["player_name"].encode("ascii")
if player_name in Game_Players.players:
print("Player " + player_name + " already registered")
