HeroesofAbenez\Combat\CombatBase

Complexity

Total Complexity

66

Size/Duplication

Total Lines	386
Duplicated Lines	0 %

Test Coverage

Coverage

94.01%

Importance

Changes	29
Bugs	0	Features	5

70 Methods

Rating	Name	Duplication	Size	Complexity
	resetInitiative()	0	5	?
A	hp$0 ➔ setDuelParticipants()	0	6	1
	getTeam2()	0	2	?
A	hp$0 ➔ getHealers()	0	2	1
	getWinner()	0	7	?
A	hp$0 ➔ recalculateStats()	0	5	2
A	hp$0 ➔ setRoundLimit()	0	2	1
	logRoundNumber()	0	2	?
A	hp$0 ➔ getCombatActions()	0	2	1
	decreaseEffectsDuration()	0	7	?
A	hp$0 ➔ registerDefaultHandlers()	0	13	1
	applyEffectProviders()	0	5	?
A	hp$0 ➔ getRound()	0	2	1
A	hp$0 ➔ getTeam1()	0	2	1
	getVictoryCondition()	0	2	?
	getTeam()	0	2	?
A	hp$0 ➔ logRoundNumber()	0	2	1
A	hp$0 ➔ decreaseEffectsDuration()	0	7	4
A	hp$0 ➔ execute()	0	18	5
	assignPositions()	0	28	?
	logCombatResult()	0	8	?
	getRoundLimit()	0	2	?
	getRound()	0	2	?
	removeCombatEffects()	0	5	?
	setDuelParticipants()	0	6	?
	setRoundLimit()	0	2	?
A	hp$0 ➔ __construct()	0	13	1
	getCombatActions()	0	2	?
A	hp$0 ➔ decreaseSkillsCooldowns()	0	6	3
	registerDefaultHandlers()	0	13	?
	setVictoryCondition()	0	2	?
A	hp$0 ➔ getVictoryCondition()	0	2	1
	setTeams()	0	7	?
	getEnemyTeam()	0	2	?
	getLog()	0	2	?
A	hp$0 ➔ getRoundLimit()	0	2	1
A	hp$0 ➔ getTeam2()	0	2	1
A	hp$0 ➔ setTeams()	0	7	2
A	hp$0 ➔ setHealers()	0	2	1
A	hp$0 ➔ removeCombatEffects()	0	5	2
A	hp$0 ➔ getLog()	0	2	1
	recalculateStats()	0	5	?
A	hp$0 ➔ getEnemyTeam()	0	2	2
A	hp$0 ➔ logDamage()	0	3	2
	execute()	0	18	?
A	hp$0 ➔ applyEffectProviders()	0	5	2
	registerDefaultCombatActions()	0	5	?
	logDamage()	0	3	?
A	hp$0 ➔ setVictoryCondition()	0	2	1
	getTeam1()	0	2	?
A	hp$0 ➔ applyPoison()	0	14	2
A	hp$0 ➔ registerDefaultCombatActions()	0	5	1
A	hp$0 ➔ logCombatResult()	0	8	2
A	hp$0 ➔ resetInitiative()	0	5	2
	__construct()	0	13	?
A	hp$0 ➔ getWinner()	0	7	2
B	hp$0 ➔ assignPositions()	0	28	7
	getTeam1Damage()	0	2	?
A	hp$0 ➔ getTeam()	0	2	2
	getHealers()	0	2	?
	decreaseSkillsCooldowns()	0	6	?
	setHealers()	0	2	?
	applyPoison()	0	14	?
A	hp$0 ➔ getTeam1Damage()	0	2	1
	selectAttackTarget()	0	17	?
A	hp$0 ➔ selectAttackTarget()	0	17	4
	mainStage()	0	13	?
A	hp$0 ➔ getTeam2Damage()	0	2	1
A	hp$0 ➔ mainStage()	0	13	3
	getTeam2Damage()	0	2	?

<?php
declare(strict_types=1);

namespace HeroesofAbenez\Combat;

use Nexendrie\Utils\Numbers;
use Nexendrie\Utils\Collection;

/**
 * Handles combat
 * 
 * @author Jakub Konečný
 * @property-read CombatLogger $log Log from the combat
 * @property-read int $winner Team which won the combat/0 if there is no winner yet
 * @property-read int $round Number of current round
 * @property int $roundLimit
 * @property Team $team1
 * @property Team $team2
 * @property-read int $team1Damage
 * @property-read int $team2Damage
 * @property Collection|ICombatAction[] $combatActions
 * @property callable $victoryCondition To evaluate the winner of combat. Gets combat as parameter, should return winning team (1/2) or 0 if there is not winner (yet)

Line exceeds 120 characters; contains 166 characters

 * @property callable $healers To determine characters that are supposed to heal their team. Gets team1 and team2 as parameters, should return Team

Line exceeds 120 characters; contains 147 characters

 * @method void onCombatStart(CombatBase $combat)
 * @method void onCombatEnd(CombatBase $combat)
 * @method void onRoundStart(CombatBase $combat)
 * @method void onRound(CombatBase $combat)
 * @method void onRoundEnd(CombatBase $combat)
 */
class CombatBase {
  use \Nette\SmartObject;

  protected Team $team1;
  protected Team $team2;
  protected CombatLogger $log;
  protected int $round = 0;
  protected int $roundLimit = 30;
  /** @var int[] Dealt damage by team */
  protected array $damage = [1 => 0, 2 => 0];
  /** @var callable[] */
  public array $onCombatStart = [];
  /** @var callable[] */
  public array $onCombatEnd = [];
  /** @var callable[] */
  public array $onRoundStart = [];
  /** @var callable[] */
  public array $onRound = [];
  /** @var callable[] */
  public array $onRoundEnd = [];
  /** @var callable */
  protected $victoryCondition;
  /** @var callable */
  protected $healers;
  public ISuccessCalculator $successCalculator;
  public ICombatActionSelector $actionSelector;
  /** @var Collection|ICombatAction[] */
  protected Collection $combatActions;
  
  public function __construct(CombatLogger $logger, ?ISuccessCalculator $successCalculator = null, ?ICombatActionSelector $actionSelector = null) {

Line exceeds 120 characters; contains 147 characters

    $this->log = $logger;
    $this->victoryCondition = [VictoryConditions::class, "moreDamage"];
    $this->successCalculator = $successCalculator ?? new RandomSuccessCalculator();
    $this->actionSelector = $actionSelector ?? new CombatActionSelector();
    $this->healers = function(): Team {
      return new Team("healers");
    };
    $this->combatActions = new class extends Collection {
      protected string $class = ICombatAction::class;
    };
    $this->registerDefaultHandlers();
    $this->registerDefaultCombatActions();
  }

  protected function registerDefaultHandlers(): void {
    $this->onCombatStart[] = [$this, "assignPositions"];
    $this->onCombatEnd[] = [$this, "removeCombatEffects"];
    $this->onCombatEnd[] = [$this, "logCombatResult"];
    $this->onCombatEnd[] = [$this, "resetInitiative"];
    $this->onRoundStart[] = [$this, "applyEffectProviders"];
    $this->onRoundStart[] = [$this, "decreaseEffectsDuration"];
    $this->onRoundStart[] = [$this, "recalculateStats"];
    $this->onRoundStart[] = [$this, "logRoundNumber"];
    $this->onRoundStart[] = [$this, "applyPoison"];
    $this->onRound[] = [$this, "mainStage"];
    $this->onRoundEnd[] = [$this, "decreaseSkillsCooldowns"];
    $this->onRoundEnd[] = [$this, "resetInitiative"];
  }

  protected function registerDefaultCombatActions(): void {
    $this->combatActions[] = new CombatActions\Attack();
    $this->combatActions[] = new CombatActions\Heal();
    $this->combatActions[] = new CombatActions\SkillAttack();
    $this->combatActions[] = new CombatActions\SkillSpecial();
  }
  
  public function getRound(): int {
    return $this->round;
  }
  
  public function getRoundLimit(): int {
    return $this->roundLimit;
  }

  public function setRoundLimit(int $roundLimit): void {
    $this->roundLimit = Numbers::range($roundLimit, 1, PHP_INT_MAX);
  }

  /**
   * Set teams
   */
  public function setTeams(Team $team1, Team $team2): void {
    if(isset($this->team1)) {
      throw new ImmutableException("Teams has already been set.");
    }
    $this->team1 = $team1;
    $this->team2 = $team2;
    $this->log->setTeams($team1, $team2);
  }
  
  /**
   * Set participants for duel
   * Creates teams named after the member
   */
  public function setDuelParticipants(Character $player, Character $opponent): void {
    $team1 = new Team($player->name);
    $team1[] = $player;
    $team2 = new Team($opponent->name);
    $team2[] = $opponent;
    $this->setTeams($team1, $team2);
  }
  
  public function getTeam1(): Team {
    return $this->team1;
  }
  
  public function getTeam2(): Team {
    return $this->team2;
  }
  
  public function getVictoryCondition(): callable {
    return $this->victoryCondition;
  }
  
  public function setVictoryCondition(callable $victoryCondition): void {
    $this->victoryCondition = $victoryCondition;
  }
  
  public function getHealers(): callable {
    return $this->healers;
  }
  
  public function setHealers(callable $healers): void {
    $this->healers = $healers;
  }
  
  public function getTeam1Damage(): int {
    return $this->damage[1];
  }
  
  public function getTeam2Damage(): int {
    return $this->damage[2];
  }

  /**
   * @return Collection|ICombatAction[]
   */
  public function getCombatActions(): Collection {
    return $this->combatActions;
  }

  /**
   * Get winner of combat
   * 
   * @staticvar int $result
   * @return int Winning team/0
   */
  public function getWinner(): int {
    static $result = 0;
    if($result === 0) {
      $result = call_user_func($this->victoryCondition, $this);
      $result = Numbers::range($result, 0, 2);
    }
    return $result;
  }

  /**
   * @internal
   */
  public function getTeam(Character $character): Team {
    return $this->team1->hasItems(["id" => $character->id]) ? $this->team1 : $this->team2;
  }

  /**
   * @internal
   */
  public function getEnemyTeam(Character $character): Team {
    return $this->team1->hasItems(["id" => $character->id]) ? $this->team2 : $this->team1;
  }
  
  public function applyEffectProviders(self $combat): void {
    /** @var Character[] $characters */
    $characters = array_merge($combat->team1->toArray(), $combat->team2->toArray());
    foreach($characters as $character) {
      $character->applyEffectProviders();
    }
  }

  public function assignPositions(self $combat): void {
    $assignPositions = function(Team $team): void {
      $row = 1;
      $column = 0;
      /** @var Character $character */
      foreach($team as $character) {
        try {
          $column++;
          if($character->positionRow > 0 && $character->positionColumn > 0) {
            continue;
          }
          setPosition:

Use of the GOTO language construct is discouraged

          $team->setCharacterPosition($character->id, $row, $column);
        } catch(InvalidCharacterPositionException $e) {
          if($e->getCode() === InvalidCharacterPositionException::ROW_FULL) {
            $row++;
            $column = 1;
          } elseif($e->getCode() === InvalidCharacterPositionException::POSITION_OCCUPIED) {
            $column++;
          } else {
            throw $e;
          }
          goto setPosition;

Use of the GOTO language construct is discouraged

        }
      }
    };
    $assignPositions($combat->team1);
    $assignPositions($combat->team2);
  }
  
  public function decreaseEffectsDuration(self $combat): void {
    /** @var Character[] $characters */
    $characters = array_merge($combat->team1->toArray(), $combat->team2->toArray());
    foreach($characters as $character) {
      foreach($character->effects as $effect) {
        if(is_int($effect->duration)) {
          $effect->duration--;
        }
      }
    }
  }
  
  /**
   * Decrease skills' cooldowns
   */
  public function decreaseSkillsCooldowns(self $combat): void {
    /** @var Character[] $characters */
    $characters = array_merge($combat->team1->toArray(), $combat->team2->toArray());
    foreach($characters as $character) {
      foreach($character->skills as $skill) {
        $skill->decreaseCooldown();
      }
    }
  }
  
  /**
   * Remove combat effects from character at the end of the combat
   */
  public function removeCombatEffects(self $combat): void {
    /** @var Character[] $characters */
    $characters = array_merge($combat->team1->toArray(), $combat->team2->toArray());
    foreach($characters as $character) {
      $character->effects->removeByFilter(["duration!=" => CharacterEffect::DURATION_FOREVER]);
    }
  }
  
  /**
   * Add winner to the log
   */
  public function logCombatResult(self $combat): void {
    $combat->log->round = 5000;
    $params = [
      "team1name" => $combat->team1->name, "team1damage" => $combat->damage[1],
      "team2name" => $combat->team2->name, "team2damage" => $combat->damage[2],
    ];
    $params["winner"] = ($combat->winner === 1) ? $combat->team1->name : $combat->team2->name;
    $combat->log->logText("combat.log.combatEnd", $params);
  }
  
  /**
   * Log start of a round
   */
  public function logRoundNumber(self $combat): void {
    $combat->log->round = ++$this->round;
  }
  
  /**
   * Decrease duration of effects and recalculate stats
   */
  public function recalculateStats(self $combat): void {
    /** @var Character[] $characters */
    $characters = array_merge($combat->team1->toArray(), $combat->team2->toArray());
    foreach($characters as $character) {
      $character->recalculateStats();
    }
  }
  
  /**
   * Reset characters' initiative
   */
  public function resetInitiative(self $combat): void {
    /** @var Character[] $characters */
    $characters = array_merge($combat->team1->toArray(), $combat->team2->toArray());
    foreach($characters as $character) {
      $character->resetInitiative();
    }
  }
  
  /**
   * Select target for attack
   *
   * @internal
   */
  public function selectAttackTarget(Character $attacker): ?Character {
    $enemyTeam = $this->getEnemyTeam($attacker);
    $rangedWeapon = ($attacker->equipment->hasItems(["%class%" => Weapon::class, "worn" => true, "ranged" => true, ]));
    if(!$rangedWeapon) {
      $rowToAttack = $enemyTeam->rowToAttack;
      if($rowToAttack === null) {
        return null;
      }
      $enemies = Team::fromArray($enemyTeam->getItems(["positionRow" => $rowToAttack, "hitpoints>" => 0, "hidden" => false, ]), $enemyTeam->name);

Line exceeds 120 characters; contains 146 characters

    } else {
      $enemies = $enemyTeam;
    }
    $target = $enemies->getLowestHpCharacter();
    if($target !== null) {
      return $target;
    }
    return $enemies->getRandomCharacter();
  }
  
  /**
   * Main stage of a round
   *
   * @throws NotImplementedException
   */
  public function mainStage(self $combat): void {
    /** @var Character[] $characters */
    $characters = array_merge($combat->team1->usableMembers, $combat->team2->usableMembers);
    usort($characters, function(Character $a, Character $b): int {
      return -1 * strcmp((string) $a->initiative, (string) $b->initiative);
    });
    foreach($characters as $character) {
      /** @var ICombatAction|null $combatAction */
      $combatAction = $combat->actionSelector->chooseAction($combat, $character);
      if($combatAction === null) {
        break;
      }
      $combatAction->do($combat, $character);
    }
  }
  
  /**
   * Executes the combat
   * 
   * @return int Winning team
   */
  public function execute(): int {
    if(!isset($this->team1)) {
      throw new InvalidStateException("Teams are not set.");
    }
    $this->onCombatStart($this);
    while($this->round <= $this->roundLimit) {
      $this->onRoundStart($this);
      if($this->getWinner() > 0) {
        break;
      }
      $this->onRound($this);
      $this->onRoundEnd($this);
      if($this->getWinner() > 0) {
        break;
      }
    }
    $this->onCombatEnd($this);
    return $this->getWinner();
  }

  /**
   * Harm poisoned characters at start of round
   */
  public function applyPoison(self $combat): void {
    /** @var Character[] $characters */
    $characters = array_merge(
        $combat->team1->getItems(["hitpoints>" => 0, "poisoned!=" => false, ]),
        $combat->team2->getItems(["hitpoints>" => 0, "poisoned!=" => false, ])
    );
    foreach($characters as $character) {
      $poisonValue = $character->getStatus(Character::STATUS_POISONED);
      $character->harm($poisonValue);
      $action = [
        "action" => CombatLogEntry::ACTION_POISON, "result" => true, "amount" => $poisonValue,
        "character1" => $character, "character2" => $character,
      ];
      $combat->log->log($action);
    }
  }
  
  /**
   * Log dealt damage
   */
  public function logDamage(Character $attacker, int $amount): void {
    $team = $this->team1->hasItems(["id" => $attacker->id]) ? 1 : 2;
    $this->damage[$team] += $amount;
  }
  
  public function getLog(): CombatLogger {
    return $this->log;
  }
}
?>