BattlescapeGame.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_BATTLESCAPEGAME_H
#define OPENXCOM_BATTLESCAPEGAME_H

#include "Position.h"
#include <SDL.h>
#include <string>
#include <list>
#include <vector>

namespace OpenXcom
{

class BattleUnit;
class SavedBattleGame;
class BattleItem;
class BattleState;
class BattlescapeState;
class ResourcePack;
class Map;
class TileEngine;
class Pathfinding;
class Ruleset;
class InfoboxOKState;

enum BattleActionType { BA_NONE, BA_TURN, BA_WALK, BA_PRIME, BA_THROW, BA_AUTOSHOT, BA_SNAPSHOT, BA_AIMEDSHOT, BA_STUN, BA_HIT, BA_USE, BA_LAUNCH, BA_MINDCONTROL, BA_PANIC, BA_RETHINK };

struct BattleAction
{
    BattleActionType type;
    BattleUnit *actor;
    BattleItem *weapon;
    Position target;
    std::list<Position> waypoints;
    int TU;
    bool targeting;
    int value;
    std::string result;
    bool strafe, run;
    int diff;
    int autoShotCounter;
    Position cameraPosition;
    bool desperate; // ignoring newly-spotted units
    int finalFacing;
    bool finalAction;
    int number; // first action of turn, second, etc.?
    BattleAction() : type(BA_NONE), actor(0), weapon(0), TU(0), targeting(false), value(0), result(""), strafe(false), run(false), diff(0), autoShotCounter(0), cameraPosition(0, 0, -1), desperate(false), finalFacing(-1), finalAction(false), number(0) { }
};

class BattlescapeGame
{
private:
    SavedBattleGame *_save;
    BattlescapeState *_parentState;
    std::list<BattleState*> _states, _deleted;
    BattleActionType _tuReserved, _playerTUReserved;
    bool _playerPanicHandled;
    int _AIActionCounter;
    BattleAction _currentAction;
    bool _AISecondMove;

    void endTurn();
    bool handlePanickingPlayer();
    bool handlePanickingUnit(BattleUnit *unit);
    bool noActionsPending(BattleUnit *bu);
    std::vector<InfoboxOKState*> _infoboxQueue;
    void showInfoBoxQueue();
    bool _playedAggroSound, _endTurnRequested, _kneelReserved;
public:
    BattlescapeGame(SavedBattleGame *save, BattlescapeState *parentState);
    ~BattlescapeGame();
    void think();
    void init();
    bool playableUnitSelected();
    void handleState();
    void statePushFront(BattleState *bs);
    void statePushNext(BattleState *bs);
    void statePushBack(BattleState *bs);
    void handleNonTargetAction();
    void popState();
    void setStateInterval(Uint32 interval);
    void checkForCasualties(BattleItem *murderweapon, BattleUnit *murderer, bool hiddenExplosion = false, bool terrainExplosion = false);
    void checkForPanic(BattleUnit *unit);
    bool checkReservedTU(BattleUnit *bu, int tu, bool justChecking = false);
    void handleAI(BattleUnit *unit);
    void dropItem(const Position &position, BattleItem *item, bool newItem = false, bool removeItem = false);
    BattleUnit *convertUnit(BattleUnit *unit, std::string newType);
    bool kneel(BattleUnit *bu);
    bool cancelCurrentAction(bool bForce = false);
    BattleAction *getCurrentAction();
    bool isBusy();
    void primaryAction(const Position &pos);
    void secondaryAction(const Position &pos);
    void launchAction();
    void psiButtonAction();
    void moveUpDown(BattleUnit *unit, int dir);
    void requestEndTurn();
    void setTUReserved(BattleActionType tur, bool player);
    void setupCursor();
    Map *getMap();
    SavedBattleGame *getSave();
    TileEngine *getTileEngine();
    Pathfinding *getPathfinding();
    ResourcePack *getResourcePack();
    const Ruleset *getRuleset() const;
    static bool _debugPlay;
    bool getPanicHandled() { return _playerPanicHandled; }
    void findItem(BattleAction *action);
    BattleItem *surveyItems(BattleAction *action);
    bool worthTaking(BattleItem* item, BattleAction *action);
    int takeItemFromGround(BattleItem* item, BattleAction *action);
    bool takeItem(BattleItem* item, BattleAction *action);
    BattleActionType getReservedAction();
    void tallyUnits(int &liveAliens, int &liveSoldiers, bool convert);
    void setKneelReserved(bool reserved);
    bool getKneelReserved();
    bool checkForProximityGrenades(BattleUnit *unit);
    void cleanupDeleted();
};

}

#endif