653 lines
31 KiB
Python
653 lines
31 KiB
Python
import time
|
|
import random
|
|
from json import JSONEncoder
|
|
from typing import List
|
|
import mariadb
|
|
from constants import *
|
|
from cards import *
|
|
|
|
|
|
class Player:
|
|
def __init__(self, player_id, name):
|
|
self.player_id = player_id
|
|
self.name = name
|
|
self.owned_starters = []
|
|
self.owned_citizens = []
|
|
self.owned_domains = []
|
|
self.owned_dukes = []
|
|
self.owned_monsters = []
|
|
self.gold_score = 2
|
|
self.strength_score = 0
|
|
self.magic_score = 1
|
|
self.victory_score = 0
|
|
self.is_first = False
|
|
self.shadow_count = 0
|
|
self.holy_count = 0
|
|
self.soldier_count = 0
|
|
self.worker_count = 0
|
|
self.effects = {
|
|
"roll_phase": [],
|
|
"harvest_phase": [],
|
|
"action_phase": []
|
|
}
|
|
|
|
@classmethod
|
|
def from_dict(cls, data):
|
|
player_id = data['player_id']
|
|
name = data['name']
|
|
player = cls(player_id, name)
|
|
player.owned_starters = [Starter.from_dict(s) for s in data['owned_starters']]
|
|
player.owned_citizens = [Citizen.from_dict(c) for c in data['owned_citizens']]
|
|
player.owned_domains = [Domain.from_dict(d) for d in data['owned_domains']]
|
|
player.owned_dukes = [Duke.from_dict(d) for d in data['owned_dukes']]
|
|
player.owned_monsters = [Monster.from_dict(m) for m in data['owned_monsters']]
|
|
player.gold_score = data['gold_score']
|
|
player.strength_score = data['strength_score']
|
|
player.magic_score = data['magic_score']
|
|
player.victory_score = data['victory_score']
|
|
player.is_first = data['is_first']
|
|
player.shadow_count = data['shadow_count']
|
|
player.holy_count = data['holy_count']
|
|
player.soldier_count = data['soldier_count']
|
|
player.worker_count = data['worker_count']
|
|
player.effects = data['effects']
|
|
return player
|
|
|
|
def calc_roles(self):
|
|
shadow_count = 0
|
|
holy_count = 0
|
|
soldier_count = 0
|
|
worker_count = 0
|
|
for citizen in self.owned_citizens:
|
|
shadow_count = shadow_count + citizen.shadow_count
|
|
holy_count = holy_count + citizen.holy_count
|
|
soldier_count = soldier_count + citizen.soldier_count
|
|
worker_count = worker_count + citizen.worker_count
|
|
for domain in self.owned_domains:
|
|
shadow_count = shadow_count + domain.shadow_count
|
|
holy_count = holy_count + domain.holy_count
|
|
soldier_count = soldier_count + domain.soldier_count
|
|
worker_count = worker_count + domain.worker_count
|
|
roles_dict = {
|
|
"shadow_count": shadow_count,
|
|
"holy_count": holy_count,
|
|
"soldier_count": soldier_count,
|
|
"worker_count": worker_count
|
|
}
|
|
return roles_dict
|
|
|
|
|
|
class Game:
|
|
def __init__(self, game_state):
|
|
self.game_id = game_state['game_id']
|
|
self.player_list = game_state['player_list']
|
|
self.monster_grid = game_state['monster_grid']
|
|
self.citizen_grid = game_state['citizen_grid']
|
|
self.domain_grid = game_state['domain_grid']
|
|
self.die_one = game_state['die_one']
|
|
self.die_two = game_state['die_two']
|
|
self.die_sum = game_state['die_sum']
|
|
self.exhausted_count = game_state['exhausted_count']
|
|
self.effects = game_state['effects']
|
|
self.action_required = game_state['action_required']
|
|
self.last_active_time = 0
|
|
|
|
def roll_phase(self):
|
|
self.die_one = random.randint(1, 6)
|
|
self.die_two = random.randint(1, 6)
|
|
self.die_sum = self.die_one + self.die_two
|
|
print(f"{self.die_one} | {self.die_two} | {self.die_sum}")
|
|
# check for player effects that are able to change roll
|
|
# check for board effects that trigger from rolls
|
|
|
|
def harvest_phase(self):
|
|
# steal activates first
|
|
for starter in self.player_list[0].owned_starters:
|
|
if (starter.roll_match1 == self.die_one) or (starter.roll_match1 == self.die_two) or (
|
|
starter.roll_match1 == self.die_sum) or (starter.roll_match2 == self.die_sum):
|
|
count = 1
|
|
if starter.roll_match1 == self.die_one == self.die_two:
|
|
count = 2
|
|
print(f"Payout for {self.player_list[0].name}: Starter {starter.name}{' x2' if count == 2 else ''}")
|
|
for i in range(count):
|
|
self.player_list[0].gold_score = self.player_list[0].gold_score + starter.gold_payout_on_turn
|
|
self.player_list[0].strength_score = self.player_list[
|
|
0].strength_score + starter.strength_payout_on_turn
|
|
self.player_list[0].magic_score = self.player_list[0].magic_score + starter.magic_payout_on_turn
|
|
if starter.has_special_payout_on_turn:
|
|
payout = self.execute_special_payout(starter.special_payout_on_turn,
|
|
self.player_list[0].player_id)
|
|
self.player_list[0].gold_score = self.player_list[0].gold_score + payout[0]
|
|
self.player_list[0].strength_score = self.player_list[0].strength_score + payout[1]
|
|
self.player_list[0].magic_score = self.player_list[0].magic_score + payout[2]
|
|
for citizen in self.player_list[0].owned_citizens:
|
|
if (citizen.roll_match1 == self.die_one) or (citizen.roll_match1 == self.die_two) or (
|
|
citizen.roll_match1 == self.die_sum) or (citizen.roll_match2 == self.die_sum):
|
|
count = 1
|
|
if citizen.roll_match1 == self.die_one == self.die_two:
|
|
count = 2
|
|
print(f"Payout for {self.player_list[0].name}: Citizen {citizen.name}{' x2' if count == 2 else ''}")
|
|
for i in range(count):
|
|
self.player_list[0].gold_score = self.player_list[0].gold_score + citizen.gold_payout_on_turn
|
|
self.player_list[0].strength_score = self.player_list[
|
|
0].strength_score + citizen.strength_payout_on_turn
|
|
self.player_list[0].magic_score = self.player_list[0].magic_score + citizen.magic_payout_on_turn
|
|
if citizen.has_special_payout_on_turn:
|
|
print(f"Citizen {citizen.name} special payout text: {citizen.special_payout_on_turn}")
|
|
payout = self.execute_special_payout(citizen.special_payout_on_turn,
|
|
self.player_list[0].player_id)
|
|
print(f"right after running execute special payout {payout}")
|
|
self.player_list[0].gold_score = self.player_list[0].gold_score + payout[0]
|
|
self.player_list[0].strength_score = self.player_list[0].strength_score + payout[1]
|
|
self.player_list[0].magic_score = self.player_list[0].magic_score + payout[2]
|
|
|
|
list_iterator = iter(self.player_list) # skip first player when paying out the rest of the board
|
|
next(list_iterator)
|
|
for player in list_iterator:
|
|
for starter in player.owned_starters:
|
|
if (starter.roll_match1 == self.die_one) or (starter.roll_match1 == self.die_two) or (
|
|
starter.roll_match1 == self.die_sum) or (starter.roll_match2 == self.die_sum):
|
|
count = 1
|
|
if starter.roll_match1 == self.die_one == self.die_two:
|
|
count = 2
|
|
print(f"Payout for {player.name}: Starter {starter.name}{' x2' if count == 2 else ''}")
|
|
for i in range(count):
|
|
player.gold_score = player.gold_score + starter.gold_payout_off_turn
|
|
player.strength_score = player.strength_score + starter.strength_payout_off_turn
|
|
player.magic_score = player.magic_score + starter.magic_payout_off_turn
|
|
if starter.has_special_payout_off_turn:
|
|
payout = self.execute_special_payout(starter.special_payout_off_turn, player.player_id)
|
|
player.gold_score = player.gold_score + payout[0]
|
|
player.strength_score = player.strength_score + payout[1]
|
|
player.magic_score = player.magic_score + payout[2]
|
|
|
|
for citizen in player.owned_citizens:
|
|
if (citizen.roll_match1 == self.die_one) or (citizen.roll_match1 == self.die_two) or (
|
|
citizen.roll_match1 == self.die_sum) or (citizen.roll_match2 == self.die_sum):
|
|
count = 1
|
|
if citizen.roll_match1 == self.die_one == self.die_two:
|
|
count = 2
|
|
print(f"Payout for {player.name}: Citizen {citizen.name}{' x2' if count == 2 else ''}")
|
|
for i in range(count):
|
|
player.gold_score = player.gold_score + citizen.gold_payout_off_turn
|
|
player.strength_score = player.strength_score + citizen.strength_payout_off_turn
|
|
player.magic_score = player.magic_score + citizen.magic_payout_off_turn
|
|
if citizen.has_special_payout_off_turn:
|
|
print("special payout off turn triggered")
|
|
print(citizen.special_payout_off_turn)
|
|
payout = self.execute_special_payout(citizen.special_payout_off_turn, player.player_id)
|
|
player.gold_score = player.gold_score + payout[0]
|
|
player.strength_score = player.strength_score + payout[1]
|
|
player.magic_score = player.magic_score + payout[2]
|
|
for player in self.player_list:
|
|
print(f"Player {player.name}: {player.gold_score} G, {player.strength_score} S, {player.magic_score} M,"
|
|
f" {player.victory_score} VP, Monsters: {len(player.owned_monsters)}, "
|
|
f"Citizens: {len(player.owned_citizens)}, Domains {len(player.owned_domains)}")
|
|
|
|
def execute_special_payout(self, command, player_id):
|
|
print("executing special payout")
|
|
payout = [0, 0, 0, 0] # gp, sp, mp, vp, todo: citizen, monster, domain
|
|
split_command = command.split()
|
|
first_word = split_command[0]
|
|
second_word = split_command[1]
|
|
third_word = split_command[2]
|
|
fourth_word = split_command[3]
|
|
match first_word:
|
|
case "count":
|
|
print("Matched count")
|
|
match second_word:
|
|
case "owned_shadow":
|
|
self.update_payout_for_role('shadow_count', player_id, payout, split_command)
|
|
case "owned_holy":
|
|
self.update_payout_for_role('holy_count', player_id, payout, split_command)
|
|
case "owned_soldier":
|
|
self.update_payout_for_role('soldier_count', player_id, payout, split_command)
|
|
case "owned_worker":
|
|
|
|
self.update_payout_for_role('worker_count', player_id, payout, split_command)
|
|
case "owned_monsters":
|
|
self.update_payout_for_role('owned_monsters', player_id, payout, split_command)
|
|
case "owned_citizens":
|
|
self.update_payout_for_role('owned_citizens', player_id, payout, split_command)
|
|
case "owned_domains":
|
|
self.update_payout_for_role('owned_domains', player_id, payout, split_command)
|
|
case _:
|
|
payout[0] = -9999
|
|
case "exchange":
|
|
print("Matched exchange")
|
|
match second_word:
|
|
case 'g':
|
|
payout[0] = payout[0] - int(third_word)
|
|
case 's':
|
|
payout[1] = payout[1] - int(third_word)
|
|
case 'm':
|
|
payout[2] = payout[2] - int(third_word)
|
|
case 'v':
|
|
payout[3] = payout[3] - int(third_word)
|
|
case _:
|
|
payout[0] = -9999
|
|
match fourth_word:
|
|
case 'g':
|
|
payout[0] = payout[0] + int(split_command[4])
|
|
case 's':
|
|
payout[1] = payout[1] + int(split_command[4])
|
|
case 'm':
|
|
payout[2] = payout[2] + int(split_command[4])
|
|
case 'v':
|
|
payout[3] = payout[3] + int(split_command[4])
|
|
case _:
|
|
payout[0] = -9999
|
|
case "choose":
|
|
print("Matched choose")
|
|
self.action_required['player_id'] = player_id
|
|
self.action_required['action'] = command
|
|
# need to pause execution here until we get player input
|
|
while self.action_required['player_id'] != self.game_id:
|
|
time.sleep(1)
|
|
choice = []
|
|
match self.action_required['action']:
|
|
case 'choose 1':
|
|
choice = [second_word, third_word]
|
|
case 'choose 2':
|
|
choice = [fourth_word, split_command[4]]
|
|
case 'choose 3':
|
|
choice = [split_command[5], split_command[6]] # [sixth_word, seventh_word]
|
|
case _:
|
|
payout[0] = -9999
|
|
match choice[0]:
|
|
case 'g':
|
|
payout[0] = payout[0] + choice[1]
|
|
case 's':
|
|
payout[1] = payout[1] + choice[1]
|
|
case 'm':
|
|
payout[2] = payout[2] + choice[1]
|
|
case 'v':
|
|
payout[3] = payout[3] + choice[1]
|
|
case _:
|
|
payout[0] = -9999
|
|
case _:
|
|
payout[0] = -9999
|
|
print(payout)
|
|
return payout
|
|
|
|
def owned_monster_attributes(self, player_id):
|
|
return_dict = {attr: 0 for attr in Constants.areas + Constants.types}
|
|
for player in self.player_list:
|
|
if player.player_id == player_id:
|
|
for monster in player.owned_monsters:
|
|
for area in Constants.areas:
|
|
if monster.area == area:
|
|
return_dict[area] += 1
|
|
for monster_type in Constants.types:
|
|
if monster.monster_type == monster_type:
|
|
return_dict[monster_type] += 1
|
|
|
|
return return_dict
|
|
|
|
def update_payout_for_role(self, role_name, player_id, payout, split_command):
|
|
role_count = 0
|
|
for player in self.player_list:
|
|
if player.player_id == player_id:
|
|
role_count = player.calc_roles()[role_name]
|
|
break
|
|
if role_count > 0:
|
|
match split_command[2]:
|
|
case 'g':
|
|
payout[0] = int(split_command[3]) * role_count
|
|
case 's':
|
|
payout[1] = int(split_command[3]) * role_count
|
|
case 'm':
|
|
payout[2] = int(split_command[3]) * role_count
|
|
case 'v':
|
|
payout[3] = int(split_command[3]) * role_count
|
|
case _:
|
|
payout[0] = -9999
|
|
else:
|
|
payout[0] = -9999
|
|
|
|
def hire_citizen(self, player_id, citizen_id, gp, mp=0):
|
|
for citizen_stack in self.citizen_grid:
|
|
for citizen in citizen_stack:
|
|
if citizen.citizen_id == citizen_id and citizen.is_accessible:
|
|
for player in self.player_list:
|
|
if player.player_id == player_id:
|
|
player.gold_score = player.gold_score - gp
|
|
player.magic_score = player.magic_score - mp
|
|
player.owned_citizens.append(citizen_stack.pop(-1))
|
|
citizen_stack[-1].toggle_accessibility(True)
|
|
|
|
def slay_monster(self, player_id, monster_id, sp, mp=0):
|
|
payout = [0, 0, 0, 0]
|
|
for monster_stack in self.monster_grid:
|
|
for monster in monster_stack:
|
|
if monster.monster_id == monster_id: # and monster.is_accessible:
|
|
for player in self.player_list:
|
|
if player.player_id == player_id:
|
|
player.strength_score = player.strength_score - sp
|
|
player.magic_score = player.magic_score - mp
|
|
player.owned_monsters.append(monster_stack.pop(-1))
|
|
if monster.has_special_reward:
|
|
payout = self.execute_special_payout(monster.special_reward, player_id)
|
|
payout[0] = payout[0] + monster.gold_reward
|
|
payout[1] = payout[1] + monster.strength_reward
|
|
payout[2] = payout[2] + monster.magic_reward
|
|
payout[3] = payout[3] + monster.vp_reward
|
|
for player in self.player_list:
|
|
if player.player_id == player_id:
|
|
player.gold_score = player.gold_score + payout[0]
|
|
player.strength_score = player.strength_score + payout[1]
|
|
player.magic_score = player.magic_score + payout[2]
|
|
player.victory_score = player.victory_score + payout[3]
|
|
monster_stack[-1].toggle_accessibility(True)
|
|
|
|
def buy_domain(self, player_id, domain_id, gp, mp=0):
|
|
for domain_stack in self.domain_grid:
|
|
for domain in domain_stack:
|
|
if domain.domain_id == domain_id and domain.is_accessible:
|
|
for player in self.player_list:
|
|
if player.player_id == player_id:
|
|
player.gold_score = player.gold_score - gp
|
|
player.magic_score = player.magic_score - mp
|
|
player.owned_domains.append(domain_stack.pop(-1))
|
|
domain_stack[-1].toggle_accessibility(True)
|
|
|
|
def action_phase(self):
|
|
return
|
|
|
|
def play_turn(self):
|
|
self.roll_phase()
|
|
self.harvest_phase()
|
|
self.action_phase()
|
|
|
|
def end_check(self):
|
|
if self.exhausted_count <= (len(self.player_list) * 2):
|
|
return False
|
|
|
|
def prompt(self):
|
|
return
|
|
|
|
|
|
class LobbyMember:
|
|
def __init__(self, player_name, player_id):
|
|
self.name = player_name
|
|
self.player_id = player_id
|
|
self.is_ready = False
|
|
self.last_active_time = 0
|
|
|
|
|
|
class GameMember:
|
|
def __init__(self, player_id, player_name, game_id):
|
|
self.name = player_name
|
|
self.player_id = player_id
|
|
self.game_id = game_id
|
|
|
|
|
|
def load_game_data(game_id, preset, player_list_from_lobby):
|
|
monster_query = ""
|
|
monster_stack = []
|
|
citizen_query = ""
|
|
citizen_stack = []
|
|
domain_query = "select_random_domains"
|
|
domain_stack = []
|
|
duke_query = "select_random_dukes"
|
|
duke_stack = []
|
|
starter_query = "SELECT * FROM starters"
|
|
starter_stack = []
|
|
player_list = []
|
|
citizen_grid: List[List[Citizen]] = [[] for _ in range(10)]
|
|
domain_grid: List[List[Domain]] = [[] for _ in range(5)]
|
|
monster_grid: List[List[Monster]] = [[] for _ in range(5)]
|
|
die_one = 0
|
|
die_two = 0
|
|
die_sum = 0
|
|
exhausted_count = 0
|
|
effects = {
|
|
"roll_phase": [],
|
|
"harvest_phase": [],
|
|
"action_phase": []
|
|
}
|
|
action_required = {
|
|
"player_id": "",
|
|
"action": ""
|
|
}
|
|
match preset:
|
|
case "base1":
|
|
monster_query = "select_base1_monsters"
|
|
citizen_query = "select_base1_citizens"
|
|
case "base2":
|
|
monster_query = "select_base2_monsters"
|
|
citizen_query = "select_base2_citizens"
|
|
try:
|
|
my_connect = mariadb.connect(user='vckonline', password='vckonline', host='127.0.0.1',
|
|
database='vckonline')
|
|
my_cursor = my_connect.cursor(dictionary=True)
|
|
|
|
my_cursor.callproc(monster_query)
|
|
|
|
results = my_cursor.fetchall()
|
|
for row in results:
|
|
my_monster = Monster(row['id_monsters'], row['name'], row['area'], row['monster_type'],
|
|
row['monster_order'], row['strength_cost'], row['magic_cost'], row['vp_reward'],
|
|
row['gold_reward'], row['strength_reward'], row['magic_reward'],
|
|
row['has_special_reward'], row['special_reward'], row['has_special_cost'],
|
|
row['special_cost'], row['is_extra'], row['expansion'])
|
|
monster_stack.append(my_monster)
|
|
|
|
my_cursor.callproc(citizen_query)
|
|
citizen_count = 5
|
|
if len(player_list_from_lobby) == 5:
|
|
citizen_count = 6
|
|
results = my_cursor.fetchall()
|
|
for row in results:
|
|
for i in range(citizen_count):
|
|
my_citizen = Citizen(row['id_citizens'], row['name'], row['gold_cost'], row['roll_match1'],
|
|
row['roll_match2'], row['shadow_count'], row['holy_count'], row['soldier_count'],
|
|
row['worker_count'], row['gold_payout_on_turn'], row['gold_payout_off_turn'],
|
|
row['strength_payout_on_turn'], row['strength_payout_off_turn'],
|
|
row['magic_payout_on_turn'], row['magic_payout_off_turn'],
|
|
row['has_special_payout_on_turn'], row['has_special_payout_off_turn'],
|
|
row['special_payout_on_turn'], row['special_payout_off_turn'],
|
|
row['special_citizen'],
|
|
row['expansion'])
|
|
citizen_stack.append(my_citizen)
|
|
|
|
my_cursor.callproc(domain_query)
|
|
results = my_cursor.fetchall()
|
|
for row in results:
|
|
my_domain = Domain(row['id_domains'], row['name'], row['gold_cost'], row['shadow_count'], row['holy_count'],
|
|
row['soldier_count'], row['worker_count'], row['vp_reward'],
|
|
row['has_activation_effect'], row['has_passive_effect'], row['passive_effect'],
|
|
row['activation_effect'], row['text'], row['expansion'])
|
|
domain_stack.append(my_domain)
|
|
|
|
my_cursor.callproc(duke_query)
|
|
results = my_cursor.fetchall()
|
|
for row in results:
|
|
my_duke = Duke(row['id_dukes'], row['name'], row['gold_mult'], row['strength_mult'], row['magic_mult'],
|
|
row['shadow_mult'], row['holy_mult'], row['soldier_mult'], row['worker_mult'],
|
|
row['monster_mult'], row['citizen_mult'], row['domain_mult'], row['boss_mult'],
|
|
row['minion_mult'], row['beast_mult'], row['titan_mult'], row['expansion'])
|
|
duke_stack.append(my_duke)
|
|
|
|
my_cursor.execute(starter_query)
|
|
my_result = my_cursor.fetchall()
|
|
for row in my_result:
|
|
my_starter = Starter(row['id_starters'], row['name'], row['roll_match1'], row['roll_match2'],
|
|
row['gold_payout_on_turn'], row['gold_payout_off_turn'],
|
|
row['strength_payout_on_turn'], row['strength_payout_off_turn'],
|
|
row['magic_payout_on_turn'], row['magic_payout_off_turn'],
|
|
row['has_special_payout_on_turn'], row['has_special_payout_off_turn'],
|
|
row['special_payout_on_turn'], row['special_payout_off_turn'], row['expansion'])
|
|
starter_stack.append(my_starter)
|
|
my_cursor.close()
|
|
my_connect.close()
|
|
except Exception as e:
|
|
print(f"Error: {e}")
|
|
# print(f"size of monster stack: {len(monster_stack)}")
|
|
# print(f"size of citizen stack: {len(citizen_stack)}")
|
|
# print(f"size of domain stack: {len(domain_stack)}")
|
|
# print(f"size of duke stack: {len(duke_stack)}")
|
|
# print(f"size of starter stack: {len(starter_stack)}")
|
|
# create players and determine order
|
|
if not all([player_list_from_lobby, starter_query, monster_stack, citizen_stack, domain_stack, duke_stack]):
|
|
raise ValueError("One or more required lists are empty.")
|
|
else:
|
|
for player in player_list_from_lobby:
|
|
my_player = Player(player.player_id, player.name)
|
|
player_list.append(my_player)
|
|
random.shuffle(player_list)
|
|
player_list[0].is_first = True
|
|
# give players starters and dukes
|
|
for player in player_list:
|
|
player.owned_starters.append(starter_stack[0])
|
|
player.owned_starters.append(starter_stack[1])
|
|
for i in range(2):
|
|
player.owned_dukes.append(duke_stack.pop())
|
|
# deal monsters onto the board
|
|
grouped_monsters = {}
|
|
for monster in monster_stack:
|
|
area = monster.area
|
|
if area in grouped_monsters:
|
|
grouped_monsters[area].append(monster)
|
|
else:
|
|
grouped_monsters[area] = [monster]
|
|
# Reverse the order of each group by monster_order
|
|
for area, monsters in grouped_monsters.items():
|
|
monsters.sort(key=lambda item: item.order, reverse=True)
|
|
areas = list(grouped_monsters.keys())
|
|
chosen_areas = random.sample(areas, 5)
|
|
for i, area in enumerate(chosen_areas):
|
|
monsters = grouped_monsters[area]
|
|
monster_grid[i].extend(monsters)
|
|
for i, stack in enumerate(monster_grid):
|
|
for monster in stack:
|
|
monster.toggle_visibility(True)
|
|
# Make the last monster in the stack accessible
|
|
stack[-1].toggle_accessibility(True)
|
|
# deal citizens onto the board
|
|
# Create a dictionary to store citizen lists with roll numbers as keys
|
|
citizens_by_roll = {roll: [] for roll in [1, 2, 3, 4, 5, 6, 7, 8, 9, 11]}
|
|
# Group citizens by roll number
|
|
for citizen in citizen_stack:
|
|
citizen.toggle_visibility()
|
|
citizens_by_roll[citizen.roll_match1].append(citizen)
|
|
for roll in citizens_by_roll:
|
|
# Map 11 roll to index 9
|
|
index = roll - 1 if roll < 11 else 9
|
|
citizens = citizens_by_roll[roll]
|
|
citizen_grid[index].extend(list(citizens))
|
|
# Make the first citizen in each list accessible
|
|
citizen_grid[index][-1].toggle_accessibility(True)
|
|
# Deal the domains into the stacks
|
|
for i in range(5):
|
|
stack = domain_grid[i]
|
|
for j in range(3):
|
|
if j == 2: # top domain is visible and accessible
|
|
domain = domain_stack.pop()
|
|
domain.toggle_visibility(True)
|
|
domain.toggle_accessibility(True)
|
|
stack.append(domain)
|
|
else: # other domains are not visible or accessible
|
|
domain = domain_stack.pop()
|
|
stack.append(domain)
|
|
|
|
# Create a dictionary to store all the stacks
|
|
game_state = {'game_id': game_id,
|
|
'player_list': player_list,
|
|
'monster_grid': monster_grid,
|
|
'citizen_grid': citizen_grid,
|
|
'domain_grid': domain_grid,
|
|
'die_one': die_one,
|
|
'die_two': die_two,
|
|
'die_sum': die_sum,
|
|
'exhausted_count': exhausted_count,
|
|
'effects': effects,
|
|
'action_required': action_required}
|
|
# Return the dictionary
|
|
return game_state
|
|
|
|
|
|
class SummaryEncoder(JSONEncoder):
|
|
def default(self, obj):
|
|
if isinstance(obj, Player):
|
|
return {
|
|
'player_id': obj.player_id,
|
|
'name': obj.name,
|
|
'owned_citizens': len(obj.owned_citizens),
|
|
'owned_domains': len(obj.owned_domains),
|
|
'owned_monsters': len(obj.owned_monsters),
|
|
'gold_score': obj.gold_score,
|
|
'strength_score': obj.strength_score,
|
|
'magic_score': obj.magic_score,
|
|
'victory_score': obj.victory_score,
|
|
'is_first': obj.is_first
|
|
}
|
|
elif isinstance(obj, LobbyMember):
|
|
return {
|
|
"player_name": obj.name,
|
|
"player_id": obj.player_id,
|
|
"is_ready": obj.is_ready
|
|
}
|
|
elif isinstance(obj, GameMember):
|
|
return {
|
|
"player_name": obj.name,
|
|
"player_id": obj.player_id
|
|
}
|
|
elif isinstance(obj, Game):
|
|
return {
|
|
"game_id": obj.game_id,
|
|
"player_list": obj.player_list
|
|
}
|
|
else:
|
|
return super().default(obj)
|
|
|
|
|
|
class GameObjectEncoder(JSONEncoder):
|
|
def default(self, obj):
|
|
if isinstance(obj, Player):
|
|
return {
|
|
'player_id': obj.player_id,
|
|
'name': obj.name,
|
|
'owned_starters': [starter.starter_id for starter in obj.owned_starters],
|
|
'owned_citizens': [citizen.citizen_id for citizen in obj.owned_citizens],
|
|
'owned_domains': [domain.domain_id for domain in obj.owned_domains],
|
|
'owned_dukes': [duke.duke_id for duke in obj.owned_dukes],
|
|
'owned_monsters': [monster.monster_id for monster in obj.owned_monsters],
|
|
'gold_score': obj.gold_score,
|
|
'strength_score': obj.strength_score,
|
|
'magic_score': obj.magic_score,
|
|
'victory_score': obj.victory_score,
|
|
'is_first': obj.is_first,
|
|
'shadow_count': obj.shadow_count,
|
|
'holy_count': obj.holy_count,
|
|
'soldier_count': obj.soldier_count,
|
|
'worker_count': obj.worker_count,
|
|
'effects': obj.effects
|
|
}
|
|
elif isinstance(obj, Duke):
|
|
return obj.to_dict()
|
|
elif isinstance(obj, Monster):
|
|
return obj.to_dict()
|
|
elif isinstance(obj, Starter):
|
|
return obj.to_dict()
|
|
elif isinstance(obj, Citizen):
|
|
return obj.to_dict()
|
|
elif isinstance(obj, Domain):
|
|
return obj.to_dict()
|
|
elif isinstance(obj, Game):
|
|
return {
|
|
"game_id": obj.game_id,
|
|
"player_list": obj.player_list,
|
|
"monster_grid": obj.monster_grid,
|
|
"citizen_grid": obj.citizen_grid,
|
|
"domain_grid": obj.domain_grid,
|
|
"die_one": obj.die_one,
|
|
"die_two": obj.die_two,
|
|
"die_sum": obj.die_sum,
|
|
"exhausted_count": obj.exhausted_count,
|
|
"effects": obj.effects,
|
|
"action_required": obj.action_required
|
|
}
|
|
else:
|
|
return super().default(obj)
|