678 lines
32 KiB
Python
Executable File
678 lines
32 KiB
Python
Executable File
import json
|
|
from json import JSONEncoder
|
|
|
|
import mysql.connector
|
|
import random
|
|
from typing import List, Dict
|
|
import shortuuid
|
|
import uuid
|
|
|
|
|
|
class Card:
|
|
def __init__(self):
|
|
self.name = ""
|
|
self.is_visible = False
|
|
self.is_accessible = False
|
|
|
|
def to_dict(self):
|
|
return {
|
|
"name": self.name,
|
|
"is_visible": self.is_visible,
|
|
"is_accessible": self.is_accessible,
|
|
}
|
|
|
|
def toggle_visibility(self, toggle: bool = True):
|
|
self.is_visible = toggle
|
|
|
|
def toggle_accessibility(self, toggle: bool = True):
|
|
self.is_accessible = toggle
|
|
|
|
|
|
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.is_first = False
|
|
self.shadow_count = 0
|
|
self.holy_count = 0
|
|
self.soldier_count = 0
|
|
self.worker_count = 0
|
|
|
|
def calc_roles(self):
|
|
for citizen in self.owned_citizens:
|
|
self.shadow_count = self.shadow_count + citizen.shadow_count
|
|
self.holy_count = self.holy_count + citizen.holy_count
|
|
self.soldier_count = self.soldier_count + citizen.soldier_count
|
|
self.worker_count = self.worker_count + citizen.worker_count
|
|
for domain in self.owned_domains:
|
|
self.shadow_count = self.shadow_count + domain.shadow_count
|
|
self.holy_count = self.holy_count + domain.holy_count
|
|
self.soldier_count = self.soldier_count + domain.soldier_count
|
|
self.worker_count = self.worker_count + domain.worker_count
|
|
|
|
|
|
class Starter(Card):
|
|
def __init__(self, starter_id, name, roll_match1, roll_match2, gold_payout_on_turn, gold_payout_off_turn,
|
|
strength_payout_on_turn, strength_payout_off_turn, magic_payout_on_turn, magic_payout_off_turn,
|
|
has_special_payout_on_turn, has_special_payout_off_turn, special_payout_on_turn,
|
|
special_payout_off_turn, expansion):
|
|
super().__init__()
|
|
self.starter_id = starter_id
|
|
self.name = name
|
|
self.rollMatch1 = roll_match1
|
|
self.rollMatch2 = roll_match2
|
|
self.goldPayoutOnTurn = gold_payout_on_turn
|
|
self.goldPayoutOffTurn = gold_payout_off_turn
|
|
self.strengthPayoutOnTurn = strength_payout_on_turn
|
|
self.strengthPayoutOffTurn = strength_payout_off_turn
|
|
self.magicPayoutOnTurn = magic_payout_on_turn
|
|
self.magicPayoutOffTurn = magic_payout_off_turn
|
|
self.hasSpecialPayoutOnTurn = has_special_payout_on_turn
|
|
self.hasSpecialPayoutOffTurn = has_special_payout_off_turn
|
|
self.specialPayoutOnTurn = special_payout_on_turn
|
|
self.specialPayoutOffTurn = special_payout_off_turn
|
|
self.expansion = expansion
|
|
|
|
def to_dict(self):
|
|
return {
|
|
"starter_id": self.starter_id,
|
|
"name": self.name,
|
|
"roll_match1": self.rollMatch1,
|
|
"roll_match2": self.rollMatch2,
|
|
"gold_payout_on_turn": self.goldPayoutOnTurn,
|
|
"gold_payout_off_turn": self.goldPayoutOffTurn,
|
|
"strength_payout_on_turn": self.strengthPayoutOnTurn,
|
|
"strength_payout_off_turn": self.strengthPayoutOffTurn,
|
|
"magic_payout_on_turn": self.magicPayoutOnTurn,
|
|
"magic_payout_off_turn": self.magicPayoutOffTurn,
|
|
"has_special_payout_on_turn": self.hasSpecialPayoutOnTurn,
|
|
"has_special_payout_off_turn": self.hasSpecialPayoutOffTurn,
|
|
"special_payout_on_turn": self.specialPayoutOnTurn,
|
|
"special_payout_off_turn": self.specialPayoutOffTurn,
|
|
"expansion": self.expansion
|
|
}
|
|
|
|
|
|
class Citizen(Card):
|
|
def __init__(self, citizen_id, name, gold_cost, roll_match1, roll_match2, shadow_count, holy_count, soldier_count,
|
|
worker_count, gold_payout_on_turn, gold_payout_off_turn, strength_payout_on_turn,
|
|
strength_payout_off_turn, magic_payout_on_turn, magic_payout_off_turn, has_special_payout_on_turn,
|
|
has_special_payout_off_turn, special_payout_on_turn, special_payout_off_turn, special_citizen,
|
|
expansion):
|
|
super().__init__()
|
|
self.citizen_id = citizen_id
|
|
self.name = name
|
|
self.gold_cost = gold_cost
|
|
self.roll_match1 = roll_match1
|
|
self.roll_match2 = roll_match2
|
|
self.shadow_count = shadow_count
|
|
self.holy_count = holy_count
|
|
self.soldier_count = soldier_count
|
|
self.worker_count = worker_count
|
|
self.gold_payout_on_turn = gold_payout_on_turn
|
|
self.gold_payout_off_turn = gold_payout_off_turn
|
|
self.strength_payout_on_turn = strength_payout_on_turn
|
|
self.strength_payout_off_turn = strength_payout_off_turn
|
|
self.magic_payout_on_turn = magic_payout_on_turn
|
|
self.magic_payout_off_turn = magic_payout_off_turn
|
|
self.has_special_payout_on_turn = has_special_payout_on_turn
|
|
self.has_special_payout_off_turn = has_special_payout_off_turn
|
|
self.special_payout_on_turn = special_payout_on_turn
|
|
self.special_payout_off_turn = special_payout_off_turn
|
|
self.special_citizen = special_citizen
|
|
self.expansion = expansion
|
|
|
|
def to_dict(self):
|
|
base_dict = super().to_dict()
|
|
return {**base_dict,
|
|
"citizen_id": self.citizen_id,
|
|
"gold_cost": self.gold_cost,
|
|
"roll_match1": self.roll_match1,
|
|
"roll_match2": self.roll_match2,
|
|
"shadow_count": self.shadow_count,
|
|
"holy_count": self.holy_count,
|
|
"soldier_count": self.soldier_count,
|
|
"worker_count": self.worker_count,
|
|
"gold_payout_on_turn": self.gold_payout_on_turn,
|
|
"gold_payout_off_turn": self.gold_payout_off_turn,
|
|
"strength_payout_on_turn": self.strength_payout_on_turn,
|
|
"strength_payout_off_turn": self.strength_payout_off_turn,
|
|
"magic_payout_on_turn": self.magic_payout_on_turn,
|
|
"magic_payout_off_turn": self.magic_payout_off_turn,
|
|
"has_special_payout_on_turn": self.has_special_payout_on_turn,
|
|
"has_special_payout_off_turn": self.has_special_payout_off_turn,
|
|
"special_payout_on_turn": self.special_payout_on_turn,
|
|
"special_payout_off_turn": self.special_payout_off_turn,
|
|
"special_citizen": self.special_citizen,
|
|
"expansion": self.expansion}
|
|
|
|
|
|
class Domain(Card):
|
|
def __init__(self, domain_id, name, gold_cost, shadow_count, holy_count, soldier_count, worker_count, vp_reward,
|
|
has_activation_effect, has_passive_effect, passive_effect, activation_effect, text, expansion):
|
|
super().__init__()
|
|
self.domain_id = domain_id
|
|
self.name = name
|
|
self.gold_cost = gold_cost
|
|
self.shadow_count = shadow_count
|
|
self.holy_count = holy_count
|
|
self.soldier_count = soldier_count
|
|
self.worker_count = worker_count
|
|
self.vp_reward = vp_reward
|
|
self.has_activation_effect = has_activation_effect
|
|
self.has_passive_effect = has_passive_effect
|
|
self.passive_effect = passive_effect
|
|
self.activation_effect = activation_effect
|
|
self.text = text
|
|
self.expansion = expansion
|
|
|
|
def to_dict(self):
|
|
return {
|
|
**super().to_dict(),
|
|
"domain_id": self.domain_id,
|
|
"name": self.name,
|
|
"gold_cost": self.gold_cost,
|
|
"shadow_count": self.shadow_count,
|
|
"holy_count": self.holy_count,
|
|
"soldier_count": self.soldier_count,
|
|
"worker_count": self.worker_count,
|
|
"vp_reward": self.vp_reward,
|
|
"has_activation_effect": self.has_activation_effect,
|
|
"has_passive_effect": self.has_passive_effect,
|
|
"passive_effect": self.passive_effect,
|
|
"activation_effect": self.activation_effect,
|
|
"text": self.text,
|
|
"expansion": self.expansion
|
|
}
|
|
|
|
|
|
class Monster(Card):
|
|
def __init__(self, monster_id, name, area, monster_type, order, strength_cost, magic_cost, vp_reward, gold_reward,
|
|
strength_reward, magic_reward, has_special_reward, special_reward, has_special_cost, special_cost,
|
|
is_extra, expansion):
|
|
super().__init__()
|
|
self.monster_id = monster_id
|
|
self.name = name
|
|
self.area = area
|
|
self.monster_type = monster_type
|
|
self.order = order
|
|
self.strength_cost = strength_cost
|
|
self.magic_cost = magic_cost
|
|
self.vp_reward = vp_reward
|
|
self.gold_reward = gold_reward
|
|
self.strength_reward = strength_reward
|
|
self.magic_reward = magic_reward
|
|
self.has_special_reward = has_special_reward
|
|
self.special_reward = special_reward
|
|
self.has_special_cost = has_special_cost
|
|
self.special_cost = special_cost
|
|
self.is_extra = is_extra
|
|
self.expansion = expansion
|
|
|
|
def to_dict(self):
|
|
card_dict = super().to_dict()
|
|
monster_dict = {
|
|
"monster_id": self.monster_id,
|
|
"area": self.area,
|
|
"monster_type": self.monster_type,
|
|
"order": self.order,
|
|
"strength_cost": self.strength_cost,
|
|
"magic_cost": self.magic_cost,
|
|
"vp_reward": self.vp_reward,
|
|
"gold_reward": self.gold_reward,
|
|
"strength_reward": self.strength_reward,
|
|
"magic_reward": self.magic_reward,
|
|
"has_special_reward": self.has_special_reward,
|
|
"special_reward": self.special_reward,
|
|
"has_special_cost": self.has_special_cost,
|
|
"special_cost": self.special_cost,
|
|
"is_extra": self.is_extra,
|
|
"expansion": self.expansion,
|
|
}
|
|
return {**card_dict, **monster_dict}
|
|
|
|
def add_strength_cost(self, added_strength):
|
|
self.strength_cost = self.strength_cost + added_strength
|
|
|
|
def add_magic_cost(self, added_magic):
|
|
self.magic_cost = self.magic_cost + added_magic
|
|
|
|
|
|
class Duke(Card):
|
|
def __init__(self, duke_id, name, gold_mult, strength_mult, magic_mult, shadow_mult, holy_mult, soldier_mult,
|
|
worker_mult, monster_mult, citizen_mult, domain_mult, boss_mult, minion_mult, beast_mult, titan_mult,
|
|
expansion):
|
|
super().__init__()
|
|
self.duke_id = duke_id
|
|
self.name = name
|
|
self.gold_multiplier = gold_mult
|
|
self.strength_multiplier = strength_mult
|
|
self.magic_multiplier = magic_mult
|
|
self.shadow_multiplier = shadow_mult
|
|
self.holy_multiplier = holy_mult
|
|
self.soldier_multiplier = soldier_mult
|
|
self.worker_multiplier = worker_mult
|
|
self.monster_multiplier = monster_mult
|
|
self.citizen_multiplier = citizen_mult
|
|
self.domain_multiplier = domain_mult
|
|
self.boss_multiplier = boss_mult
|
|
self.minion_multiplier = minion_mult
|
|
self.beast_multiplier = beast_mult
|
|
self.titan_multiplier = titan_mult
|
|
self.expansion = expansion
|
|
|
|
def to_dict(self):
|
|
return {
|
|
**super().to_dict(),
|
|
"duke_id": self.duke_id,
|
|
"gold_multiplier": self.gold_multiplier,
|
|
"strength_multiplier": self.strength_multiplier,
|
|
"magic_multiplier": self.magic_multiplier,
|
|
"shadow_multiplier": self.shadow_multiplier,
|
|
"holy_multiplier": self.holy_multiplier,
|
|
"soldier_multiplier": self.soldier_multiplier,
|
|
"worker_multiplier": self.worker_multiplier,
|
|
"monster_multiplier": self.monster_multiplier,
|
|
"citizen_multiplier": self.citizen_multiplier,
|
|
"domain_multiplier": self.domain_multiplier,
|
|
"boss_multiplier": self.boss_multiplier,
|
|
"minion_multiplier": self.minion_multiplier,
|
|
"beast_multiplier": self.beast_multiplier,
|
|
"titan_multiplier": self.titan_multiplier,
|
|
"expansion": self.expansion
|
|
}
|
|
|
|
|
|
class Game:
|
|
def __init__(self, game_id, player_list_from_lobby, preset="shuffled", number_of_dukes=2):
|
|
self.game_id = game_id
|
|
self.player_count = len(player_list_from_lobby)
|
|
self.preset = preset
|
|
self.number_of_dukes = number_of_dukes
|
|
self.player_list = []
|
|
self.citizen_grid: List[List[Citizen]] = [[] for _ in range(10)]
|
|
self.domain_grid: List[List[Domain]] = [[] for _ in range(5)]
|
|
self.monster_grid: List[List[Monster]] = [[] for _ in range(5)]
|
|
self.duke_stack = []
|
|
self.domain_stack = []
|
|
self.citizen_stack = []
|
|
self.monster_stack = []
|
|
self.starter_stack = []
|
|
self.graveyard = []
|
|
self.die_one = 0
|
|
self.die_two = 0
|
|
self.die_sum = 0
|
|
self.exhausted_count = 0
|
|
|
|
my_connect = mysql.connector.connect(user='vckonline', password='vckonline', host='localhost',
|
|
database='vckonline')
|
|
my_cursor = my_connect.cursor(dictionary=True)
|
|
|
|
# load game data
|
|
my_cursor.execute("SELECT * FROM dukes")
|
|
my_result = my_cursor.fetchall()
|
|
for row in my_result:
|
|
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'])
|
|
self.duke_stack.append(my_duke)
|
|
random.shuffle(self.duke_stack)
|
|
my_cursor.execute("SELECT * FROM domains")
|
|
my_result = my_cursor.fetchall()
|
|
for row in my_result:
|
|
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'])
|
|
self.domain_stack.append(my_domain)
|
|
random.shuffle(self.domain_stack)
|
|
|
|
my_cursor.execute("SELECT * FROM citizens")
|
|
my_result = my_cursor.fetchall()
|
|
for row in my_result:
|
|
for i in range(6):
|
|
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'])
|
|
self.citizen_stack.append(my_citizen)
|
|
|
|
my_cursor.execute("SELECT * FROM starters")
|
|
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'])
|
|
self.starter_stack.append(my_starter)
|
|
|
|
my_cursor.execute("SELECT * FROM monsters")
|
|
my_result = my_cursor.fetchall()
|
|
for row in my_result:
|
|
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'])
|
|
self.monster_stack.append(my_monster)
|
|
my_connect.close()
|
|
# end load game data
|
|
# remove extra cards
|
|
if self.player_count != 5:
|
|
extra_monsters = []
|
|
remaining_monsters = []
|
|
for monster in self.monster_stack:
|
|
if monster.is_extra == 1:
|
|
extra_monsters.append(monster)
|
|
else:
|
|
remaining_monsters.append(monster)
|
|
self.monster_stack = remaining_monsters
|
|
self.graveyard.extend(extra_monsters)
|
|
match self.preset:
|
|
case "base1":
|
|
base1_monsters = []
|
|
other_expansion_monsters = []
|
|
for monster in self.monster_stack:
|
|
if monster.expansion == "base1":
|
|
base1_monsters.append(monster)
|
|
else:
|
|
other_expansion_monsters.append(monster)
|
|
self.monster_stack = base1_monsters
|
|
self.graveyard.extend(other_expansion_monsters)
|
|
base1_citizens = []
|
|
other_expansion_citizens = []
|
|
for citizen in self.citizen_stack:
|
|
if citizen.expansion == "base1":
|
|
base1_citizens.append(citizen)
|
|
else:
|
|
other_expansion_citizens.append(citizen)
|
|
self.citizen_stack = base1_citizens
|
|
self.graveyard.extend(other_expansion_citizens)
|
|
case "base2":
|
|
base1_monsters = []
|
|
base2_monsters = []
|
|
other_expansion_monsters = []
|
|
for monster in self.monster_stack:
|
|
if monster.expansion == "base1":
|
|
base1_monsters.append(monster)
|
|
elif monster.expansion == "base2":
|
|
base2_monsters.append(monster)
|
|
else:
|
|
other_expansion_monsters.append(monster)
|
|
# add 2 random monster areas from base1 to fill out base2 monsters
|
|
grouped_monsters = {}
|
|
for base1_monster in base1_monsters:
|
|
area = base1_monster.area
|
|
if area in grouped_monsters:
|
|
grouped_monsters[area].append(base1_monster)
|
|
else:
|
|
grouped_monsters[area] = [base1_monster]
|
|
areas = list(grouped_monsters.keys())
|
|
chosen_areas = random.sample(areas, 2)
|
|
not_chosen_monsters = [monster for area, monsters in grouped_monsters.items() if
|
|
area not in chosen_areas for monster in monsters]
|
|
self.graveyard.extend(not_chosen_monsters)
|
|
for i, area in enumerate(chosen_areas):
|
|
monsters = grouped_monsters[area]
|
|
base2_monsters.extend(monsters)
|
|
self.monster_stack = base2_monsters
|
|
self.graveyard.extend(other_expansion_monsters)
|
|
base2_citizens = []
|
|
other_expansion_citizens = []
|
|
for citizen in self.citizen_stack:
|
|
if citizen.expansion == "base2":
|
|
base2_citizens.append(citizen)
|
|
else:
|
|
other_expansion_citizens.append(citizen)
|
|
# add peasant and knight from base1
|
|
for citizen in other_expansion_citizens:
|
|
if citizen.name == "Peasant" and citizen.expansion == "base1":
|
|
base2_citizens.append(citizen)
|
|
elif citizen.name == "Knight" and citizen.expansion == "base1":
|
|
base2_citizens.append(citizen)
|
|
self.citizen_stack = base2_citizens
|
|
# put the rest of the cards in the graveyard
|
|
grouped_citizens = {}
|
|
for citizen in other_expansion_citizens:
|
|
expansion = citizen.expansion
|
|
if expansion in grouped_citizens:
|
|
grouped_citizens[expansion].append(citizen)
|
|
else:
|
|
grouped_citizens[expansion] = [citizen]
|
|
if "base1" in grouped_citizens:
|
|
base1_citizens = grouped_citizens["base1"]
|
|
base1_citizens = [citizen for citizen in base1_citizens if
|
|
citizen.name not in ("Peasant", "Knight")]
|
|
grouped_citizens["base1"] = base1_citizens
|
|
other_expansion_citizens = []
|
|
for expansion in grouped_citizens.values():
|
|
other_expansion_citizens.extend(expansion)
|
|
self.graveyard.extend(other_expansion_citizens)
|
|
case "shadowvale":
|
|
shadowvale_monsters = []
|
|
other_expansion_monsters = []
|
|
for monster in self.monster_stack:
|
|
if monster.expansion == "shadowvale":
|
|
shadowvale_monsters.append(monster)
|
|
else:
|
|
other_expansion_monsters.append(monster)
|
|
self.monster_stack = shadowvale_monsters
|
|
self.graveyard.extend(other_expansion_monsters)
|
|
shadowvale_citizens = []
|
|
other_expansion_citizens = []
|
|
for citizen in self.citizen_stack:
|
|
if citizen.expansion == "shadowvale":
|
|
shadowvale_citizens.append(citizen)
|
|
else:
|
|
other_expansion_citizens.append(citizen)
|
|
self.citizen_stack = shadowvale_citizens
|
|
self.graveyard.extend(other_expansion_citizens)
|
|
case "flamesandfrost":
|
|
flamesandfrost_monsters = []
|
|
other_expansion_monsters = []
|
|
for monster in self.monster_stack:
|
|
if monster.expansion == "flamesandfrost":
|
|
flamesandfrost_monsters.append(monster)
|
|
else:
|
|
other_expansion_monsters.append(monster)
|
|
self.monster_stack = flamesandfrost_monsters
|
|
self.graveyard.extend(other_expansion_monsters)
|
|
flamesandfrost_citizens = []
|
|
other_expansion_citizens = []
|
|
for citizen in self.citizen_stack:
|
|
if citizen.expansion == "flamesandfrost":
|
|
flamesandfrost_citizens.append(citizen)
|
|
else:
|
|
other_expansion_citizens.append(citizen)
|
|
self.citizen_stack = flamesandfrost_citizens
|
|
self.graveyard.extend(other_expansion_citizens)
|
|
case _:
|
|
if self.player_count != 5:
|
|
for stack in self.monster_grid:
|
|
# Remove monsters with isExtra = True from each stack
|
|
stack[:] = [monster for monster in stack if not monster.is_extra]
|
|
# end remove extra cards
|
|
# create players and determine order
|
|
for player in player_list_from_lobby:
|
|
my_player = Player(player.player_id, player.name)
|
|
self.player_list.append(my_player)
|
|
random.shuffle(self.player_list)
|
|
self.player_list[0].is_first = True
|
|
# give players starters and dukes
|
|
for player in self.player_list:
|
|
player.owned_starters.append(self.starter_stack[0])
|
|
player.owned_starters.append(self.starter_stack[1])
|
|
for i in range(number_of_dukes):
|
|
player.owned_dukes.append(self.duke_stack.pop())
|
|
# deal monsters onto the board
|
|
grouped_monsters = {}
|
|
for monster in self.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]
|
|
self.monster_grid[i].extend(monsters)
|
|
for i, stack in enumerate(self.monster_grid):
|
|
for monster in stack:
|
|
monster.toggle_visibility(True)
|
|
# Make the last monster in the stack accessible
|
|
stack[-1].toggle_accessibility(True)
|
|
self.monster_stack = []
|
|
# 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 self.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]
|
|
self.citizen_grid[index].extend(list(citizens))
|
|
# Make the first citizen in each list accessible
|
|
self.citizen_grid[index][-1].toggle_accessibility(True)
|
|
self.citizen_stack = []
|
|
# Deal the domains into the stacks
|
|
for i in range(5):
|
|
stack = self.domain_grid[i]
|
|
for j in range(3):
|
|
if j == 2: # top domain is visible and accessible
|
|
domain = self.domain_stack.pop()
|
|
domain.toggle_visibility(True)
|
|
domain.toggle_accessibility(True)
|
|
stack.append(domain)
|
|
else: # other domains are not visible or accessible
|
|
domain = self.domain_stack.pop()
|
|
stack.append(domain)
|
|
self.get_game_state()
|
|
|
|
def get_game_state(self):
|
|
for i, monster_list in enumerate(self.monster_grid):
|
|
print(
|
|
f"Monster Stack {i + 1}: {[f'{monster.name} ({monster.monster_id})' + ('E' if monster.is_extra else '') + ('V' if monster.is_visible else '') + ('A' if monster.is_accessible else '') for monster in monster_list]}")
|
|
for i, citizen_list in enumerate(self.citizen_grid):
|
|
print(
|
|
f"Citizen Stack {i + 1}: {[f'{citizen.name} ({citizen.citizen_id})' + ('V' if citizen.is_visible else '') + ('A' if citizen.is_accessible else '') for citizen in citizen_list]}")
|
|
for i, domain_list in enumerate(self.domain_grid):
|
|
print(
|
|
f"Domain Stack {i + 1}: {[f'{domain.name} ({domain.domain_id})' + ('V' if domain.is_visible else '') + ('A' if domain.is_accessible else '') for domain in domain_list]}")
|
|
for i, player in enumerate(self.player_list):
|
|
print(
|
|
f"Player {i + 1}: {[f'{player.player_id}' + (' *' if player.is_first else '') + f' G{player.gold_score} S{player.strength_score} M{player.magic_score}']}")
|
|
print(f"monster stack size {len(self.monster_stack)}")
|
|
print(f"citizen stack size {len(self.citizen_stack)}")
|
|
print(f"domain stack size {len(self.domain_stack)}")
|
|
print(f"graveyard stack size {len(self.graveyard)}")
|
|
|
|
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}")
|
|
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):
|
|
print(f"{citizen.name} Payout")
|
|
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
|
|
list_iterator = iter(self.player_list)
|
|
next(list_iterator)
|
|
for player in list_iterator:
|
|
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):
|
|
print(f"{citizen.name} Payout")
|
|
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
|
|
|
|
def play_turn(self):
|
|
self.roll_phase()
|
|
|
|
def end_check(self):
|
|
if self.exhausted_count <= (self.player_count * 2):
|
|
return False
|
|
|
|
|
|
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,
|
|
'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
|
|
}
|
|
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_count": obj.player_count,
|
|
"preset": obj.preset,
|
|
"number_of_dukes": obj.number_of_dukes,
|
|
"player_list": obj.player_list,
|
|
"monster_grid": obj.monster_grid,
|
|
"citizen_grid": obj.citizen_grid,
|
|
"domain_grid": obj.domain_grid,
|
|
"duke_stack": obj.duke_stack,
|
|
"domain_stack": obj.domain_stack,
|
|
"citizen_stack": obj.citizen_stack,
|
|
"monster_stack": obj.monster_stack,
|
|
"starter_stack": obj.starter_stack,
|
|
"graveyard": obj.graveyard,
|
|
"die_one": obj.die_one,
|
|
"die_two": obj.die_two,
|
|
"die_sum": obj.die_sum,
|
|
"exhausted_count": obj.exhausted_count
|
|
}
|
|
else:
|
|
return super().default(obj)
|
|
|