370 lines
10 KiB
Python
370 lines
10 KiB
Python
import random
|
|
from typing import Dict, List, Optional
|
|
from dataclasses import dataclass
|
|
import sys
|
|
from logger import log
|
|
from fuzzywuzzy import process
|
|
|
|
@dataclass
|
|
class Player:
|
|
name: str
|
|
role: str
|
|
alive: bool = True
|
|
protected: bool = False
|
|
|
|
|
|
class Game:
|
|
def __init__(self):
|
|
# single source of truth: name -> Player
|
|
self.players: Dict[str, Player] = {}
|
|
|
|
# lovers
|
|
self.lovers: Optional[Tuple[str, str]] = None
|
|
|
|
# Dead this night
|
|
self.dead_this_night: [List[str]] = []
|
|
|
|
# Used potions
|
|
self.used_potions: [list[str]] = []
|
|
# -------------------------
|
|
# setup / I/O
|
|
# -------------------------
|
|
def load_lists(self) -> Optional[Dict[str, List[str]]]:
|
|
"""
|
|
Load players and roles from files and return them as lists.
|
|
Returns dict with keys 'players' and 'roles'.
|
|
"""
|
|
players_file = "players.txt"
|
|
roles_file = "roles.txt"
|
|
|
|
log.info("Loading lists...")
|
|
|
|
try:
|
|
with open(players_file, "r", encoding="utf-8") as pf:
|
|
player_names = [line.strip() for line in pf if line.strip()]
|
|
except FileNotFoundError:
|
|
log.critical("Players file not found: %s", players_file)
|
|
return None
|
|
|
|
try:
|
|
with open(roles_file, "r", encoding="utf-8") as rf:
|
|
roles_list = [line.strip() for line in rf if line.strip()]
|
|
except FileNotFoundError:
|
|
log.critical("Roles file not found: %s", roles_file)
|
|
return None
|
|
|
|
log.info("Load complete!")
|
|
|
|
return {"players": player_names, "roles": roles_list}
|
|
|
|
# -------------------------
|
|
# player / role assignment
|
|
# -------------------------
|
|
def give_roles_to_players(self, player_names: Optional[List[str]] = None,
|
|
roles_list: Optional[List[str]] = None) -> None:
|
|
"""
|
|
Assign a random role to each player. Accepts optional lists (returned by load_lists).
|
|
If lists are not supplied, it will attempt to read files itself.
|
|
"""
|
|
|
|
if not player_names:
|
|
log.info("Players are not initialized")
|
|
return
|
|
if not roles_list:
|
|
log.info("Roles are not initialized")
|
|
return
|
|
if len(roles_list) < len(player_names):
|
|
log.error("Not enough roles for players (roles: %d, players: %d)",
|
|
len(roles_list), len(player_names))
|
|
return
|
|
|
|
available_roles = list(roles_list)
|
|
random.shuffle(available_roles)
|
|
|
|
# clear any existing players (safe to reassign)
|
|
self.players.clear()
|
|
|
|
for name in player_names:
|
|
chosen_role = available_roles.pop()
|
|
self.players[name] = Player(name=name, role=chosen_role)
|
|
|
|
log.debug("Assigned roles:")
|
|
for player in self.players.values():
|
|
log.debug("%s: %s", player.name, player.role)
|
|
|
|
# -------------------------
|
|
# utilities
|
|
# -------------------------
|
|
def select_someone(self, prompt: Optional[str] = None) -> Optional[str]:
|
|
"""
|
|
Prompt the user to enter a player name until a valid one is entered.
|
|
Returns None on EOF/KeyboardInterrupt.
|
|
"""
|
|
prompt = prompt or "Enter the name of the player: "
|
|
while True:
|
|
selected = input(prompt).strip()
|
|
|
|
# exact match
|
|
if selected in self.players:
|
|
return selected
|
|
|
|
# fuzzy matching
|
|
match = process.extract(selected, self.players, limit=1)
|
|
log.debug(match)
|
|
if match:
|
|
fuzz_player, fuzz_score = match[0][0], match[0][1] # player name, score
|
|
log.debug(fuzz_player)
|
|
log.debug(fuzz_score)
|
|
if fuzz_score >= 60:
|
|
log.info("You meant %s!", fuzz_player.name)
|
|
log.debug("Fuzz score: %s" % fuzz_score)
|
|
return fuzz_player.name
|
|
|
|
def choose_between(self, options):
|
|
#Prompt the user to choose between options until a valid one is entered
|
|
|
|
options_available = ', '.join(map(str, options))
|
|
#Make a prompt with a list of options, accepting either a list or a tuple.
|
|
prompt = f"Choose between {options_available}: "
|
|
while True:
|
|
selected = input(prompt)
|
|
|
|
if selected in options:
|
|
return selected
|
|
|
|
# fuzzy matching
|
|
match = process.extract(selected, options, limit=1)
|
|
log.debug(match)
|
|
if match:
|
|
fuzz_option, fuzz_score = match[0][0], match[0][1] #options, score
|
|
log.debug(fuzz_option)
|
|
log.debug(fuzz_score)
|
|
if fuzz_score >= 60:
|
|
log.info("You meant %s!", fuzz_option)
|
|
log.debug("Fuzz score: %s" % fuzz_score)
|
|
return fuzz_option
|
|
|
|
|
|
# -------------------------
|
|
# game actions
|
|
# -------------------------
|
|
def put_in_love(self, player1: str, player2: str) -> None:
|
|
"""Link two players such that if one dies the other dies too."""
|
|
if player1 not in self.players or player2 not in self.players:
|
|
log.error("One or both players do not exist: %s, %s", player1, player2)
|
|
return
|
|
|
|
self.lovers = (player1, player2)
|
|
|
|
log.debug("Players now put in love: %s <-> %s", player1, player2)
|
|
|
|
log.info("They are now bounded by love.")
|
|
log.info("They wake up and reveal their role to each other.")
|
|
log.info("Those two go back to sleep.")
|
|
|
|
|
|
def kill(self, player: str) -> None:
|
|
"""Kill a player."""
|
|
if player not in self.players:
|
|
log.error("Couldn't kill unknown player: %s", player)
|
|
return
|
|
|
|
target = self.players[player]
|
|
|
|
# already dead?
|
|
if not target.alive:
|
|
log.error("%s is already dead!", player)
|
|
return
|
|
|
|
# protected?
|
|
if target.protected:
|
|
log.debug("%s was protected and survives.", player)
|
|
return
|
|
|
|
# in love?
|
|
if player in self.lovers:
|
|
log.debug("%s is in love! Killing them and their lover.", player)
|
|
for p in self.lovers:
|
|
# kill them and their lover
|
|
log.debug("Killed %s", p)
|
|
self.dead_this_night.append(p)
|
|
self.players[p].alive = False
|
|
return
|
|
|
|
# else just kill them
|
|
log.info("Killed %s" % player)
|
|
self.dead_this_night.append(player)
|
|
target.alive = False
|
|
|
|
def revive(self, player: str) -> None:
|
|
"""Revive a player."""
|
|
log.info("Players that will die this night are: %s", self.dead_this_night)
|
|
if player not in self.players:
|
|
log.error("Tried to revive unknown player: %s", player)
|
|
return
|
|
p = self.players[player]
|
|
if not p.alive:
|
|
p.alive = True
|
|
log.info("%s has been revived.", player)
|
|
else:
|
|
log.info("%s is already alive.", player)
|
|
|
|
# -------------------------
|
|
# helpers
|
|
# -------------------------
|
|
def status(self) -> None:
|
|
"""Log current players' statuses for debugging."""
|
|
|
|
# player values
|
|
for p in self.players.values():
|
|
log.debug("%s -> role: %s, alive: %s, Protected: %s",
|
|
p.name, p.role, p.alive, p.protected)
|
|
# lovers
|
|
log.debug("Lovers: %s" % ",".join(self.lovers))
|
|
|
|
def role(func):
|
|
"""Decorator for roles"""
|
|
def wrapper(*args, **kwargs):
|
|
# the role is the name of the function thats decorated
|
|
role = func.__name__.capitalize()
|
|
log.info("%s wakes up." % role)
|
|
func(*args, **kwargs)
|
|
log.info("%s goes back to sleep." % role)
|
|
|
|
# workaround to call status from the instance
|
|
# is it ok? no idea but i dont have self anyway
|
|
instance = args[0]
|
|
instance.status()
|
|
|
|
return wrapper
|
|
|
|
# -------------------------
|
|
# roles
|
|
# -------------------------
|
|
|
|
@role
|
|
def cupidon(self) -> None:
|
|
"""Interactively pick two players to link by love."""
|
|
log.info("Choose two people to be linked to death.")
|
|
log.info("Give me the first person that shall be bounded!")
|
|
p1 = self.select_someone()
|
|
if p1 is None:
|
|
return
|
|
log.info("What about the second one?")
|
|
p2 = self.select_someone()
|
|
if p2 is None:
|
|
return
|
|
if p1 == p2:
|
|
log.info("Cannot link a player to themselves.")
|
|
return
|
|
self.put_in_love(p1, p2)
|
|
|
|
@role
|
|
def savior(self) -> None:
|
|
"""Interactively choose someone to protect."""
|
|
log.info("Choose someone to protect.")
|
|
protected = self.select_someone()
|
|
if protected is None:
|
|
return
|
|
|
|
self.players[protected].protected = True
|
|
log.debug("Protected: %s", protected)
|
|
|
|
@role
|
|
def witch(self) -> None:
|
|
"""Interactively choose to kill or revive someone"""
|
|
log.info("With the Revive Potion, you can revive someone, and with the Death Potion, you can kill someone. You can only use each potion once, and you can also choose to do nothing.")
|
|
log.info("Players who might die are %s", ' '.join(map(str, self.dead_this_night)))
|
|
if len(self.used_potions) >= 2:
|
|
log.info("You already used all of your potions. ")
|
|
else:
|
|
while True:
|
|
options = ("Death", "Revive", "Nothing")
|
|
potionchoice = self.choose_between(options).capitalize()
|
|
if potionchoice == "Revive" and "Revive" not in self.used_potions:
|
|
player = self.select_someone()
|
|
if player in self.dead_this_night:
|
|
self.used_potions.append("Revive")
|
|
self.revive(player)
|
|
return
|
|
elif player not in self.dead_this_night and not self.players[player].alive:
|
|
log.info("You cannot bring this person back to life because they have been buried.")
|
|
elif self.players[player].alive:
|
|
log.info("This player is not dead.")
|
|
else:
|
|
log.info("Unknown error: Invalid player choice")
|
|
return
|
|
elif potionchoice == "Death" and "Death" not in self.used_potions:
|
|
player = self.select_someone()
|
|
if self.players[player].alive:
|
|
self.used_potions.append("Death")
|
|
self.kill(player)
|
|
return
|
|
elif not self.players[player].alive:
|
|
log.info("This player is already dead.")
|
|
else:
|
|
log.info("Unknown error: Invalid player choice")
|
|
return
|
|
elif potionchoice == "Nothing":
|
|
log.info("You are not doing anything tonight.")
|
|
return
|
|
elif potionchoice in self.used_potions:
|
|
log.info("You already used this potion.")
|
|
else:
|
|
log.critical("Unknown error: Invalid potion choice.")
|
|
return
|
|
@role
|
|
def werewolf(self) -> None:
|
|
log.info("You will choose someone to kill.")
|
|
player = self.select_someone()
|
|
self.kill(player)
|
|
|
|
@role
|
|
def seer(self) -> None:
|
|
log.info("Choose a player to discover their role.")
|
|
while True:
|
|
player = self.select_someone()
|
|
if "Seer" == self.players[player].role:
|
|
log.info("You can't see your own role.")
|
|
else:
|
|
log.info(f"{player} is a {self.players[player].role}")
|
|
return
|
|
# -------------------------
|
|
# game flow
|
|
# -------------------------
|
|
def first_day_cycle(self) -> None:
|
|
log.info("All the villagers fall asleep.")
|
|
self.cupidon()
|
|
self.savior()
|
|
self.werewolf()
|
|
self.witch()
|
|
self.seer()
|
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
print("---\nWerewolfGame\n---")
|
|
|
|
# instantiate the game
|
|
game = Game()
|
|
|
|
# I/O: read files and assign roles
|
|
loaded = game.load_lists()
|
|
try:
|
|
if loaded:
|
|
# start the game!
|
|
game.give_roles_to_players(loaded["players"], loaded["roles"])
|
|
game.first_day_cycle()
|
|
|
|
# CTRL+C
|
|
except KeyboardInterrupt:
|
|
print() # new line
|
|
log.info("Bye bye!")
|
|
sys.exit(0)
|
|
|
|
# Any unhandled exception
|
|
except Exception as e:
|
|
log.exception("Unhandled exception: %s" % e)
|
|
sys.exit(1)
|
|
|