BattleUnit.h

/*
 * Copyright 2010-2014 OpenXcom Developers.
 *
 * This file is part of OpenXcom.
 *
 * OpenXcom is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * OpenXcom is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with OpenXcom.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef OPENXCOM_BATTLEUNIT_H
#define OPENXCOM_BATTLEUNIT_H

#include <vector>
#include <string>
#include "../Battlescape/Position.h"
#include "../Battlescape/BattlescapeGame.h"
#include "../Ruleset/RuleItem.h"
#include "../Ruleset/Unit.h"
#include "../Ruleset/MapData.h"
#include "Soldier.h"

namespace OpenXcom
{

class Tile;
class BattleItem;
class Unit;
class BattleAIState;
class Node;
class Surface;
class RuleInventory;
class Soldier;
class Armor;
class SavedGame;
class Language;
class AlienBAIState;
class CivilianBAIState;

enum UnitStatus {STATUS_STANDING, STATUS_WALKING, STATUS_FLYING, STATUS_TURNING, STATUS_AIMING, STATUS_COLLAPSING, STATUS_DEAD, STATUS_UNCONSCIOUS, STATUS_PANICKING, STATUS_BERSERK};
enum UnitFaction {FACTION_PLAYER, FACTION_HOSTILE, FACTION_NEUTRAL};
enum UnitSide {SIDE_FRONT, SIDE_LEFT, SIDE_RIGHT, SIDE_REAR, SIDE_UNDER};
enum UnitBodyPart {BODYPART_HEAD, BODYPART_TORSO, BODYPART_RIGHTARM, BODYPART_LEFTARM, BODYPART_RIGHTLEG, BODYPART_LEFTLEG};


class BattleUnit
{
private:
    UnitFaction _faction, _originalFaction;
    UnitFaction _killedBy;
    int _id;
    Position _pos;
    Tile *_tile;
    Position _lastPos;
    int _direction, _toDirection;
    int _directionTurret, _toDirectionTurret;
    int _verticalDirection;
    Position _destination;
    UnitStatus _status;
    int _walkPhase, _fallPhase;
    std::vector<BattleUnit *> _visibleUnits, _unitsSpottedThisTurn;
    std::vector<Tile *> _visibleTiles;
    int _tu, _energy, _health, _morale, _stunlevel;
    bool _kneeled, _floating, _dontReselect;
    int _currentArmor[5];
    int _fatalWounds[6];
    int _fire;
    std::vector<BattleItem*> _inventory;
    BattleAIState *_currentAIState;
    bool _visible;
    Surface *_cache[5];
    bool _cacheInvalid;
    int _expBravery, _expReactions, _expFiring, _expThrowing, _expPsiSkill, _expMelee;
    int improveStat(int exp);
    int _motionPoints;
    int _kills;
    int _faceDirection; // used only during strafeing moves
    bool _hitByFire;
    int _moraleRestored;
    int _coverReserve;
    BattleUnit *_charging;
    int _turnsSinceSpotted;
    std::string _spawnUnit;
    std::string _activeHand;

    // static data
    std::string _type;
    std::string _rank;
    std::string _race;
    std::wstring _name;
    UnitStats _stats;
    int _standHeight, _kneelHeight, _floatHeight;
    int _value, _deathSound, _aggroSound, _moveSound;
    int _intelligence, _aggression;
    SpecialAbility _specab;
    Armor *_armor;
    SoldierGender _gender;
    Soldier *_geoscapeSoldier;
    std::vector<int> _loftempsSet;
    Unit *_unitRules;
    int _rankInt;
    int _turretType;
public:
    static const int MAX_SOLDIER_ID = 1000000;
    BattleUnit(Soldier *soldier, UnitFaction faction);
    BattleUnit(Unit *unit, UnitFaction faction, int id, Armor *armor, int diff);
    ~BattleUnit();
    void load(const YAML::Node& node);
    YAML::Node save() const;
    int getId() const;
    void setPosition(const Position& pos, bool updateLastPos = true);
    const Position& getPosition() const;
    const Position& getLastPosition() const;
    void setDirection(int direction);
    void setFaceDirection(int direction);
    int getDirection() const;
    int getFaceDirection() const;
    int getTurretDirection() const;
    int getTurretToDirection() const;
    int getVerticalDirection() const;
    UnitStatus getStatus() const;
    void startWalking(int direction, const Position &destination, Tile *tileBelowMe, bool cache);
    void keepWalking(Tile *tileBelowMe, bool cache);
    int getWalkingPhase() const;
    int getDiagonalWalkingPhase() const;
    const Position &getDestination() const;
    void lookAt(const Position &point, bool turret = false);
    void lookAt(int direction, bool force = false);
    void turn(bool turret = false);
    void abortTurn();
    SoldierGender getGender() const;
    UnitFaction getFaction() const;
    void setCache(Surface *cache, int part = 0);
    Surface *getCache(bool *invalid, int part = 0) const;
    void kneel(bool kneeled);
    bool isKneeled() const;
    bool isFloating() const;
    void aim(bool aiming);
    int directionTo(const Position &point) const;
    int getTimeUnits() const;
    int getEnergy() const;
    int getHealth() const;
    int getMorale() const;
    int damage(const Position &relative, int power, ItemDamageType type, bool ignoreArmor = false);
    void healStun(int power);
    int getStunlevel() const;
    void knockOut(BattlescapeGame *battle);
    void startFalling();
    void keepFalling();
    int getFallingPhase() const;
    bool isOut() const;
    int getActionTUs(BattleActionType actionType, BattleItem *item);
    bool spendTimeUnits(int tu);
    bool spendEnergy(int tu);
    void setTimeUnits(int tu);
    bool addToVisibleUnits(BattleUnit *unit);
    std::vector<BattleUnit*> *getVisibleUnits();
    void clearVisibleUnits();
    bool addToVisibleTiles(Tile *tile);
    std::vector<Tile*> *getVisibleTiles();
    void clearVisibleTiles();
    int getFiringAccuracy(BattleActionType actionType, BattleItem *item);
    int getAccuracyModifier(BattleItem *item = 0);
    double getThrowingAccuracy();
    void setArmor(int armor, UnitSide side);
    int getArmor(UnitSide side) const;
    int getFatalWounds() const;
    double getReactionScore();
    void prepareNewTurn();
    void moraleChange(int change);
    void dontReselect();
    void allowReselect();
    bool reselectAllowed() const;
    void setFire(int fire);
    int getFire() const;
    std::vector<BattleItem*> *getInventory();
    void think(BattleAction *action);
    BattleAIState *getCurrentAIState() const;
    void setAIState(BattleAIState *aiState);
    void setVisible(bool flag);
    bool getVisible() const;
    void setTile(Tile *tile, Tile *tileBelow = 0);
    Tile *getTile() const;
    BattleItem *getItem(RuleInventory *slot, int x = 0, int y = 0) const;
    BattleItem *getItem(const std::string &slot, int x = 0, int y = 0) const;
    BattleItem *getMainHandWeapon(bool quickest = true) const;
    BattleItem *getGrenadeFromBelt() const;
    bool checkAmmo();
    bool isInExitArea(SpecialTileType stt = START_POINT) const;
    int getHeight() const;
    int getFloatHeight() const;
    void addReactionExp();
    void addFiringExp();
    void addThrowingExp();
    void addPsiExp();
    void addMeleeExp();
    void updateGeoscapeStats(Soldier *soldier);
    bool postMissionProcedures(SavedGame *geoscape);
    int getMiniMapSpriteIndex () const;
    void setTurretType(int turretType);
    int getTurretType() const;
    int getFatalWound(int part) const;
    void heal(int part, int woundAmount, int healthAmount);
    void painKillers ();
    void stimulant (int energy, int stun);
    int getMotionPoints() const;
    Armor *getArmor() const;
    std::wstring getName(Language *lang, bool debugAppendId = false) const;
    UnitStats *getStats();
    int getStandHeight() const;
    int getKneelHeight() const;
    int getLoftemps(int entry = 0) const;
    int getValue() const;
    int getDeathSound() const;
    int getMoveSound() const;
    bool isWoundable() const;
    bool isFearable() const;
    int getIntelligence() const;
    int getAggression() const;
    int getSpecialAbility() const;
    void setSpecialAbility(SpecialAbility specab);
    std::string getRankString() const;
    Soldier *getGeoscapeSoldier() const;
    void addKillCount();
    std::string getType() const;
    void setActiveHand(const std::string &slot);
    std::string getActiveHand() const;
    void convertToFaction(UnitFaction f);
    void instaKill();
    std::string getSpawnUnit() const;
    void setSpawnUnit(std::string spawnUnit);
    int getAggroSound() const;
    void setEnergy(int energy);
    void halveArmor();
    UnitFaction killedBy() const;
    void killedBy(UnitFaction f);
    void setCharging(BattleUnit *chargeTarget);
    BattleUnit *getCharging();
    int getCarriedWeight(BattleItem *draggingItem = 0) const;
    void setTurnsSinceSpotted (int turns);
    int getTurnsSinceSpotted () const;
    UnitFaction getOriginalFaction() const;
    void invalidateCache();

    Unit *getUnitRules() const { return _unitRules; }

    bool _hidingForTurn; // don't zone out and start patrolling again
    Position lastCover;
    std::vector<BattleUnit *> &getUnitsSpottedThisTurn();
    void setRankInt(int rank);
    int getRankInt() const;
    void deriveRank();
    bool checkViewSector(Position pos) const;
    void adjustStats(const int diff);
    bool tookFireDamage() const;
    void toggleFireDamage();
    void setCoverReserve(int reserve);
    int getCoverReserve() const;
    bool isSelectable(UnitFaction faction, bool checkReselect, bool checkInventory) const;
    bool hasInventory() const;
};

}

#endif