from __future__ import annotations from uuid import uuid4 from datetime import datetime from typing import Any, Dict, List from warchron.model.exception import ForbiddenOperation from warchron.model.war_participant import WarParticipant from warchron.model.objective import Objective from warchron.model.campaign_participant import CampaignParticipant from warchron.model.sector import Sector from warchron.model.campaign import Campaign from warchron.model.round import Round from warchron.model.choice import Choice from warchron.model.battle import Battle class War: def __init__(self, name: str, year: int) -> None: self.id: str = str(uuid4()) self.name: str = name self.year: int = year self.major_value: int = 2 self.minor_value: int = 1 self.influence_token: bool = True self.participants: Dict[str, WarParticipant] = {} self.objectives: Dict[str, Objective] = {} self.campaigns: List[Campaign] = [] self.is_over: bool = False def set_id(self, new_id: str) -> None: self.id = new_id def set_name(self, new_name: str) -> None: self.name = new_name def set_year(self, new_year: int) -> None: self.year = new_year def set_major_value(self, new_value: int) -> None: if self.is_over: raise ForbiddenOperation("Can't set major value of a closed war.") if new_value < self.minor_value: raise ValueError("Can' set major value < minor value") self.major_value = new_value def set_minor_value(self, new_value: int) -> None: if self.is_over: raise ForbiddenOperation("Can't set minor value of a closed war.") if new_value > self.major_value: raise ValueError("Can't set minor value > major value") self.minor_value = new_value def set_influence_token(self, new_state: bool) -> None: if self.is_over: raise ForbiddenOperation("Can't set influence token of a closed war.") self.influence_token = new_state def set_state(self, new_state: bool) -> None: self.is_over = new_state def toDict(self) -> Dict[str, Any]: return { "id": self.id, "name": self.name, "year": self.year, "major_value": self.major_value, "minor_value": self.minor_value, "influence_token": self.influence_token, "participants": [part.toDict() for part in self.participants.values()], "objectives": [obj.toDict() for obj in self.objectives.values()], "campaigns": [camp.toDict() for camp in self.campaigns], "is_over": self.is_over, } @staticmethod def fromDict(data: Dict[str, Any]) -> War: war = War(name=data["name"], year=data["year"]) war.set_id(data["id"]) war.set_major_value(data["major_value"]) war.set_minor_value(data["minor_value"]) war.set_influence_token(data["influence_token"]) for part_data in data.get("participants", []): part = WarParticipant.fromDict(part_data) war.participants[part.id] = part for obj_data in data.get("objectives", []): obj = Objective.fromDict(obj_data) war.objectives[obj.id] = obj for camp_data in data.get("campaigns", []): war.campaigns.append(Campaign.fromDict(camp_data)) war.set_state(data.get("is_over", False)) return war # Objective methods def add_objective(self, name: str, description: str | None) -> Objective: if self.is_over: raise ForbiddenOperation("Can't add objective in a closed war.") obj = Objective(name, description) self.objectives[obj.id] = obj return obj def get_objective(self, id: str) -> Objective: return self.objectives[id] def get_all_objectives(self) -> List[Objective]: return list(self.objectives.values()) def get_objective_name(self, objective_id: str | None) -> str: if objective_id is None: return "" obj = self.objectives.get(objective_id) return obj.name if obj else "" def update_objective( self, objective_id: str, *, name: str, description: str | None ) -> None: if self.is_over: raise ForbiddenOperation("Can't update objective in a closed war.") obj = self.get_objective(objective_id) obj.set_name(name) obj.set_description(description) def remove_objective(self, objective_id: str) -> None: if self.is_over: raise ForbiddenOperation("Can't remove objective in a closed war.") camp_using_obj: List[str] = [] for camp in self.campaigns: if camp.has_sector_with_objective(objective_id): camp_using_obj.append(camp.name) if camp_using_obj: camps_str = ", ".join(camp_using_obj) raise ForbiddenOperation( f"This objective is used in campaign(s) sector(s): {camps_str}.\n" "Remove it from campaign(s) first." ) del self.objectives[objective_id] # War participant methods def get_all_war_participants_ids(self) -> set[str]: return set(self.participants.keys()) def has_participant(self, participant_id: str) -> bool: return participant_id in self.participants def has_player(self, player_id: str) -> bool: return any(part.player_id == player_id for part in self.participants.values()) def add_war_participant(self, player_id: str, faction: str) -> WarParticipant: if self.is_over: raise ForbiddenOperation("Can't add participant in a closed war.") if self.has_player(player_id): raise ValueError("Player already registered in this war") participant = WarParticipant(player_id=player_id, faction=faction) self.participants[participant.id] = participant return participant def get_war_participant(self, id: str) -> WarParticipant: return self.participants[id] def get_all_war_participants(self) -> List[WarParticipant]: return list(self.participants.values()) def update_war_participant(self, participant_id: str, *, faction: str) -> None: if self.is_over: raise ForbiddenOperation("Can't update participant in a closed war.") part = self.get_war_participant(participant_id) # Can't change referred Model.players part.set_faction(faction) def remove_war_participant(self, participant_id: str) -> None: if self.is_over: raise ForbiddenOperation("Can't remove participant in a closed war.") camp_using_part: List[str] = [] for camp in self.campaigns: if camp.has_war_participant(participant_id): camp_using_part.append(camp.name) if camp_using_part: camps_str = ", ".join(camp_using_part) raise ForbiddenOperation( f"This war participant is used in campaign(s): {camps_str}.\n" "Remove it from campaign(s) first." ) del self.participants[participant_id] # Campaign methods def has_campaign(self, campaign_id: str) -> bool: return any(c.id == campaign_id for c in self.campaigns) def get_default_campaign_values(self) -> Dict[str, Any]: return {"month": datetime.now().month} def has_finished_campaign(self) -> bool: return any(c.is_over for c in self.campaigns) def has_finished_round(self) -> bool: return any(c.has_finished_round() for c in self.campaigns) def has_finished_battle(self) -> bool: return any(c.has_finished_battle() for c in self.campaigns) def all_campaigns_finished(self) -> bool: return all(c.is_over for c in self.campaigns) def add_campaign(self, name: str, month: int | None = None) -> Campaign: if self.is_over: raise ForbiddenOperation("Can't add campaign in a closed war.") if month is None: month = self.get_default_campaign_values()["month"] campaign = Campaign(name, month) self.campaigns.append(campaign) return campaign def get_campaign(self, campaign_id: str) -> Campaign: for camp in self.campaigns: if camp.id == campaign_id: return camp raise KeyError(f"Campaign {campaign_id} not found in War {self.id}") # TODO replace multiloops by internal has_* method def get_campaign_by_round(self, round_id: str) -> Campaign | None: for camp in self.campaigns: for rnd in camp.rounds: if rnd.id == round_id: return camp return None # TODO replace multiloops by internal has_* method def get_campaign_by_sector(self, sector_id: str) -> Campaign: for camp in self.campaigns: for sect in camp.sectors.values(): if sect.id == sector_id: return camp raise KeyError(f"Sector {sector_id} not found in any Campaign") def get_campaign_by_campaign_participant(self, participant_id: str) -> Campaign: for camp in self.campaigns: if camp.has_participant(participant_id): return camp raise KeyError(f"Participant {participant_id} not found in any Campaign") def update_campaign(self, campaign_id: str, *, name: str, month: int) -> None: if self.is_over: raise ForbiddenOperation("Can't update campaign in a closed war.") camp = self.get_campaign(campaign_id) if camp.is_over: raise ForbiddenOperation("Can't update a closed campaign.") camp.set_name(name) camp.set_month(month) def get_all_campaigns(self) -> List[Campaign]: return list(self.campaigns) def remove_campaign(self, campaign_id: str) -> None: if self.is_over: raise ForbiddenOperation("Can't remove campaign in a closed war.") camp = self.get_campaign(campaign_id) if camp: if camp.is_over: raise ForbiddenOperation("Can't remove closed campaign.") if camp.has_finished_round(): raise ForbiddenOperation( "Can't remove campaign with finished round(s)." ) if camp.has_finished_battle(): raise ForbiddenOperation( "Can't remove campaign with finished battle(s) in round(s)." ) self.campaigns.remove(camp) # Sector methods def add_sector( self, campaign_id: str, name: str, round_id: str, major_id: str, minor_id: str, influence_id: str, mission: str, description: str, ) -> Sector: camp = self.get_campaign(campaign_id) return camp.add_sector( name, round_id, major_id, minor_id, influence_id, mission, description ) # TODO replace multiloops by internal has_* method def get_sector(self, sector_id: str) -> Sector: for camp in self.campaigns: for sect in camp.sectors.values(): if sect.id == sector_id: return sect raise KeyError("Sector not found") def update_sector( self, sector_id: str, *, name: str, round_id: str | None, major_id: str | None, minor_id: str | None, influence_id: str | None, mission: str | None, description: str | None, ) -> None: camp = self.get_campaign_by_sector(sector_id) camp.update_sector( sector_id, name=name, round_id=round_id, major_id=major_id, minor_id=minor_id, influence_id=influence_id, mission=mission, description=description, ) def remove_sector(self, sector_id: str) -> None: camp = self.get_campaign_by_sector(sector_id) camp.remove_sector(sector_id) # Campaign participant methods def get_available_war_participants(self, campaign_id: str) -> List[WarParticipant]: camp = self.get_campaign(campaign_id) return [ part for part in self.participants.values() if not camp.has_war_participant(part.id) ] def add_campaign_participant( self, campaign_id: str, participant_id: str, leader: str, theme: str ) -> CampaignParticipant: camp = self.get_campaign(campaign_id) return camp.add_campaign_participant(participant_id, leader, theme) # TODO replace multiloops by internal has_* method def get_campaign_participant(self, participant_id: str) -> CampaignParticipant: for camp in self.campaigns: for part in camp.participants.values(): if part.id == participant_id: return part raise KeyError("Participant not found") def update_campaign_participant( self, participant_id: str, *, leader: str, theme: str ) -> None: camp = self.get_campaign_by_campaign_participant(participant_id) camp.update_campaign_participant(participant_id, leader=leader, theme=theme) def remove_campaign_participant(self, participant_id: str) -> None: camp = self.get_campaign_by_campaign_participant(participant_id) camp.remove_campaign_participant(participant_id) # Round methods def add_round(self, campaign_id: str) -> Round: camp = self.get_campaign(campaign_id) return camp.add_round() def remove_round(self, round_id: str) -> None: camp = self.get_campaign_by_round(round_id) if camp is not None: camp.remove_round(round_id) # Choice methods def create_choice(self, round_id: str, participant_id: str) -> Choice: camp = self.get_campaign_by_round(round_id) if camp is not None: return camp.create_choice(round_id, participant_id) raise KeyError("Campaign with round {round_id} doesn't exist") def update_choice( self, round_id: str, participant_id: str, priority_sector_id: str | None, secondary_sector_id: str | None, comment: str | None, ) -> None: camp = self.get_campaign_by_round(round_id) if camp is not None: camp.update_choice( round_id, participant_id, priority_sector_id, secondary_sector_id, comment, ) def remove_choice(self, round_id: str, participant_id: str) -> None: camp = self.get_campaign_by_round(round_id) if camp is not None: camp.remove_choice(round_id, participant_id) # Battle methods def create_battle(self, round_id: str, sector_id: str) -> Battle: camp = self.get_campaign_by_round(round_id) if camp is not None: return camp.create_battle(round_id, sector_id) raise KeyError("Campaign with round {round_id} doesn't exist") def update_battle( self, round_id: str, sector_id: str, player_1_id: str | None, player_2_id: str | None, winner_id: str | None, score: str | None, victory_condition: str | None, comment: str | None, ) -> None: camp = self.get_campaign_by_round(round_id) if camp is not None: camp.update_battle( round_id, sector_id, player_1_id, player_2_id, winner_id, score, victory_condition, comment, ) def remove_battle(self, round_id: str, sector_id: str) -> None: camp = self.get_campaign_by_round(round_id) if camp is not None: camp.remove_battle(round_id, sector_id)