- Implemented Panicking units.

- Various little tweaks and fixes.

Author: tomvd

CHANGELOG.txt

@@ -8,6 +8,7 @@ New features:
 -- Abort screen.
 -- Debriefing screen.
 -- Battlescape save game.
+-- Panicking units.
 
 
 Bugfixes:
@@ -30,6 +31,7 @@ Bugfixes:
 - Missing text in Monthly Report.
 - Ground items showing up in soldier's hands.
 - Improved interface performance.
+- Bug with seeing through undiscovered floors.
 
 Version 0.3 (01-09-2011)
 -------------------------

src/Battlescape/BattlescapeState.cpp

@@ -66,6 +66,8 @@
 #include "WarningMessage.h"
 #include "BattlescapeOptionsState.h"
 #include "DebriefingState.h"
+#include "../Engine/RNG.h"
+#include "InfoboxState.h"
 
 namespace OpenXcom
 {
@@ -344,6 +346,8 @@ void BattlescapeState::init()
 	_map->cacheUnits();
 	_map->draw();
 	updateSoldierInfo();
+	if (_battleGame->getSide() == FACTION_PLAYER)
+		_playerPanicHandled = false;
 }
 
 /**
@@ -371,13 +375,33 @@ void BattlescapeState::think()
 		_game->pushState(*_popups.begin());
 		_popups.erase(_popups.begin());
 		popped = true;
+		return;
 	}
 
-	// it's the alien side, and nothing is happening
-	if (_battleGame->getSide() != FACTION_PLAYER && _states.empty() && !_debugPlay)
+	// nothing is happening - see if we need some alien AI or units panicking or what have you
+	if (_states.empty())
 	{
-		if (_battleGame->getSelectedUnit())
-			handleAI(_battleGame->getSelectedUnit());
+		// it's a non player side (ALIENS or CIVILIANS)
+		if (_battleGame->getSide() != FACTION_PLAYER)
+		{
+			if (!_debugPlay)
+			{
+				if (_battleGame->getSelectedUnit())
+				{
+					if (!handlePanickingUnit(_battleGame->getSelectedUnit()))
+						handleAI(_battleGame->getSelectedUnit());
+				}
+			}
+		}
+		else
+		{
+			// it's a player side && we have not handled all panicking units
+			if (!_playerPanicHandled)
+			{
+				_playerPanicHandled = handlePanickingPlayer();
+			}
+		}
+
 	}
 
 }
@@ -395,7 +419,6 @@ void BattlescapeState::handleAI(BattleUnit *unit)
 	unit->think(&_action);
 	if (_action.type == BA_WALK)
 	{
-		_tuReserved = BA_SNAPSHOT; // aliens are not dumb :)
 		statePushBack(new UnitWalkBState(this, _action));
 	}
 
@@ -424,7 +447,7 @@ void BattlescapeState::handleAI(BattleUnit *unit)
 				_debugPlay = true;
 			}
 		}
-		if (playableUnitSelected())
+		if (_battleGame->getSelectedUnit())
 		{
 			_map->centerOnPosition(_battleGame->getSelectedUnit()->getPosition());
 		}
@@ -687,8 +710,6 @@ void BattlescapeState::endTurn()
 	Position p;
 
 	_debugPlay = false;
-	_tuReserved = BA_NONE;
-	_reserve = _btnReserveNone;
 	_action.type = BA_NONE;
 
 	// check for hot grenades on the ground
@@ -760,13 +781,19 @@ void BattlescapeState::endTurn()
 		statePushNext(new ExplosionBState(this, p, 0, 0, t));
 	}
 
-	checkForCasualties(0, 0);
+	bool bBattleIsOver = checkForCasualties(0, 0);
+	if (bBattleIsOver)
+	{
+		return;
+	}
 
 	updateSoldierInfo();
+
 	if (playableUnitSelected())
 	{
 		_map->centerOnPosition(_battleGame->getSelectedUnit()->getPosition());
 	}
+
 	_game->pushState(new NextTurnState(_game, _battleGame));
 }
 
@@ -775,8 +802,9 @@ void BattlescapeState::endTurn()
  * Checks for casualties and adjusts morale accordingly.
  * @param murderweapon
  * @param murderer
+ * @return Whether the battle is finished.
  */
-void BattlescapeState::checkForCasualties(BattleItem *murderweapon, BattleUnit *murderer)
+bool BattlescapeState::checkForCasualties(BattleItem *murderweapon, BattleUnit *murderer)
 {
 	// TODO : include rank bonuses and penalties !!
 	for (std::vector<BattleUnit*>::iterator j = _battleGame->getUnits()->begin(); j != _battleGame->getUnits()->end(); ++j)
@@ -842,7 +870,10 @@ void BattlescapeState::checkForCasualties(BattleItem *murderweapon, BattleUnit *
 	if (liveAliens == 0 || liveSoldiers == 0)
 	{
 		finishBattle(false);
+		return true;
 	}
+
+	return false;
 }
 
 /**
@@ -966,7 +997,7 @@ void BattlescapeState::handleNonTargetAction()
 	{
 		if (_action.type == BA_PRIME && _action.value > -1)
 		{
-			if (_action.actor->spendTimeUnits(_action.TU, _game->getSavedGame()->getBattleGame()->getDebugMode()))
+			if (_action.actor->spendTimeUnits(_action.TU, dontSpendTUs()))
 			{
 				_action.weapon->setExplodeTurn(_game->getSavedGame()->getBattleGame()->getTurn() + _action.value);
 			}
@@ -1268,7 +1299,7 @@ void BattlescapeState::popState()
 
 	if (_states.empty()) return;
 
-	if (_states.front()->getResult().length() > 0 && _battleGame->getSide() == FACTION_PLAYER)
+	if (_states.front()->getResult().length() > 0 && _battleGame->getSide() == FACTION_PLAYER && !dontSpendTUs())
 	{
 		_warning->showMessage(_game->getLanguage()->getString(_states.front()->getResult()));
 		actionFailed = true;
@@ -1279,7 +1310,7 @@ void BattlescapeState::popState()
 	{
 		if (_action.targeting && _battleGame->getSelectedUnit() && !actionFailed)
 		{
-			_action.actor->spendTimeUnits(_action.TU, _battleGame->getDebugMode());
+			_action.actor->spendTimeUnits(_action.TU, dontSpendTUs());
 		}
 		if (_action.type == BA_THROW && !actionFailed)
 		{
@@ -1396,6 +1427,8 @@ void BattlescapeState::popup(State *state)
  */
 bool BattlescapeState::checkReservedTU(BattleUnit *bu, int tu)
 {
+	if (dontSpendTUs() || _battleGame->getSide() != FACTION_PLAYER) return true; // aliens don't reserve TUs
+
 	if (_tuReserved != BA_NONE &&
 		tu + bu->getActionTUs(_tuReserved, bu->getMainHandWeapon()) > bu->getTimeUnits())
 	{
@@ -1457,6 +1490,116 @@ void BattlescapeState::dropItem(const Position &position, BattleItem *item, bool
 	}
 
 	item->setSlot(_game->getRuleset()->getInventory("STR_GROUND"));
+	item->setOwner(0);
+}
+
+/**
+ * Pick the first soldier from the list in status panic.
+ * @return True when all panicking is over.
+ */
+bool BattlescapeState::handlePanickingPlayer()
+{
+	for (std::vector<BattleUnit*>::iterator j = _battleGame->getUnits()->begin(); j != _battleGame->getUnits()->end(); ++j)
+	{
+		if (handlePanickingUnit(*j))
+			return false;
+	}
+	return true;
+}
+
+/**
+ * Cmmon function for panicking units.
+ * @return False when unit not in panicking mode.
+ */
+bool BattlescapeState::handlePanickingUnit(BattleUnit *unit)
+{
+	UnitStatus status = unit->getStatus();
+	if (status != STATUS_PANICKING && status != STATUS_BERSERK) return false;
+	unit->setVisible(true);
+
+	std::wstringstream ss;
+	ss << unit->getUnit()->getName(_game->getLanguage()) << L'\n' << _game->getLanguage()->getString(status==STATUS_PANICKING?"STR_HAS_PANICKED":"STR_HAS_GONE_BERSERK");
+	_game->pushState(new InfoboxState(_game, ss.str()));
+
+	unit->abortTurn(); //makes the unit go to status STANDING :p
+
+	int dropweapons = RNG::generate(0,100);
+	int flee = RNG::generate(0,100);
+	switch (status)
+	{
+	case STATUS_PANICKING: // 1/2 chance to drop weapons and 1/2 chance try to flee
+
+		if (dropweapons <= 50)
+		{
+			BattleItem *item = unit->getItem("STR_RIGHT_HAND");
+			if (item)
+			{
+				dropItem(unit->getPosition(), item);
+				item->moveToOwner(0);
+			}
+			item = unit->getItem("STR_LEFT_HAND");
+			if (item)
+			{
+				dropItem(unit->getPosition(), item);
+				item->moveToOwner(0);
+			}
+			unit->setCache(0);
+		}
+
+		if (flee <= 50)
+		{
+			_action.actor = unit;
+			_action.target = Position(unit->getPosition().x + RNG::generate(-5,5), unit->getPosition().y + RNG::generate(-5,5), unit->getPosition().z);
+			statePushBack(new UnitWalkBState(this, _action));
+		}
+		break;
+	case STATUS_BERSERK: // berserk - do some weird turning around and then pick the closest unit to shoot towards
+		_action.actor = unit;
+		for (int i= 0; i < 4; i++)
+		{
+			_action.target = Position(unit->getPosition().x + RNG::generate(-5,5), unit->getPosition().y + RNG::generate(-5,5), unit->getPosition().z);
+			statePushBack(new UnitTurnBState(this, _action));
+		}
+		int mindistance = 10000;
+		for (std::vector<BattleUnit*>::iterator i = _battleGame->getUnits()->begin(); i != _battleGame->getUnits()->end(); ++i)
+		{
+			int x = abs(unit->getPosition().x - (*i)->getPosition().x);
+			int y = abs(unit->getPosition().y - (*i)->getPosition().y);
+			int distance = int(floor(sqrt(float(x*x + y*y)) + 0.5));
+
+			if (distance < mindistance && (*i) != unit && !(*i)->isOut())
+			{
+				_action.target = (*i)->getPosition();
+				mindistance = distance;
+			}
+		}
+		statePushBack(new UnitTurnBState(this, _action));
+		_action.type = BA_SNAPSHOT;
+		_action.weapon = unit->getMainHandWeapon();
+		for (int i= 0; i < 6; i++)
+		{
+			statePushBack(new ProjectileFlyBState(this, _action));
+		}
+		break;
+	}
+	unit->setTimeUnits(0);
+	unit->moraleChange(+15);
+
+	return true;
+}
+
+/**
+ * TUs are not spent when handling panicking mode or in debug mode.
+ * @return Whether TUs are spent or not.
+ */
+bool BattlescapeState::dontSpendTUs()
+{
+	if (_battleGame->getDebugMode())
+		return true;
+	if (!_playerPanicHandled)
+		return true;
+
+	return false;
 }
 
 }

src/Battlescape/BattlescapeState.h

@@ -86,14 +86,16 @@ class BattlescapeState : public State
 	BattleAction _action;
 	BattleActionType _tuReserved;
 	std::vector<State*> _popups;
-	bool _debugPlay;
+	bool _debugPlay, _playerPanicHandled;
 
 	void selectNextPlayerUnit(bool checkReselect);
 	void endTurn();
 	void handleItemClick(BattleItem *item);
 	void blinkVisibleUnitButtons();
 	void handleNonTargetAction();
 	void setupCursor();
+	bool handlePanickingPlayer();
+	bool handlePanickingUnit(BattleUnit *unit);
 public:
 	static const int DEFAULT_ANIM_SPEED = 100;
 	/// Creates the Battlescape state.
@@ -179,7 +181,9 @@ class BattlescapeState : public State
 	/// Displays a popup window.
 	void popup(State *state);
 	/// Checks for casualties in battle.
-	void checkForCasualties(BattleItem *murderweapon, BattleUnit *murderer);
+	bool checkForCasualties(BattleItem *murderweapon, BattleUnit *murderer);
+	/// Checks if a unit panics.
+	void checkForPanic(BattleUnit *unit);
 	/// Check reserved tu.
 	bool checkReservedTU(BattleUnit *bu, int tu);
 	/// Handles unit AI.
@@ -188,6 +192,8 @@ class BattlescapeState : public State
 	void finishBattle(bool abort);
 	/// Add item & affect with gravity.
 	void dropItem(const Position &position, BattleItem *item, bool newItem = false);
+	/// Check whether TUs should be spent.
+	bool dontSpendTUs();
 };
 
 }