I'm trying to build an irc-bot that serves as the manager of a multiplayer, turn-based, dice-rolling game. The bot listens to all messages on the channel. When the connections, it creates a Game example with all the players, except him, present in the chain.
There are two types of players in the game, regular players and lords. Being a lord is a cumulative property, you can be a lord with one count, with two, and so on.
The purpose of the first round is to assign lords. Each player must roll the dice at least once. If you throw pairs, you have to repeat. The three of you are assigned a lord.
Then you have two more rounds. Each player must roll the dice at least once more. If you launch pairs, you have to repeat, if you launch certain types of reels, you lose all your waiting reels. If you launch other types of reels, you can send a fight to another player. The fight is resolved until one of the two participants fails. It is important the number of rounds that the fight lasts.
I'm trying to build a loop style, along the lines of:
first_round: Round = next(self.game)
for turn in first_round:
current_player = turn.player
for dices in turn:
dices.roll()
for the first round. The other tours must be managed via irc-bot, responding to chat messages. irc-bot has access to the Game example.
But I'm stuck with the code, I don't know how to continue.
class Dices:
def __init__(self, left, right):
# Canonical members of dices are ordered being the first the min and the second the max.
self.left: int = left if left < right else right
self.right: int = right if left >= right else left
def roll(self):
first_roll = random.randint(1, 6)
second_roll = random.randint(1, 6)
return Dices(first_roll, second_roll)
def count_threes(self):
return (1 if self.left == 3 else 0) + (1 if self.right == 3 else 0)
def is_pair(self):
return self.left == self.right
def __eq__(self, other):
if isinstance(other, Dices):
return other.left == self.left and other.right == self.right
else:
return False
def __str__(self):
return f"({self.left},{self.right})"
class NotRollingDices(Dices):
def roll(self):
return NotImplementedError
class Pair(NotRollingDices):
def __init__(self, num: int):
super().__init__(num, num)
class Player:
def __init__(self, name):
self.name: str = name
self.dices = Dices(0, 0)
self.lords: int = 0
def add_lord(self) -> None:
self.lords = self.lords + 1
def is_lord(self) -> bool:
return self.lords_count() > 0
def lords_count(self) -> int:
return self.lords
def roll(self) -> Dices:
return self.dices.roll()
def __str__(self):
return f""
def __eq__(self, other):
if isinstance(other, Player):
return self.name == other.name
return False
def __hash__(self):
return self.name.__hash__()
class Turn(Iterator(Dices)):
def __init__(self, player: Player, is_first: bool):
self.player: Player = player
self.is_first: bool = is_first
self.pending_rolls: int = 3
self.current_roll: Optional(Dices) = None
def __next__(self) -> Dices:
if self.pending_rolls == 0:
raise StopIteration
self.pending_rolls -= 1
current_roll = self.player.roll()
return current_roll
def __str__(self):
return f""
class Round(Iterator(Turn)):
def __init__(self, players: Iterable(Player), is_first: bool):
self.players = players
self.is_first: bool = is_first
self.current_turn = Optional(Turn)
def __next__(self) -> Turn:
for player in self.players:
return Turn(player, self.is_first)
raise StopIteration
class Game(Iterator(Round)):
def __init__(self, pending_rounds: int = 3):
self.players: set = set()
self.pending_rounds: int = pending_rounds
self.current_round: Optional(Round) = None
def add_player(self, player: Player) -> None:
self.players.add(player)
def player_by_name(self, name: str) -> Optional(Player):
for player in self.players:
if player.name == name:
return player
return None
def lords(self) -> List(Player):
return (player for player in self.players if player.is_lord())
def current_round(self) -> Round:
return self.current_round
def is_first_round(self):
return self.pending_rounds == 3
def __next__(self) -> Round:
if self.pending_rounds <= 0:
raise StopIteration
self.pending_rounds -= 1
self.current_round = Round(self.players, self.is_first_round())
return self.current_round
