BattleMachine.py

from statemachine import Machine, BluePrint, Node
from random import randrange, choice, shuffle

class Move(object):
    def __init__(self,name,power):
        self.name,self.power=name,power
    def apply(self,target):
        target.hp -= self.power
    def __str__(self):return self.name

class Monster(object):
    def __init__(self,species):
        self.species = species
        self.moves = [Move('kick',3),Move('punch',2),Move("heal",-1)]
        self.hp,self.speed = 10,randrange(1,20)

class Card(object):
    name="Player-"
    def __init__(self):
        self.roster = []
        self.inventory = {}
    def __str__(self):return self.name

class Battle(object):
    def __init__(self):
        self.players = []
        self.rounds = []

class Round(object):
    def __init__(self,players):
        self.moves = {}
        sort_by_speed=lambda player:-player.roster[0].speed
        self.players = sorted(players,key=sort_by_speed)
    @property
    def current_player(self):
        return [p for p in self.players if p not in self.moves][0]

class BattleMachine(Machine):
    def __init__(self,*a,**b):
        super().__init__(*a,**b)
        self.battle = Battle()
        self.pending = None
    def __call__(self):super().__call__(self.battle)

class CreatePlayer(Node):
    def apply(self,battle):
        p = Card()
        p.roster = [Monster(None) for i in range(randrange(1,6))]
        p.name += str(len(battle.players)+1)
        battle.players.append(p)

class EnoughPlayers(Node):
    def apply(self,battle):
        return len(battle.players)>3

class NeedMoreMoves(Node):
    resume=True
    def apply(self,battle):
        return len(battle.rounds[-1].moves)<len(battle.rounds[-1].players)

class GetMove(Node):
    def apply(self,battle):
        player = battle.rounds[-1].current_player
        moves = player.roster[0].moves
        m = choice(moves+[None]*3)
        if m is not None:
            t=[p for p in battle.rounds[-1].players if p is not player]
            shuffle(t)
            battle.rounds[-1].moves[player]=(m,t)

class ApplyMoves(Node):
    def apply(self,battle):
        round = battle.rounds[-1]
        for player,(move,targets) in round.moves.items():
            if len(player.roster)<1:
                print(player.name,"has no pokemon left to fight.")
            targets = [t for t in targets if len(t.roster)>0]
            if len(targets)<1:
                print(player.name,"failed.")
                continue
            target=targets[0]
            move.apply(target.roster[0])
            if target.roster[0].hp <1:
                print(target.name,"lost a pokemon.")
                target.roster = target.roster[1:]
                if len(target.roster)<1:
                    print(target.name,"is out of pokemon.")

class GameFinished(Node):
    def apply(self,battle):
        p=[p for p in battle.players if len(p.roster)>0]
        return len(p)<2

class NextRound(Node):
    resume=True
    def apply(self,battle):
        p=[p for p in battle.players if len(p.roster)>0]
        battle.rounds.append(Round(p))

class FinalizeGame(Node):
    def apply(self,battle):
        print("Game is over!")
        victors = [p for p in battle.players if len(p.roster)>0]
        if len(victors)<1:
            print("There are no winners.")
        if len(victors)>1:
            print("The winners are:",*map(str,victors))
        else:
            print("The winner is:",victors[0].name)

class BattleScheme(BluePrint):
    machine = BattleMachine
    components = [
        (CreatePlayer,1), #0
        (EnoughPlayers,[0,2]),#1
        (NextRound,3),#2
        (NeedMoreMoves,[5,4]),#3
        (GetMove,3),#4
        (ApplyMoves,6),#5
        (GameFinished,[2,7]),#6
        (FinalizeGame,-1)#7
    ]

for i in range(10):
    print("Battle",i+1)
    with BattleScheme.build() as machine:
            while machine.state>=0:
                machine()
    print("="*80,end='\n'*2)