Simulate turn-based monster team battle

Design an object-oriented model and implement the core battle logic for a turn-based fight between two teams of monsters. The system should simulate the battle and produce a detailed, chronological battle log, as well as the final result.

Game Setup

There are two teams: Team A and Team B.

Each team has an ordered list of monsters.

Each Monster has the following attributes:

• name : string
• health : positive integer (HP)
• attack : positive integer (attack power)

The battle continues until at least one team has no living monsters.

Active Monster Rules

For each team, the active monster is defined as:

• The first monster in that team's list whose health > 0 .
• If a team has no monsters with health > 0 , that team immediately loses (unless this happens to both teams in the same round, see draw rule below).

Round and Attack Rules

The battle proceeds in rounds. Each round follows this exact sequence:

1. Determine the active monster for Team A and Team B as described above.
2. Team A's active monster attacks Team B's active monster.
   • Damage calculation: defender.health -= attacker.attack .
   • If the defender's health becomes <= 0 , that monster dies.
3. If Team B's active monster is still alive after step 2 , it immediately counterattacks:
   • Team B's active monster attacks Team A's active monster using the same damage rule: defender.health -= attacker.attack .
   • If the defender's health becomes <= 0 , that monster dies.
4. The round ends, and the next round begins with newly determined active monsters based on the updated health values.

Death and replacement:

• When a monster's health <= 0 , it is considered dead and removed from battle.
• On the next round , the next monster in that team's list with health > 0 becomes the new active monster (if any).

Win / Draw Conditions

• Win:
  • If, after processing the attacks in a round, one team has no living monsters and the other team still has at least one living monster, the surviving team wins.
• Draw:
  • If the last remaining monsters of both teams die in the same round (for example, Team A's monster kills Team B's monster, but Team B's monster's counterattack in the same round kills Team A's monster as well), the result is a draw.

Logging Requirements

You must generate a battle log in strict chronological order. The log should include at least:

1. Each attack event , with:
   • Attacker name and team.
   • Defender name and team.
   • Damage dealt (equal to attacker's attack ).
   • Defender HP change: HP_before -> HP_after .
2. Each death event , including:
   • Which monster died (name, team).
   • If a new monster becomes active for that team in the next round , log which monster is coming in as the replacement.
3. Final result , as one of the strings:
   • "Team A wins"
   • "Team B wins"
   • "Draw"

You may choose the exact log format (e.g., a list of strings or structured records), but it must be sufficient to reconstruct the full sequence of events.

Implementation / OOD Requirements

Use good object-oriented design. Do not put all logic into a single class or function. At minimum, design the following classes (you may add more helper classes if needed):

• Monster
  • Holds name , health , attack and exposes any behavior needed (e.g., takeDamage, isAlive).
• Team
  • Holds an ordered collection of Monster instances.
  • Provides methods to get the current active monster and to determine if the team is defeated.
• BattleEngine
  • Orchestrates the battle rounds between two Team instances.
  • Runs the main battle loop according to the rules above.
  • Generates the chronological battle log.
  • Determines the final result.
• BattleResult
  • Contains at least:
    • winner : one of "Team A" , "Team B" , or "Draw" .
    • log : the ordered battle log.

Task:

Design and implement these classes and the core battle logic so that, given two teams of monsters as input, you can run the battle with BattleEngine and obtain a BattleResult containing the winner and the full battle log.