lukesau/basegame-vcko
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

all citizen payouts for base1 work

Browse Source
This commit is contained in:
Luke Esau
2023-05-04 18:04:09 -07:00
parent 56782e5560
commit 1dea2cf324
5 changed files with 253 additions and 2520 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -40,6 +40,7 @@ __pycache__/
# Distribution / packaging # Distribution / packaging
gamestate.txt gamestate.txt
game_state.txt
python3-vckonline/ python3-vckonline/
.idea/ .idea/
.Python .Python

191
common.py
View File

@@ -1,7 +1,6 @@
import json import json
import time import time
from json import JSONEncoder, JSONDecoder from json import JSONEncoder, JSONDecoder
import mysql.connector
import random import random
from typing import List, Dict from typing import List, Dict
from constants import * from constants import *
@@ -98,6 +97,7 @@ class Player:
} }
return roles_dict return roles_dict
class Starter(Card): class Starter(Card):
def __init__(self, starter_id, name, roll_match1, roll_match2, gold_payout_on_turn, gold_payout_off_turn, 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, strength_payout_on_turn, strength_payout_off_turn, magic_payout_on_turn, magic_payout_off_turn,
@@ -106,36 +106,36 @@ class Starter(Card):
super().__init__() super().__init__()
self.starter_id = starter_id self.starter_id = starter_id
self.name = name self.name = name
self.rollMatch1 = roll_match1 self.roll_match1 = roll_match1
self.rollMatch2 = roll_match2 self.roll_match2 = roll_match2
self.goldPayoutOnTurn = gold_payout_on_turn self.gold_payout_on_turn = gold_payout_on_turn
self.goldPayoutOffTurn = gold_payout_off_turn self.gold_payout_off_turn = gold_payout_off_turn
self.strengthPayoutOnTurn = strength_payout_on_turn self.strength_payout_on_turn = strength_payout_on_turn
self.strengthPayoutOffTurn = strength_payout_off_turn self.strength_payout_off_turn = strength_payout_off_turn
self.magicPayoutOnTurn = magic_payout_on_turn self.magic_payout_on_turn = magic_payout_on_turn
self.magicPayoutOffTurn = magic_payout_off_turn self.magic_payout_off_turn = magic_payout_off_turn
self.hasSpecialPayoutOnTurn = has_special_payout_on_turn self.has_special_payout_on_turn = has_special_payout_on_turn
self.hasSpecialPayoutOffTurn = has_special_payout_off_turn self.has_special_payout_off_turn = has_special_payout_off_turn
self.specialPayoutOnTurn = special_payout_on_turn self.special_payout_on_turn = special_payout_on_turn
self.specialPayoutOffTurn = special_payout_off_turn self.special_payout_off_turn = special_payout_off_turn
self.expansion = expansion self.expansion = expansion
def to_dict(self): def to_dict(self):
return { return {
"starter_id": self.starter_id, "starter_id": self.starter_id,
"name": self.name, "name": self.name,
"roll_match1": self.rollMatch1, "roll_match1": self.roll_match1,
"roll_match2": self.rollMatch2, "roll_match2": self.roll_match2,
"gold_payout_on_turn": self.goldPayoutOnTurn, "gold_payout_on_turn": self.gold_payout_on_turn,
"gold_payout_off_turn": self.goldPayoutOffTurn, "gold_payout_off_turn": self.gold_payout_off_turn,
"strength_payout_on_turn": self.strengthPayoutOnTurn, "strength_payout_on_turn": self.strength_payout_on_turn,
"strength_payout_off_turn": self.strengthPayoutOffTurn, "strength_payout_off_turn": self.strength_payout_off_turn,
"magic_payout_on_turn": self.magicPayoutOnTurn, "magic_payout_on_turn": self.magic_payout_on_turn,
"magic_payout_off_turn": self.magicPayoutOffTurn, "magic_payout_off_turn": self.magic_payout_off_turn,
"has_special_payout_on_turn": self.hasSpecialPayoutOnTurn, "has_special_payout_on_turn": self.has_special_payout_on_turn,
"has_special_payout_off_turn": self.hasSpecialPayoutOffTurn, "has_special_payout_off_turn": self.has_special_payout_off_turn,
"special_payout_on_turn": self.specialPayoutOnTurn, "special_payout_on_turn": self.special_payout_on_turn,
"special_payout_off_turn": self.specialPayoutOffTurn, "special_payout_off_turn": self.special_payout_off_turn,
"expansion": self.expansion "expansion": self.expansion
} }
@@ -180,6 +180,7 @@ class Citizen(Card):
def get_special_payout_on_turn(self): def get_special_payout_on_turn(self):
return self.special_payout_on_turn return self.special_payout_on_turn
def to_dict(self): def to_dict(self):
base_dict = super().to_dict() base_dict = super().to_dict()
return {**base_dict, return {**base_dict,
@@ -453,43 +454,99 @@ class Game:
def harvest_phase(self): def harvest_phase(self):
# steal activates first # 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: for citizen in self.player_list[0].owned_citizens:
if (citizen.roll_match1 == self.die_one) or (citizen.roll_match1 == self.die_two) or ( 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): citizen.roll_match1 == self.die_sum) or (citizen.roll_match2 == self.die_sum):
count = 1 count = 1
if self.die_one == self.die_two: if citizen.roll_match1 == self.die_one == self.die_two:
count = 2 count = 2
print(f"{citizen.name} Payout") print(f"Payout for {self.player_list[0].name}: Citizen {citizen.name}{' x2' if count == 2 else ''}")
for i in range(count): 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].gold_score = self.player_list[0].gold_score + citizen.gold_payout_on_turn
self.player_list[0].strength_score = self.player_list[ self.player_list[0].strength_score = self.player_list[
0].strength_score + citizen.strength_payout_on_turn 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 self.player_list[0].magic_score = self.player_list[0].magic_score + citizen.magic_payout_on_turn
if citizen.has_special_payout_on_turn: if citizen.has_special_payout_on_turn:
payout = self.execute_special_payout(citizen.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) 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 list_iterator = iter(self.player_list) # skip first player when paying out the rest of the board
next(list_iterator) next(list_iterator)
for player in 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: for citizen in player.owned_citizens:
if (citizen.roll_match1 == self.die_one) or (citizen.roll_match1 == self.die_two) or ( 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): citizen.roll_match1 == self.die_sum) or (citizen.roll_match2 == self.die_sum):
print(f"{citizen.name} Payout") count = 1
player.gold_score = player.gold_score + citizen.gold_payout_off_turn if citizen.roll_match1 == self.die_one == self.die_two:
player.strength_score = player.strength_score + citizen.strength_payout_off_turn count = 2
player.magic_score = player.magic_score + citizen.magic_payout_off_turn 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): 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 payout = [0, 0, 0, 0] # gp, sp, mp, vp, todo: citizen, monster, domain
split_command = command.split() split_command = command.split()
first_word = split_command[0] first_word = split_command[0]
second_word = split_command[1] second_word = split_command[1]
third_word = split_command[2] third_word = split_command[2]
fourth_word = split_command[3] fourth_word = split_command[3]
fifth_word = split_command[4]
match first_word: match first_word:
case "count": case "count":
print("Matched count")
match second_word: match second_word:
case "owned_shadow": case "owned_shadow":
self.update_payout_for_role('shadow_count', player_id, payout, split_command) self.update_payout_for_role('shadow_count', player_id, payout, split_command)
@@ -498,6 +555,7 @@ class Game:
case "owned_soldier": case "owned_soldier":
self.update_payout_for_role('soldier_count', player_id, payout, split_command) self.update_payout_for_role('soldier_count', player_id, payout, split_command)
case "owned_worker": case "owned_worker":
self.update_payout_for_role('worker_count', player_id, payout, split_command) self.update_payout_for_role('worker_count', player_id, payout, split_command)
case "owned_monsters": case "owned_monsters":
self.update_payout_for_role('owned_monsters', player_id, payout, split_command) self.update_payout_for_role('owned_monsters', player_id, payout, split_command)
@@ -508,40 +566,44 @@ class Game:
case _: case _:
payout[0] = -9999 payout[0] = -9999
case "exchange": case "exchange":
print("Matched exchange")
match second_word: match second_word:
case 'g': case 'g':
payout[0] = payout[0] - third_word payout[0] = payout[0] - int(third_word)
case 's': case 's':
payout[1] = payout[1] - third_word payout[1] = payout[1] - int(third_word)
case 'm': case 'm':
payout[2] = payout[2] - third_word payout[2] = payout[2] - int(third_word)
case 'v': case 'v':
payout[3] = payout[3] - third_word payout[3] = payout[3] - int(third_word)
case _: case _:
payout[0] = -9999 payout[0] = -9999
match fourth_word: match fourth_word:
case 'g': case 'g':
payout[0] = payout[0] + fifth_word payout[0] = payout[0] + int(split_command[4])
case 's': case 's':
payout[1] = payout[1] + fifth_word payout[1] = payout[1] + int(split_command[4])
case 'm': case 'm':
payout[2] = payout[2] + fifth_word payout[2] = payout[2] + int(split_command[4])
case 'v': case 'v':
payout[3] = payout[3] + fifth_word payout[3] = payout[3] + int(split_command[4])
case _: case _:
payout[0] = -9999 payout[0] = -9999
case "choose": case "choose":
# need to pause execution here until we get player input print("Matched choose")
self.action_required['player_id'] = player_id self.action_required['player_id'] = player_id
self.action_required['action'] = command self.action_required['action'] = command
# need to pause execution here until we get player input
while self.action_required['player_id'] != self.game_id: while self.action_required['player_id'] != self.game_id:
time.sleep(1) time.sleep(1)
choice = [] choice = []
match self.action_required['action']: match self.action_required['action']:
case 'choose left': case 'choose 1':
choice = [second_word, third_word] choice = [second_word, third_word]
case 'choose right': case 'choose 2':
choice = [fourth_word, fifth_word] choice = [fourth_word, fifth_word]
case 'choose 3':
choice = [split_command[5], split_command[6]] # [sixth_word, seventh_word]
case _: case _:
payout[0] = -9999 payout[0] = -9999
match choice[0]: match choice[0]:
@@ -557,6 +619,7 @@ class Game:
payout[0] = -9999 payout[0] = -9999
case _: case _:
payout[0] = -9999 payout[0] = -9999
print(payout)
return payout return payout
def update_payout_for_role(self, role_name, player_id, payout, split_command): def update_payout_for_role(self, role_name, player_id, payout, split_command):
@@ -568,28 +631,50 @@ class Game:
if role_count > 0: if role_count > 0:
match split_command[2]: match split_command[2]:
case 'g': case 'g':
payout[0] = split_command[3] * role_count payout[0] = int(split_command[3]) * role_count
case 's': case 's':
payout[1] = split_command[3] * role_count payout[1] = int(split_command[3]) * role_count
case 'm': case 'm':
payout[2] = split_command[3] * role_count payout[2] = int(split_command[3]) * role_count
case 'v': case 'v':
payout[3] = split_command[3] * role_count payout[3] = int(split_command[3]) * role_count
case _: case _:
payout[0] = -9999 payout[0] = -9999
else: else:
payout[0] = -9999 payout[0] = -9999
def hire_citizen(self, citizen_id, gp, mp=0): def hire_citizen(self, player_id, citizen_id, gp, mp=0):
available_citizens = []
for citizen_stack in self.citizen_grid: for citizen_stack in self.citizen_grid:
for citizen in citizen_stack: for citizen in citizen_stack:
if citizen.citizen_id == citizen_id and citizen.is_accessible: if citizen.citizen_id == citizen_id and citizen.is_accessible:
self.player_list[0].gold_score = self.player_list[0].gold_score - gp for player in self.player_list:
self.player_list[0].magic_score = self.player_list[0].magic_score - mp if player.player_id == player_id:
self.player_list[0].owned_citizens.append(citizen_stack.pop(-1)) 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) citizen_stack[-1].toggle_accessibility(True)
def slay_monster(self, player_id, monster_id, sp, mp=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))
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): def action_phase(self):
return return

2377
gamestate.txt
View File

File diff suppressed because it is too large Load Diff

165
server.py
View File

@@ -264,93 +264,94 @@ def load_game_data(game_id, preset, player_list_from_lobby):
row['has_special_payout_on_turn'], row['has_special_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']) row['special_payout_on_turn'], row['special_payout_off_turn'], row['expansion'])
starter_stack.append(my_starter) starter_stack.append(my_starter)
except Exception as e:
print(f"Error: {e}")
finally:
my_cursor.close() my_cursor.close()
my_connect.close() my_connect.close()
print(f"size of monster stack: {len(monster_stack)}") except Exception as e:
print(f"size of citizen stack: {len(citizen_stack)}") print(f"Error: {e}")
print(f"size of domain stack: {len(domain_stack)}") # print(f"size of monster stack: {len(monster_stack)}")
print(f"size of duke stack: {len(duke_stack)}") # print(f"size of citizen stack: {len(citizen_stack)}")
print(f"size of starter stack: {len(starter_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 # create players and determine order
for player in player_list_from_lobby: if not all([player_list_from_lobby, starter_query, monster_stack, citizen_stack, domain_stack, duke_stack]):
my_player = Player(player.player_id, player.name) raise ValueError("One or more required lists are empty.")
player_list.append(my_player) else:
random.shuffle(player_list) for player in player_list_from_lobby:
player_list[0].is_first = True my_player = Player(player.player_id, player.name)
# give players starters and dukes player_list.append(my_player)
for player in player_list: random.shuffle(player_list)
player.owned_starters.append(starter_stack[0]) player_list[0].is_first = True
player.owned_starters.append(starter_stack[1]) # give players starters and dukes
for i in range(2): for player in player_list:
player.owned_dukes.append(duke_stack.pop()) player.owned_starters.append(starter_stack[0])
# deal monsters onto the board player.owned_starters.append(starter_stack[1])
grouped_monsters = {} for i in range(2):
for monster in monster_stack: player.owned_dukes.append(duke_stack.pop())
area = monster.area # deal monsters onto the board
if area in grouped_monsters: grouped_monsters = {}
grouped_monsters[area].append(monster) for monster in monster_stack:
else: area = monster.area
grouped_monsters[area] = [monster] if area in grouped_monsters:
# Reverse the order of each group by monster_order grouped_monsters[area].append(monster)
for area, monsters in grouped_monsters.items(): else:
monsters.sort(key=lambda item: item.order, reverse=True) grouped_monsters[area] = [monster]
areas = list(grouped_monsters.keys()) # Reverse the order of each group by monster_order
chosen_areas = random.sample(areas, 5) for area, monsters in grouped_monsters.items():
for i, area in enumerate(chosen_areas): monsters.sort(key=lambda item: item.order, reverse=True)
monsters = grouped_monsters[area] areas = list(grouped_monsters.keys())
monster_grid[i].extend(monsters) chosen_areas = random.sample(areas, 5)
for i, stack in enumerate(monster_grid): for i, area in enumerate(chosen_areas):
for monster in stack: monsters = grouped_monsters[area]
monster.toggle_visibility(True) monster_grid[i].extend(monsters)
# Make the last monster in the stack accessible for i, stack in enumerate(monster_grid):
stack[-1].toggle_accessibility(True) for monster in stack:
monster_stack = [] monster.toggle_visibility(True)
# deal citizens onto the board # Make the last monster in the stack accessible
# Create a dictionary to store citizen lists with roll numbers as keys stack[-1].toggle_accessibility(True)
citizens_by_roll = {roll: [] for roll in [1, 2, 3, 4, 5, 6, 7, 8, 9, 11]} monster_stack = []
# Group citizens by roll number # deal citizens onto the board
for citizen in citizen_stack: # Create a dictionary to store citizen lists with roll numbers as keys
citizen.toggle_visibility() citizens_by_roll = {roll: [] for roll in [1, 2, 3, 4, 5, 6, 7, 8, 9, 11]}
citizens_by_roll[citizen.roll_match1].append(citizen) # Group citizens by roll number
for roll in citizens_by_roll: for citizen in citizen_stack:
# Map 11 roll to index 9 citizen.toggle_visibility()
index = roll - 1 if roll < 11 else 9 citizens_by_roll[citizen.roll_match1].append(citizen)
citizens = citizens_by_roll[roll] for roll in citizens_by_roll:
citizen_grid[index].extend(list(citizens)) # Map 11 roll to index 9
# Make the first citizen in each list accessible index = roll - 1 if roll < 11 else 9
citizen_grid[index][-1].toggle_accessibility(True) citizens = citizens_by_roll[roll]
citizen_stack = [] citizen_grid[index].extend(list(citizens))
# Deal the domains into the stacks # Make the first citizen in each list accessible
for i in range(5): citizen_grid[index][-1].toggle_accessibility(True)
stack = domain_grid[i] citizen_stack = []
for j in range(3): # Deal the domains into the stacks
if j == 2: # top domain is visible and accessible for i in range(5):
domain = domain_stack.pop() stack = domain_grid[i]
domain.toggle_visibility(True) for j in range(3):
domain.toggle_accessibility(True) if j == 2: # top domain is visible and accessible
stack.append(domain) domain = domain_stack.pop()
else: # other domains are not visible or accessible domain.toggle_visibility(True)
domain = domain_stack.pop() domain.toggle_accessibility(True)
stack.append(domain) stack.append(domain)
else: # other domains are not visible or accessible
# Create a dictionary to store all the stacks domain = domain_stack.pop()
game_state = {'game_id': game_id, stack.append(domain)
'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}
# 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 the dictionary
return game_state return game_state
if __name__ == '__main__': if __name__ == '__main__':

39
vckonline.py
View File

@@ -1,11 +1,34 @@
from common import * from common import *
from server import load_game_data from server import load_game_data
player1 = Player(shortuuid.uuid(), "Player 1") player1_id = shortuuid.uuid()
player2 = Player(shortuuid.uuid(), "Player 2") player2_id = shortuuid.uuid()
player1 = Player(player1_id, "Player 1")
player2 = Player(player2_id, "Player 2")
player_list = [player1, player2] player_list = [player1, player2]
base1_new_game_state = load_game_data(str(uuid.uuid4()), "base1", player_list) try:
game_board = Game(base1_new_game_state) base1_new_game_state = load_game_data(str(uuid.uuid4()), "base1", player_list)
game_board.play_turn() game = Game(base1_new_game_state)
game_json = json.dumps(game_board, cls=GameObjectEncoder, indent=2) game.hire_citizen(player1_id, 1, 0, 0)
with open("gamestate.txt", "w") as dump: game.hire_citizen(player1_id, 3, 0, 0)
dump.write(game_json) game.hire_citizen(player1_id, 4, 0, 0)
game.hire_citizen(player1_id, 5, 0, 0)
game.hire_citizen(player1_id, 6, 0, 0)
game.hire_citizen(player1_id, 7, 0, 0)
game.hire_citizen(player1_id, 8, 0, 0)
game.hire_citizen(player1_id, 9, 0, 0)
game.hire_citizen(player1_id, 10, 0, 0)
game.hire_citizen(player2_id, 1, 0, 0)
game.hire_citizen(player2_id, 3, 0, 0)
game.hire_citizen(player2_id, 4, 0, 0)
game.hire_citizen(player2_id, 5, 0, 0)
game.hire_citizen(player2_id, 6, 0, 0)
game.hire_citizen(player2_id, 7, 0, 0)
game.hire_citizen(player2_id, 8, 0, 0)
game.hire_citizen(player2_id, 9, 0, 0)
game.hire_citizen(player2_id, 10, 0, 0)
game.play_turn()
game_json = json.dumps(game, cls=GameObjectEncoder, indent=2)
with open("game_state.txt", "w") as dump:
dump.write(game_json)
except ValueError:
print("Error: Failed to load game data")