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

185
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
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.gold_score = player.gold_score + citizen.gold_payout_off_turn
player.strength_score = player.strength_score + citizen.strength_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 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

19
server.py
View File

@@ -264,17 +264,19 @@ 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
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: for player in player_list_from_lobby:
my_player = Player(player.player_id, player.name) my_player = Player(player.player_id, player.name)
player_list.append(my_player) player_list.append(my_player)
@@ -348,7 +350,6 @@ def load_game_data(game_id, preset, player_list_from_lobby):
'exhausted_count': exhausted_count, 'exhausted_count': exhausted_count,
'effects': effects, 'effects': effects,
'action_required': action_required} 'action_required': action_required}
# Return the dictionary # Return the dictionary
return game_state return game_state

35
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]
try:
base1_new_game_state = load_game_data(str(uuid.uuid4()), "base1", player_list) base1_new_game_state = load_game_data(str(uuid.uuid4()), "base1", player_list)
game_board = Game(base1_new_game_state) game = Game(base1_new_game_state)
game_board.play_turn() game.hire_citizen(player1_id, 1, 0, 0)
game_json = json.dumps(game_board, cls=GameObjectEncoder, indent=2) game.hire_citizen(player1_id, 3, 0, 0)
with open("gamestate.txt", "w") as dump: 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) dump.write(game_json)
except ValueError:
print("Error: Failed to load game data")