X-Git-Url: https://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fbattle%2FBattleState.cpp;h=0171e1480f56a7d52b905a86e577525d0a2597a0;hb=2255d436a0c2acc10b015827366a72b2ece86094;hp=9830e8c6a0b976f41f26642f024d34d2032e6e6e;hpb=e1edc92c4fb834c8061118e89c0d7e239742b030;p=l2e.git

diff --git a/src/battle/BattleState.cpp b/src/battle/BattleState.cpp
index 9830e8c..0171e14 100644
--- a/src/battle/BattleState.cpp
+++ b/src/battle/BattleState.cpp
@@ -177,9 +177,7 @@ class OrderCompare {
 	public:
 		OrderCompare(BattleState *battle) : battle(battle) { }
 		bool operator ()(const BattleState::Order &lhs, const BattleState::Order &rhs) {
-			int lagl(lhs.isMonster ? battle->MonsterAt(lhs.index).GetStats().Agility() : battle->HeroAt(lhs.index).GetStats().Agility());
-			int ragl(rhs.isMonster ? battle->MonsterAt(rhs.index).GetStats().Agility() : battle->HeroAt(rhs.index).GetStats().Agility());
-			return lagl > ragl;
+			return lhs.GetStats(*battle).Agility() > rhs.GetStats(*battle).Agility();
 		}
 	private:
 		BattleState *battle;
@@ -188,12 +186,15 @@ class OrderCompare {
 void BattleState::CalculateAttackOrder() {
 	attackOrder.reserve(monsters.size() + NumHeroes());
 	for (int i(0); i < NumHeroes(); ++i) {
-		attackOrder.push_back(Order(i, false));
+		attackOrder.push_back(Order(Order::HERO, i));
 	}
 	for (vector<Monster>::size_type i(0), end(monsters.size()); i < end; ++i) {
-		attackOrder.push_back(Order(i, true));
+		attackOrder.push_back(Order(Order::MONSTER, i));
 		MonsterAt(i).GetAttackChoice() = AttackChoice(this);
 	}
+	if (capsule.Health() > 0) {
+		attackOrder.push_back(Order(Order::CAPSULE));
+	}
 	std::sort(attackOrder.begin(), attackOrder.end(), OrderCompare(this));
 }
 
@@ -204,10 +205,12 @@ void BattleState::NextAttack() {
 	}
 	++attackCursor;
 	while (attackCursor < int(attackOrder.size())) {
-		if (attackOrder[attackCursor].isMonster) {
+		if (attackOrder[attackCursor].IsMonster()) {
 			if (MonsterAt(attackOrder[attackCursor].index).Health() > 0) break;
-		} else {
+		} else if (attackOrder[attackCursor].IsHero()) {
 			if (HeroAt(attackOrder[attackCursor].index).Health() > 0) break;
+		} else {
+			if (capsule.Health() > 0) break;
 		}
 		++attackCursor;
 	}
@@ -219,23 +222,20 @@ bool BattleState::AttacksFinished() const {
 }
 
 void BattleState::CalculateDamage() {
-	if (CurrentAttack().isMonster) {
+	if (CurrentAttack().IsMonster()) {
 		DecideMonsterAttack(MonsterAt(CurrentAttack().index));
+	} else if (CurrentAttack().IsCapsule()) {
+		DecideCapsuleAttack();
 	}
-	AttackChoice &ac(CurrentAttack().isMonster ? MonsterAt(CurrentAttack().index).GetAttackChoice() : HeroAt(CurrentAttack().index).GetAttackChoice());
+	AttackChoice &ac = CurrentAttack().GetAttackChoice(*this);
 	if (ac.GetType() == AttackChoice::DEFEND) return;
 	TargetSelection &ts(ac.Selection());
 
-	if (CurrentAttack().isMonster) {
-		const Stats &attackerStats(MonsterAt(CurrentAttack().index).GetStats());
-		CalculateDamage(attackerStats, ts);
-	} else {
-		const Stats &attackerStats(HeroAt(CurrentAttack().index).GetStats());
-		CalculateDamage(attackerStats, ts);
-	}
+	const Stats &attackerStats = CurrentAttack().GetStats(*this);
+	CalculateDamage(attackerStats, ts);
 }
 
-void BattleState::DecideMonsterAttack(Monster &m) const {
+void BattleState::DecideMonsterAttack(Monster &m) {
 	AttackChoice &ac(m.GetAttackChoice());
 	TargetSelection &ts(ac.Selection());
 	ac.Reset();
@@ -249,6 +249,46 @@ void BattleState::DecideMonsterAttack(Monster &m) const {
 	ts.Select(target);
 }
 
+void BattleState::DecideCapsuleAttack() {
+	AttackChoice &ac(capsule.GetAttackChoice());
+	TargetSelection &ts(ac.Selection());
+	ac.Reset();
+	int target(rand() % monsters.size());
+	while (!MonsterPositionOccupied(target)) {
+		target = rand() % monsters.size();
+	}
+	ac.SetType(AttackChoice::SWORD);
+	ts.SelectMonsters();
+	ts.SetSingle();
+	ts.Select(target);
+}
+
+AttackChoice &BattleState::Order::GetAttackChoice(BattleState &b) const {
+	switch (by) {
+		case HERO:
+			return b.HeroAt(index).GetAttackChoice();
+		case CAPSULE:
+			return b.GetCapsule().GetAttackChoice();
+		case MONSTER:
+			return b.MonsterAt(index).GetAttackChoice();
+		default:
+			throw std::runtime_error("invalid case in BttleStats::Order::GetAttackChoice()");
+	}
+}
+
+Stats &BattleState::Order::GetStats(BattleState &b) const {
+	switch (by) {
+		case HERO:
+			return b.HeroAt(index).GetStats();
+		case CAPSULE:
+			return b.GetCapsule().GetStats();
+		case MONSTER:
+			return b.MonsterAt(index).GetStats();
+		default:
+			throw std::runtime_error("invalid case in BttleStats::Order::GetAttackChoice()");
+	}
+}
+
 void BattleState::CalculateDamage(const Stats &attackerStats, TargetSelection &ts) const {
 	bool hitSome(false);
 	if (ts.TargetsMonsters()) {
@@ -304,7 +344,7 @@ Uint16 BattleState::CalculateDamage(const Stats &attacker, const Stats &defender
 
 void BattleState::ApplyDamage() {
 	if (attackCursor < 0) return;
-	AttackChoice &ac(CurrentAttack().isMonster ? MonsterAt(CurrentAttack().index).GetAttackChoice() : HeroAt(CurrentAttack().index).GetAttackChoice());
+	AttackChoice &ac = CurrentAttack().GetAttackChoice(*this);
 	TargetSelection &ts(ac.Selection());
 	if (ts.TargetsMonsters()) {
 		for (int i(0); i < MaxMonsters(); ++i) {
@@ -328,11 +368,7 @@ void BattleState::ApplyDamage() {
 }
 
 AttackChoice &BattleState::CurrentAttackAttackChoice() {
-	if (CurrentAttack().isMonster) {
-		return MonsterAt(CurrentAttack().index).GetAttackChoice();
-	} else {
-		return HeroAt(CurrentAttack().index).GetAttackChoice();
-	}
+	return CurrentAttack().GetAttackChoice(*this);
 }
 
 void BattleState::ClearAllAttacks() {
@@ -344,6 +380,7 @@ void BattleState::ClearAllAttacks() {
 	for (int i(0); i < MaxMonsters(); ++i) {
 		MonsterAt(i).GetAttackChoice() = AttackChoice(this);
 	}
+	capsule.GetAttackChoice() = AttackChoice(this);
 	attackOrder.clear();
 }