class Player:
IN_STATE = "IN"
FOLD_STATE = "FOLD"
ALL_IN_STATE = "ALL IN"
CALL_ACTION = "CALL"
RAISE_ACTION = "RAISE"
CHECK_ACTION = "CHECK"
BET_ACTION = "BET"
def __init__(self, slack_id, slack_client):
self.slack_id = slack_id
self.money = 200
self.cards = []
self.state = Player.IN_STATE
self.action = ''
self.bet = 0
self.slack_client = slack_client
self.chat = Chat(
slack_client,
Player.get_im_channel(self.slack_client, self.slack_id))
@staticmethod
def get_im_channel(slack_client, slack_id):
ims = json.loads(slack_client.api_call('im.list'))['ims']
for im in ims:
if im['user'] == slack_id:
return im['id']
print str(ims)
raise "IM Channel not found!"
def get_username(self):
user_api = json.loads(
self.slack_client.api_call('users.info',
user=self.slack_id))['user']
return user_api['name']
def card_str(self):
return '{}, {}'.format(Card.int_to_pretty_str(self.cards[0]),
Card.int_to_pretty_str(self.cards[1]))
def deal(self, cards):
self.bet = 0
self.cards = cards
self.state = Player.IN_STATE
self.chat.message('Your hand: {}'.format(self.card_str()))
def __hash__(self):
return hash(self.slack_id)
def __eq__(self, other):
try:
return hash(self) == hash(other)
except:
return False
def __str__(self):
return self.get_username()
class Player:
IN_STATE = "IN"
FOLD_STATE = "FOLD"
ALL_IN_STATE = "ALL IN"
CALL_ACTION = "CALL"
RAISE_ACTION = "RAISE"
CHECK_ACTION = "CHECK"
BET_ACTION = "BET"
def __init__(self, slack_id, slack_client):
self.slack_id = slack_id
self.money = 200
self.cards = []
self.state = Player.IN_STATE
self.action = ''
self.bet = 0
self.slack_client = slack_client
self.chat = Chat(slack_client, Player.get_im_channel(self.slack_client, self.slack_id))
@staticmethod
def get_im_channel(slack_client, slack_id):
ims = json.loads(slack_client.api_call('im.list'))['ims']
for im in ims:
if im['user'] == slack_id:
return im['id']
print str(ims)
raise "IM Channel not found!"
def get_username(self):
user_api = json.loads(self.slack_client.api_call('users.info', user=self.slack_id))['user']
return user_api['name']
def card_str(self):
return '{}, {}'.format(Card.int_to_pretty_str(self.cards[0]), Card.int_to_pretty_str(self.cards[1]))
def deal(self, cards):
self.bet = 0
self.cards = cards
self.state = Player.IN_STATE
self.chat.message('Your hand: {}'.format(self.card_str()))
def __hash__(self):
return hash(self.slack_id)
def __eq__(self, other):
try:
return hash(self) == hash(other)
except:
return False
def __str__(self):
return self.get_username()
class JoinManager:
def __init__(self, slack_client, channel, players):
self.last_message = None
self.slack_client = slack_client
self.channel = channel
self.players = players
self.chat = Chat(slack_client, channel)
print str(channel)
def process_message(self, data):
if 'text' in data and data['text'].lower() == 'yes':
player = Player(data['user'], self.slack_client)
if player not in self.players:
self.players.append(player)
self.chat.message(join_message.format(data['user']))
def tick(self, timer):
self.last_message = self.chat.message(start_message.format(timer),
self.last_message)
class Game:
def __init__(self, slack_client):
self.state = DEAD_STATE
self.timer = WAIT
self.players = []
self.deck = None
self.current_player = 0
self.pot_manager = None
self.slack_client = slack_client
self.join_manager = None
self.chat = None
self.dealer_id = 0
self.bet_manager = None
self.board = []
self.evaluator = Evaluator()
self.last_message = None
self.board_message = None
def start(self, channel):
self.state = START_STATE
self.timer = WAIT
self.players = []
self.deck = Deck()
self.current_player = 0
self.chat = Chat(self.slack_client, channel)
self.pot_manager = PotManager(self.chat)
self.join_manager = JoinManager(self.slack_client, channel, self.players)
self.bet_manager = BetManager(self.pot_manager, self.players)
self.board = []
self.last_message = None
self.board_message = None
def process(self, data):
if 'text' in data:
text = data['text']
quit_text = '{}: quit'.format(bot_name)
if quit_text.lower() in text.lower():
if PAUSE_BETWEEN_GAME_STATE == self.state:
player_to_remove = None
for player in self.players:
if player.slack_id == data['user']:
player_to_remove = player
self.players.remove(player_to_remove)
self.chat.message("{} has quit.".format(player_to_remove))
else:
self.chat.message("You can't quit now, wait between games.")
if DEAD_STATE == self.state:
self.process_dead(data)
if START_STATE == self.state:
self.process_start(data)
if BET_STATE == self.state:
self.bet_manager.process(data)
def process_dead(self, data):
text = data['text']
deal_text = '{}: deal'.format(bot_name)
if deal_text.lower() in text.lower():
self.start(data['channel'])
def process_start(self, data):
self.join_manager.process_message(data)
def set_state(self, state):
self.state = state
self.timer = WAIT
self.last_message = None
self.board_message = None
def enough_players(self):
if len(self.players) < 2:
self.chat.message("Not enough players.")
self.set_state(DEAD_STATE)
return False
return True
def deal_state(self):
self.current_player = 0
if not self.enough_players():
return
# burn card
self.deck.draw(1)
for player in self.players:
player.deal(self.deck.draw(2))
self.set_state(BLIND_STATE)
def post_blind(self, blind_func):
while True:
player = self.players[self.current_player % len(self.players)]
can_post = blind_func(player)
if not can_post:
self.players.pop(0)
if not self.enough_players():
return False
self.current_player += 1
return True
def blind_state(self):
if not self.post_blind(self.pot_manager.post_small_blind):
return
if not self.post_blind(self.pot_manager.post_big_blind):
return
self.pot_manager.add_other_players(self.players)
self.dealer_id = self.current_player
self.display_board()
flop_callback = partial(self.set_state, FLOP_STATE)
fold_win_callback = partial(self.set_state, FOLD_WIN_STATE)
self.bet_manager.request_bets(self.dealer_id, flop_callback, fold_win_callback, self.display_board)
self.set_state(BET_STATE)
def display_board(self):
board_str = '```'
for i, player in enumerate(self.players):
if i == self.current_player % len(self.players):
board_str += '->'
else:
board_str += ' '
board_str += '<@{}>\t\t\t${}\t{}\t{} {}\n'.format(player.slack_id,
player.money,
player.state,
player.action,
player.bet)
board_str += '```\n'
board_str += self.pot_manager.get_pot_string()
board_str += "\n{}".format(Game.board_to_string(self.board))
self.board_message = self.chat.message(board_str, self.board_message)
@staticmethod
def board_to_string(board):
result = ""
for card in board:
result += "{} ".format(Card.int_to_pretty_str(card))
return result
def flop_state(self):
# burn card
self.deck.draw(1)
self.board.extend(self.deck.draw(3))
self.chat.message("*Dealing the flop:*\n{}".format(Game.board_to_string(self.board)))
turn_callback = partial(self.set_state, TURN_STATE)
fold_win_callback = partial(self.set_state, FOLD_WIN_STATE)
self.bet_manager.request_bets(0, turn_callback, fold_win_callback, self.display_board)
self.set_state(BET_STATE)
def turn_state(self):
# burn card
self.deck.draw(1)
self.board.append(self.deck.draw(1))
self.chat.message("*Dealing the turn:*\n{}".format(Game.board_to_string(self.board)))
turn_callback = partial(self.set_state, RIVER_STATE)
fold_win_callback = partial(self.set_state, FOLD_WIN_STATE)
self.bet_manager.request_bets(0, turn_callback, fold_win_callback, self.display_board)
self.set_state(BET_STATE)
def river_state(self):
# burn card
self.deck.draw(1)
self.board.append(self.deck.draw(1))
self.chat.message("*Dealing the river:*\n{}".format(Game.board_to_string(self.board)))
self.set_state(SHOW_HANDS_STATE)
def count_down(self, new_state):
self.timer -= 1
if self.timer < 0:
self.set_state(new_state)
return
def show_hands_state(self):
for player in self.players:
if player.state == Player.FOLD_STATE:
continue
card_score = self.evaluator.evaluate(self.board, player.cards)
card_class = self.evaluator.get_rank_class(card_score)
self.chat.message('{} had: {} {}'.format(player, player.card_str(), card_class))
self.set_state(DETERMINE_WINNER_STATE)
def determine_winner_state(self):
for pot in reversed(self.pot_manager.pots):
pot_score = 9999
pot_winners = []
if len(pot.players) == 1:
self.chat.message(SINGLE_WINNER_MESSAGE.format(pot.players[0], pot.amount, pot.name))
pot.players[0].money += pot.amount
else:
for player in pot.players:
card_score = self.evaluator.evaluate(self.board, player.cards)
if card_score == pot_score:
pot_winners.append(player)
if card_score < pot_score:
pot_winners = [player]
pot_score = card_score
if len(pot_winners) == 1:
self.chat.message(SINGLE_WINNER_MESSAGE.format(pot_winners[0], pot.amount, pot.name))
pot_winners[0].money += pot.amount
else:
self.chat.message(SPLIT_WINNER_MESSAGE.format(pot_winners, pot.amount, pot.name))
for pot_winner in pot_winners:
pot_winner.money += (pot.amount / len(pot_winners))
self.set_state(PREPARE_NEW_GAME_STATE)
def prepare_new_game_state(self):
# rotate players
self.players.append(self.players.pop(0))
self.set_state(PAUSE_BETWEEN_GAME_STATE)
def pause_between_game_state(self):
self.last_message = self.chat.message(PAUSE_MESSAGE.format(self.timer), self.last_message)
self.timer = NEW_GAME_WAIT
self.count_down(DEAL_STATE)
def tick(self):
if START_STATE == self.state:
self.join_manager.tick(self.timer)
self.count_down(DEAL_STATE)
if DEAL_STATE == self.state:
self.deal_state()
if BLIND_STATE == self.state:
self.blind_state()
if BET_STATE == self.state:
self.bet_manager.tick()
if FLOP_STATE == self.state:
self.flop_state()
if TURN_STATE == self.state:
self.turn_state()
if RIVER_STATE == self.state:
self.river_state()
if FOLD_WIN_STATE == self.state:
self.set_state(DETERMINE_WINNER_STATE)
if SHOW_HANDS_STATE == self.state:
self.show_hands_state()
if DETERMINE_WINNER_STATE == self.state:
self.determine_winner_state()
if PREPARE_NEW_GAME_STATE == self.state:
self.prepare_new_game_state()
if PAUSE_BETWEEN_GAME_STATE == self.state:
self.pause_between_game_state()
class Game:
def __init__(self, slack_client):
self.state = DEAD_STATE
self.timer = WAIT
self.players = []
self.deck = None
self.current_player = 0
self.pot_manager = None
self.slack_client = slack_client
self.join_manager = None
self.chat = None
self.dealer_id = 0
self.bet_manager = None
self.board = []
self.evaluator = Evaluator()
self.last_message = None
self.board_message = None
def start(self, channel):
self.state = START_STATE
self.timer = WAIT
self.players = []
self.deck = Deck()
self.current_player = 0
self.chat = Chat(self.slack_client, channel)
self.pot_manager = PotManager(self.chat)
self.join_manager = JoinManager(self.slack_client, channel,
self.players)
self.bet_manager = BetManager(self.pot_manager, self.players)
self.board = []
self.last_message = None
self.board_message = None
def process(self, data):
if 'text' in data:
text = data['text']
quit_text = '{}: quit'.format(bot_name)
if quit_text.lower() in text.lower():
if PAUSE_BETWEEN_GAME_STATE == self.state:
player_to_remove = None
for player in self.players:
if player.slack_id == data['user']:
player_to_remove = player
self.players.remove(player_to_remove)
self.chat.message("{} has quit.".format(player_to_remove))
else:
self.chat.message(
"You can't quit now, wait between games.")
if DEAD_STATE == self.state:
self.process_dead(data)
if START_STATE == self.state:
self.process_start(data)
if BET_STATE == self.state:
self.bet_manager.process(data)
def process_dead(self, data):
text = data['text']
deal_text = '{}: deal'.format(bot_name)
if deal_text.lower() in text.lower():
self.start(data['channel'])
def process_start(self, data):
self.join_manager.process_message(data)
def set_state(self, state):
self.state = state
self.timer = WAIT
self.last_message = None
self.board_message = None
def enough_players(self):
if len(self.players) < 2:
self.chat.message("Not enough players.")
self.set_state(DEAD_STATE)
return False
return True
def deal_state(self):
self.current_player = 0
if not self.enough_players():
return
# burn card
self.deck.draw(1)
for player in self.players:
player.deal(self.deck.draw(2))
self.set_state(BLIND_STATE)
def post_blind(self, blind_func):
while True:
player = self.players[self.current_player % len(self.players)]
can_post = blind_func(player)
if not can_post:
self.players.pop(0)
if not self.enough_players():
return False
self.current_player += 1
return True
def blind_state(self):
if not self.post_blind(self.pot_manager.post_small_blind):
return
if not self.post_blind(self.pot_manager.post_big_blind):
return
self.pot_manager.add_other_players(self.players)
self.dealer_id = self.current_player
self.display_board()
flop_callback = partial(self.set_state, FLOP_STATE)
fold_win_callback = partial(self.set_state, FOLD_WIN_STATE)
self.bet_manager.request_bets(self.dealer_id, flop_callback,
fold_win_callback, self.display_board)
self.set_state(BET_STATE)
def display_board(self):
board_str = '```'
for i, player in enumerate(self.players):
if i == self.current_player % len(self.players):
board_str += '->'
else:
board_str += ' '
board_str += '<@{}>\t\t\t${}\t{}\t{} {}\n'.format(
player.slack_id, player.money, player.state, player.action,
player.bet)
board_str += '```\n'
board_str += self.pot_manager.get_pot_string()
board_str += "\n{}".format(Game.board_to_string(self.board))
self.board_message = self.chat.message(board_str, self.board_message)
@staticmethod
def board_to_string(board):
result = ""
for card in board:
result += "{} ".format(Card.int_to_pretty_str(card))
return result
def flop_state(self):
# burn card
self.deck.draw(1)
self.board.extend(self.deck.draw(3))
self.chat.message("*Dealing the flop:*\n{}".format(
Game.board_to_string(self.board)))
turn_callback = partial(self.set_state, TURN_STATE)
fold_win_callback = partial(self.set_state, FOLD_WIN_STATE)
self.bet_manager.request_bets(0, turn_callback, fold_win_callback,
self.display_board)
self.set_state(BET_STATE)
def turn_state(self):
# burn card
self.deck.draw(1)
self.board.append(self.deck.draw(1))
self.chat.message("*Dealing the turn:*\n{}".format(
Game.board_to_string(self.board)))
turn_callback = partial(self.set_state, RIVER_STATE)
fold_win_callback = partial(self.set_state, FOLD_WIN_STATE)
self.bet_manager.request_bets(0, turn_callback, fold_win_callback,
self.display_board)
self.set_state(BET_STATE)
def river_state(self):
# burn card
self.deck.draw(1)
self.board.append(self.deck.draw(1))
self.chat.message("*Dealing the river:*\n{}".format(
Game.board_to_string(self.board)))
self.set_state(SHOW_HANDS_STATE)
def count_down(self, new_state):
self.timer -= 1
if self.timer < 0:
self.set_state(new_state)
return
def show_hands_state(self):
for player in self.players:
if player.state == Player.FOLD_STATE:
continue
card_score = self.evaluator.evaluate(self.board, player.cards)
card_class = self.evaluator.get_rank_class(card_score)
self.chat.message('{} had: {} {}'.format(player, player.card_str(),
card_class))
self.set_state(DETERMINE_WINNER_STATE)
def determine_winner_state(self):
for pot in reversed(self.pot_manager.pots):
pot_score = 9999
pot_winners = []
if len(pot.players) == 1:
self.chat.message(
SINGLE_WINNER_MESSAGE.format(pot.players[0], pot.amount,
pot.name))
pot.players[0].money += pot.amount
else:
for player in pot.players:
card_score = self.evaluator.evaluate(
self.board, player.cards)
if card_score == pot_score:
pot_winners.append(player)
if card_score < pot_score:
pot_winners = [player]
pot_score = card_score
if len(pot_winners) == 1:
self.chat.message(
SINGLE_WINNER_MESSAGE.format(pot_winners[0],
pot.amount, pot.name))
pot_winners[0].money += pot.amount
else:
self.chat.message(
SPLIT_WINNER_MESSAGE.format(pot_winners, pot.amount,
pot.name))
for pot_winner in pot_winners:
pot_winner.money += (pot.amount / len(pot_winners))
self.set_state(PREPARE_NEW_GAME_STATE)
def prepare_new_game_state(self):
# rotate players
self.players.append(self.players.pop(0))
self.set_state(PAUSE_BETWEEN_GAME_STATE)
def pause_between_game_state(self):
self.last_message = self.chat.message(PAUSE_MESSAGE.format(self.timer),
self.last_message)
self.timer = NEW_GAME_WAIT
self.count_down(DEAL_STATE)
def tick(self):
if START_STATE == self.state:
self.join_manager.tick(self.timer)
self.count_down(DEAL_STATE)
if DEAL_STATE == self.state:
self.deal_state()
if BLIND_STATE == self.state:
self.blind_state()
if BET_STATE == self.state:
self.bet_manager.tick()
if FLOP_STATE == self.state:
self.flop_state()
if TURN_STATE == self.state:
self.turn_state()
if RIVER_STATE == self.state:
self.river_state()
if FOLD_WIN_STATE == self.state:
self.set_state(DETERMINE_WINNER_STATE)
if SHOW_HANDS_STATE == self.state:
self.show_hands_state()
if DETERMINE_WINNER_STATE == self.state:
self.determine_winner_state()
if PREPARE_NEW_GAME_STATE == self.state:
self.prepare_new_game_state()
if PAUSE_BETWEEN_GAME_STATE == self.state:
self.pause_between_game_state()
def threaded_client(conn, player_no):
player_no -= 1
players[player_no].stealing_from = [
0 for i in range(steals[player_no].numberofstealtokens)
]
players[player_no].fertility_orientation = fertility_orientation
players[player_no].datetime = datetime.now()
tell_the_officer_data_store_punishment = [
'NA' for i in range(steals[0].numberofdefencetokens)
]
conn.send(
pickle.dumps(
(draganddrops[player_no], players[player_no], steals[player_no],
chats[player_no], trades[player_no], waits[player_no])))
round_change_flag = {
'0': {
'drag': 0,
'chat': 0,
'steal': 0,
'trade': 0,
'player': 0
},
'1': {
'drag': 0,
'chat': 0,
'steal': 0,
'trade': 0,
'player': 0
},
'2': {
'drag': 0,
'chat': 0,
'steal': 0,
'trade': 0,
'player': 0
},
'3': {
'drag': 0,
'chat': 0,
'steal': 0,
'trade': 0,
'player': 0
},
'4': {
'drag': 0,
'chat': 0,
'steal': 0,
'trade': 0,
'player': 0
},
'5': {
'drag': 0,
'chat': 0,
'steal': 0,
'trade': 0,
'player': 0
},
}
#conn.send(pickle.dumps())
while True:
# for S in all_steals:
# if S[2]:
# victims[S[2] - 1] = 1
# for i in range(victims):
# players[i].being_stolen_from = victims[i]
steals[player_no].ranking = ranking()
data_type = pickle.loads(conn.recv(3 * 4096))
if chats[player_no].selected_recipient == 0:
# print("I am sending 0 because chats" + str(player_no) + "=" + str(chats[player_no].selected_recipient))
conn.send(pickle.dumps((data_type + " active", chat_lists["0"])))
else:
if chats[player_no].selected_recipient < players[player_no].id:
# print("I am sending ", str(chats[player_no].selected_recipient) + str(player.id))
conn.send(
pickle.dumps(
(data_type + " active",
chat_lists[str(chats[player_no].selected_recipient) +
str(player.id)])))
else:
# print("I am sending ", str(player.id) + str(chats[player_no].selected_recipient))
conn.send(
pickle.dumps((
data_type + " active",
chat_lists[str(player.id) +
str(chats[player_no].selected_recipient)])))
if data_type == "wait_class":
wait, player = pickle.loads(conn.recv(3 * 4096))
global was_round_number_updated
# player.experiment_start_time = players[player_no].experiment_start_time
# print("wait player grain", player.resources['Grain'])
wait.start_time = waits[player_no].start_time
wait.end_time = waits[player_no].end_time
wait.started = waits[player_no].started
sum_of_ready = int()
# print(player_no, "wait.ready", wait.ready, "wait.started", wait.started)
if wait.ready and not wait.started:
waits[player_no].ready = wait.ready
sum_of_ready = 0
for i in range(6):
sum_of_ready += waits[i].ready
if sum_of_ready >= 2:
print("Because sum_of_ready was ", sum_of_ready,
"we could now start says player", player_no,
". Look what waits[i].ready looks like.", "A",
waits[0].ready, "B", waits[1].ready, "C", waits[2].ready,
"D", waits[3].ready, "E", waits[4].ready, "F",
waits[5].ready)
wait.started = 1
if was_round_number_updated == False:
round_constants['round_number'] += 1
was_round_number_updated = True
wait.round_number = round_constants['round_number']
waits[player_no].round_number = round_constants['round_number']
for i in range(6):
waits[i].start_time = datetime.now() + timedelta(seconds=5)
waits[i].end_time = waits[i].start_time + timedelta(
seconds=round_constants['round_time'])
waits[i].ready = 0
waits[i].started = wait.started
round_change_flag[str(i)] = {
'drag': 1,
'chat': 1,
'steal': 1,
'trade': 1,
'player': 1
}
players[i] = Player(i + 1)
steals[i] = Steal(i + 1)
if round_constants['round_number'] == 1:
players[i].experiment_start_time = wait.start_time
player.experiment_start_time = wait.start_time
print("expt start time was updated for player no",
player_no, "and the value was ",
player.experiment_start_time)
print(player.experiment_start_time)
if i == 0:
players[i].type = 2
print(steals[0].numberofdefencetokens)
players[i].enforcer_number_of_defence_tokens = steals[
0].numberofdefencetokens
players[player_no].stealing_from = [
0 for i in range(steals[player_no].numberofstealtokens)
]
players[
player_no].fertility_orientation = fertility_orientation
if fertility_orientation == 'EI':
if round_constants['round_number'] >= 5:
players[i].fertility = players[i].id * 10
players[i].fertility = players[i].id * 10
elif fertility_orientation == 'IE':
if round_constants['round_number'] <= 4:
players[i].fertility = players[i].id * 10
players[i].fertility = players[i].id * 10
if datetime.now() > wait.start_time and datetime.now(
) < wait.end_time:
for i in range(6):
waits[i].started = 0
player.datetime = datetime.now()
print("player", player_no, "thinks that round number is",
round_constants['round_number'])
conn.send(pickle.dumps((wait, player)))
if data_type == "chat_classs":
chat, player = pickle.loads(conn.recv(3 * 4096))
# print("round_change_flag on chat", round_change_flag[str(player_no)], player_no)
if round_change_flag[str(player_no)]['chat']:
chat = Chat()
chats[player_no] = Chat()
round_change_flag[str(player_no)]['chat'] = 0
# if round_change_flag[str(player_no)]['player']:
# player = Player(player_no+1)
# players[player_no] = Player(player_no+1)
# # print("special chat player grain", player.resources['Grain'], "player number is", player_no)
# # print("special chat player grain", players[player_no].resources['Grain'], "player number is", player_no)
# if fertility_orientation == 'EI':
# if round_constants['round_number'] >= 5:
# player.fertility = player.id * 10
# players[player_no].fertility = player.id * 10
# elif fertility_orientation == 'IE':
# if round_constants['round_number'] <=4:
# player.fertility = player.id * 10
# players[player_no].fertility = player.id * 10
# round_change_flag[str(player_no)]['player'] = 0
global new_chat_row
if chat.message != '':
if chat.selected_recipient == 0:
chat_lists['0'].append(
[str(datetime.now()), player.id, chat.message])
else:
if chat.selected_recipient < player.id:
chat_lists[str(chat.selected_recipient) +
str(player.id)].append([
str(datetime.now()), player.id,
chat.message
])
else:
chat_lists[str(player.id) +
str(chat.selected_recipient)].append([
str(datetime.now()), player.id,
chat.message
])
new_chat_row = [
str(datetime.now()), player.id, chat.selected_recipient,
chat.message
]
chat.message = ''
chats[player_no] = chat
player.datetime = datetime.now()
conn.send(pickle.dumps((chat, player)))
if data_type == "trade_classs":
response_message = ''
trade, player = pickle.loads(conn.recv(3 * 4096))
# print("round_change_flag on trade", round_change_flag[str(player_no)], player_no)
if round_change_flag[str(player_no)]['trade']:
trade = Trade(player_no)
trades[player_no] = Trade(player_no)
round_change_flag[str(player_no)]['trade'] = 0
# if round_change_flag[str(player_no)]['player']:
# player = Player(player_no+1)
# players[player_no] = Player(player_no+1)
# # print("special trade player grain", player.resources['Grain'], "player number is", player_no)
# # print("special trade player grain", players[player_no].resources['Grain'], "player number is", player_no)
# if fertility_orientation == 'EI':
# if round_constants['round_number'] >= 5:
# player.fertility = player.id * 10
# players[player_no].fertility = player.id * 10
# elif fertility_orientation == 'IE':
# if round_constants['round_number'] <=4:
# player.fertility = player.id * 10
# players[player_no].fertility = player.id * 10
# round_change_flag[str(player_no)]['player'] = 0
if not trade:
print("disconnected")
break
elif trade.trade_initiated:
print("Player number ", player_no, "is trying to send ",
trade.TryToTrade[0] - 1, ", ", trade.TryToTrade[1],
" of quantity ", trade.TryToTrade[2])
trade.trade_initiated = False
if player.resources[
trade.TryToTrade[1]] >= trade.TryToTrade[2]:
player.resources[
trade.TryToTrade[1]] -= trade.TryToTrade[2]
players[trade.TryToTrade[0] - 1].resources[
trade.TryToTrade[1]] += trade.TryToTrade[2]
players[player.id - 1] = player
trades_list.append([
str(datetime.now()), player.id, trade.TryToTrade[0],
trade.TryToTrade[1], trade.TryToTrade[2]
])
print(trades_list)
response_message = "Success!!"
else:
response_message = "You have insufficient " + str(
trade.TryToTrade[1]) + "."
if trade.buysell[0] > 0:
if players[player_no].resources[
"Grain"] >= trade.buysell[0] * trade.stealtokenbuycost:
steals[player_no].numberofstealtokens += trade.buysell[0]
players[player_no].resource_change -= trade.buysell[
0] * trade.stealtokenbuycost
trade.buysell[0] = 0
elif trade.buysell[0] < 0:
steals[player_no].numberofstealtokens += trade.buysell[0]
players[player_no].resource_change -= trade.buysell[
0] * trade.stealtokensellcost
trade.buysell[0] = 0
if trade.buysell[1] > 0:
if player.resources["Grain"] >= trade.buysell[
1] * trade.defencetokenbuycost:
steals[player_no].numberofdefencetokens += trade.buysell[1]
players[player_no].resource_change -= trade.buysell[
1] * trade.defencetokenbuycost
trade.buysell[1] = 0
elif trade.buysell[1] < 0:
steals[player_no].numberofdefencetokens += trade.buysell[1]
players[player_no].resource_change -= trade.buysell[
1] * trade.defencetokensellcost
trade.buysell[1] = 0
player.resources['Grain'] += players[player_no].resource_change
players[player_no].resource_change = 0
conn.send(pickle.dumps((trade, player, response_message)))
if data_type == "drag_class":
draganddrop, player = pickle.loads(conn.recv(3 * 4096))
if was_round_number_updated:
was_round_number_updated = False
# if player_no == 1:
# print("round_change_flag on drag class", round_change_flag[str(player_no)], player_no)
if round_change_flag[str(player_no)]['drag']:
draganddrop = DragDrop()
draganddrops[player_no] = DragDrop()
round_change_flag[str(player_no)]['drag'] = 0
# player = Player(player_no+1)
# players[player_no] = Player(player_no+1)
# # if player_no == 1:
# # print("special drag player grain", player.resources['Grain'], "player number is", player_no)
# # print("special drag player grain", players[player_no].resources['Grain'], "player number is", player_no)
# if fertility_orientation == 'EI':
# if round_constants['round_number'] >= 5:
# player.fertility = player.id * 10
# players[player_no].fertility = player.id * 10
# elif fertility_orientation == 'IE':
# if round_constants['round_number'] <=4:
# player.fertility = player.id * 10
# players[player_no].fertility = player.id * 10
# round_change_flag[str(player_no)]['player'] = 0
# print("drag player grain", player.resources['Grain'], "for player_no", player_no)
# print("player.fertility of", player_no, "is", player.fertility)
try:
draganddrop.log_last_message = [
str(police_log[-1][0]),
str(police_log[-1][1]),
str(police_log[-1][2])
]
except:
draganddrop.log_last_message = []
player.resources["Grain"] = players[player_no].resources["Grain"]
#print(draganddrop.score)
if not draganddrop:
print("disconnected")
break
else:
if draganddrop.stage == 5:
players[player_no].resource_change += player.fertility
draganddrop.stage = 0
draganddrop.score = [0, 0, 0, 0, 0]
players[player_no].resources["Grain"] = max(
0, player.resources['Grain'] +
players[player_no].resource_change)
player.resources['Grain'] = max(
0, player.resources['Grain'] +
players[player_no].resource_change)
players[player_no].resource_change = 0
player.datetime = datetime.now()
conn.send(pickle.dumps((draganddrop, player)))
if data_type == "steal_class":
steal, player = pickle.loads(conn.recv(100 * 4096))
if round_change_flag[str(player_no)]['steal']:
steal = Steal(player.id)
steals[player_no] = Steal(player.id)
steals[player_no].ranking = ranking()
round_change_flag[str(player_no)]['steal'] = 0
# if round_change_flag[str(player_no)]['player']:
# player = Player(player_no+1)
# players[player_no] = Player(player_no+1)
# # if player_no == 1:
# # print("special steal player grain", player.resources['Grain'], "player number is", player_no)
# # print("special steal player grain", players[player_no].resources['Grain'], "player number is", player_no)
# if fertility_orientation == 'EI':
# if round_constants['round_number'] >= 5:
# player.fertility = player.id * 10
# players[player_no].fertility = player.id * 10
# elif fertility_orientation == 'IE':
# if round_constants['round_number'] <=4:
# player.fertility = player.id * 10
# players[player_no].fertility = player.id * 10
#
# round_change_flag[str(player_no)]['player'] = 0
player.update_stealing_from_count(steal.numberofstealtokens -
len(player.stealing_from))
global updater, tokens_allocated
for update in updater:
try:
if update[0] == player.id:
steal.initialize_steal_token(update[1],
"myserver place 1")
update[0] = 0
except:
pass
updater = [i for i in updater if i[0] != 0]
if player.type == 2:
tokens_allocated = len(
steal.recPunishment.collidelistall(steal.recDefenceTokens))
steal.ranking = steals[player_no].ranking
players[player_no].resources["Grain"] = max(
0,
player.resources['Grain'] + players[player_no].resource_change)
player.resources['Grain'] = max(
0,
player.resources['Grain'] + players[player_no].resource_change)
players[player_no].resource_change = 0
if not steal:
print("disconnected")
break
else:
for i in range(steal.numberofstealtokens):
if player.stealing_from[i]:
#print("reached first if")
if steal.stealoclock[i]:
#print("reached 2 if")
# if players[player.stealing_from[i]-1].connected:
#print(player.stealing_from[i]-1)
#print("reached 3 if")
if players[player.stealing_from[i] -
1].resources["Grain"]:
players[
player_no].resource_change += player.stealing_amount_per_30th_of_a_second
players[
player.stealing_from[i] -
1].resource_change -= player.stealing_amount_per_30th_of_a_second
# else:
# steal.initialize_steal_token(i, "myserver place 2")
# print("player "+ str(player.id) +" has ", str(player.resources["Grain"]) + ". He is stealing from player " + str(player.stealing_from[i]) + ". Victim now has "+ str(players[player.stealing_from[i]-1].resources["Grain"]))
steal.stealoclock[i] = 0
all_defences[player.id] = [
pygame.rect.Rect(i[0], i[1], steal.defencetokensize[0],
steal.defencetokensize[1])
for i in steal.defence_coordinates
if i != steal.defencetokenstartcoordinates
]
all_steals[player.id] = [
(i[0], i[1],
player.stealing_from[steal.steal_coordinates.index(i)])
for i in steal.steal_coordinates
]
# print(all_steals, updater)
if steal.detectoclockD:
print("D=", steal.detectoclockD)
steal.detectoclockD = 0
for j in all_steals.keys(): # see all players steal tokens
if j != player.id: # except the players own
for stoken_no, stoken in enumerate(
all_steals[j]
): # in which steal token number = stoken_no and stoken is the steal token itself
for defence_no, defence in enumerate(
all_defences[
player.id]): # get players own
if defence.collidepoint(
(stoken[0], stoken[1])):
print("player ", j,
"was found stealing from",
stoken[2])
# print(stoken_no)
punished = punishment(j, stoken[2], 1)
print("punished up", punished)
players[punished -
1].resource_change -= 17
players[0].resource_change += 25
if punished != j:
if np.random.randint(
low=1, high=100,
size=1)[0] > 30:
players[
0].resource_change -= 15
# chosen = my_punishment(j, stoken[2])
tell_the_officer_data_store_punishment[
defence_no] = [
j, stoken_no, punished,
"reprimanded"
]
if punished:
police_log.append([
datetime.now().strftime(
"%H:%M:%S %p"), punished,
stoken[2]
])
# my_punishment(j, stoken[2])
updater.append([j, stoken_no])
data_store_punishment = [
'NA' for i in range(steals[0].numberofdefencetokens)
]
if player.type == 2:
data_store_punishment = tell_the_officer_data_store_punishment
tell_the_officer_data_store_punishment = [
'NA' for i in range(steal.numberofdefencetokens)
]
if steal.detectoclockS:
print("S=", steal.detectoclockS)
steal.detectoclockS = 0
for i in all_defences.keys(
): # all_defences has keys and values as player.id:rects made from deence coordinates
if i != player.id: # we dont want to check the player's own defences matching with his steal tokens
for defence_no, defence in enumerate(
all_defences[i]
): # check all the defence rects in one of the values
for coords_no, coords in enumerate(
all_steals[player.id]
): # coords_no is which steal token it is, and coords are the steal token coords.
if defence.collidepoint(
(coords[0], coords[1])
): # if defence rect collides with player's steal token and not found anything before
print("Player ", player.id,
"was found stealing from ",
coords[2])
punished = punishment(
player.id, coords[2], 1)
print("punished", punished)
players[punished -
1].resource_change -= 17
# chosen = my_punishment(player.id, coords[2])
players[0].resource_change += 25
if punished != player.id:
if np.random.randint(
low=1, high=100,
size=1)[0] > 30:
players[
0].resource_change -= 15
print("defence_no ===== ", defence_no)
data_store_punishment[defence_no] = [
player.id, coords_no, punished,
"reprimanded"
]
if punished:
police_log.append([
datetime.now().strftime(
"%H:%M:%S %p"), punished,
coords[2]
])
# my_punishment(player.id, coords[2])
steal.caught[coords_no] = [
1, defence_no
]
steal.initialize_steal_token(
coords_no, "myserver place 3")
try:
punished = punished if punished else 0
except:
punished = 0
steal.numberofstealtokens = steals[
player_no].numberofstealtokens
steal.numberofdefencetokens = steals[
player_no].numberofdefencetokens
steal.update_token_count()
player.update_stealing_from_count(steal.numberofstealtokens -
len(player.stealing_from))
players[player_no].stealing_from = player.stealing_from
steal.P_innocent, steal.P_culprit = probability()
# players[player_no].resources["Grain"] = player.resources["Grain"] ##############################################################################################################
steals[player_no] = steal
player.datetime = datetime.now()
conn.send(
pickle.dumps((steal, player, police_log, punished,
data_store_punishment)))
# Write data to file
# if len(new_chat_row):
# with open('chats.csv', 'a', newline='') as csvfile:
# chatwriter = csv.writer(csvfile, delimiter=',',
# quotechar='|', quoting=csv.QUOTE_MINIMAL)
# chatwriter.writerow(new_chat_row)
# print(new_chat_row)
# new_chat_row = []
# file = open(r'C:\Users\Shantanu\PycharmProjects\desipun\venv\storage\important'+str(frame_number), 'wb')
# dump information to that file
# pickle.dump((players, draganddrops, steals, trades, all_defences, all_steals, trades_list), file)
# close the file
# file.close()
#except:
#print("break at except")
#break
print("lost connection")
player_no -= 1
conn.close()
