Tactics3DApp.h

Go to the documentation of this file.

//    Copyright (C) 2006-2015 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This file is part of Tactics3D.
//
//    Tactics3D 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 2 of the License, or
//    (at your option) any later version.
//
//    Tactics3D 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 this program; if not, write to the Free Software
//    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef TACTICS3DAPP_H
#define TACTICS3DAPP_H

#include "../Libs/OgreCore_LIB/OgreCore.h"
#include "../Libs/Graphics_LIB/GUI.h"
#include "../Libs/Utils_LIB/USocket.h"

#include "Tactics3DPC.h"
#include "Tactics3DNPC.h"
#include "Tactics3DRemotePC.h"

#include <OgreRenderObjectListener.h>

#include <tinyxml.h>

namespace Tactics3D {
    class IntroScreen;
    class LobbyScreen;
    class MainScreen;
    class WarriorsSetupScreen;
    class WarriorsWrapupScreen;

#ifdef _WIN32
    DWORD WINAPI gameLoop(LPVOID arg);
#else
    void* gameLoop(void* arg);
#endif

    class AppUserObj {
    public:
        enum TYPE { NONE, WARRIOR };
        TYPE _type;
        Warrior* _warrior;
        bool _isMovable;

        AppUserObj(TYPE type_, Warrior* warrior_=0) : _type(type_), 
            _warrior(warrior_), _isMovable(false) {}

        virtual long getTypeID() const { return _type; }

        inline bool isMovable() const { return _isMovable; }
        inline void setMovable(bool isMovable_) { _isMovable = isMovable_; }
    };

    class InputListener : public OpenSkyNet::Graphics::InputListener {
    public:
        Warrior* _currPickedWarrior;

        virtual ~InputListener() {}

        virtual bool keyPressed(const OIS::KeyEvent& arg);
        virtual bool keyReleased(const OIS::KeyEvent& arg);

        virtual void pickNode(Ogre::SceneNode* node_);
    };

    class App : public OpenSkyNet::Graphics::UI, public Ogre::RenderObjectListener {
    public:
        enum WARRIOR_SETUP_STAGE { WARRIOR_SETUP_DESC, WARRIOR_SETUP_DEX, WARRIOR_SETUP_STR, 
            WARRIOR_SETUP_END, WARRIOR_SETUP_FIGHTING_STYLE, WARRIOR_SETUP_INV, WARRIOR_SETUP_READY, WARRIOR_SETUP_DONE };

        enum WARRIOR_TYPE { WARRIOR_TYPE_NPC, WARRIOR_TYPE_PC, WARRIOR_TYPE_REMOTE_PC };
    private:
        friend class Tactics3D::InputListener;
        friend class Tactics3D::IntroScreen;
        friend class Tactics3D::LobbyScreen;
        friend class Tactics3D::MainScreen;
        friend class Tactics3D::WarriorsSetupScreen;
        friend class Tactics3D::WarriorsWrapupScreen;

#ifdef _WIN32
        friend DWORD WINAPI gameLoop(LPVOID arg);
        friend DWORD WINAPI serverAccept(LPVOID arg);
        friend DWORD WINAPI recvPCAttributes(LPVOID arg);
#else
        friend void* gameLoop(void* arg);
        friend void* serverAccept(void* arg);
        friend void* recvPCAttributes(void* arg);
#endif
        OpenSkyNet::Utils::Thread _gameLoopThread;

        TiXmlDocument _tactics3DObjectsDoc;
        volatile bool _areWarriorsSetup, _isGameStageOver;
        std::vector<WARRIOR_SETUP_STAGE> _warriorSetupStage;
        std::vector<WARRIOR_TYPE> _warriorType;
        std::vector<bool> _isWarriorMusician;

        OpenSkyNet::Utils::uint _gameStage;
        Warrior::TEAM _teamThatWon;

        CEGUI::WindowManager* _wMgr;
        Ogre::SceneNode* _objNode;
        OpenSkyNet::Core::Cinematographer* _cine;
        std::set<OpenSkyNet::CD::Volume*> _pFVolumes;
        std::set<OpenSkyNet::CD::Volume*> _cDVolumes;
        const Ogre::Vector3* _vCorners;
        OpenSkyNet::Math::Point<> _pCorners[8];
        std::vector<Warrior*> _warriors;
        unsigned int _keysHeldDown;
        std::map<const Warrior*,CEGUI::Window*> _warriorsToWindows;
        Warrior* _currWarriorGettingActions;
        std::vector<Warrior*> _currChosenDefenders;
        volatile bool _canAcceptPCActionsInput;
        volatile bool _canSetGotActionsEvent;
        bool _shouldFocusOnPickedWarrior;
        Action* _currAction;
        std::map<CEGUI::Window*,Ogre::Camera*> _dieRollCams;

        //Networking
        OpenSkyNet::Utils::Socket _socket;

        OpenSkyNet::Utils::LockableCS _coreCS;

#ifdef TACTICS3D_DEBUG
        bool _doRayTraceDebugDraw;
        OpenSkyNet::Math::Point<> _debugRayOrigin, _debugRayDir;

        Ogre::ManualObject* _debugSpreadPointObj;
        OpenSkyNet::Math::Point<float, 2> _debugSpreadPoint;
        OpenSkyNet::Math::Point<> _debugSpreadRayOrigin, _debugSpreadRayDir;
#endif

        //Setup/Teardown Operations
        virtual bool setup(bool restoreOgreConfig_);
        void setupDieRollCameras(const Warrior* warrior_);
        void setupDieRollViewports(const Warrior* warrior_);
        virtual void destroyScene(bool doDestroyPersistentData_);
        void teardownDieRollViewports(const Warrior* warrior_);
        void teardownEventHandlers();
        void clearCEGUICache();

        //Modify warrior GUI elements that can change between combat rounds
        void updateWarriorGUI(const Warrior* warrior_, const std::string& warriorWindowPrefix_);

        //Showing Player Messages
        std::queue<std::string> _msgs;
        void showPlayerMessage(const char* msg_, bool clearQueue_=true, bool queue_=false, bool showCancel_=false);

        //Serialization
        void serializeWarrior(const Warrior* warrior_, TiXmlElement* element_);
    protected:
        virtual bool configure(bool restoreOgreConfig_);
    public:
        App();

        virtual bool setup(bool restoreOgreConfig_, bool isSmokeTest_);
        void loadTactics3DObjectsXML(const char* tactics3DObjectsXML_, bool loadWarriorsImages_);
        void loadWarriorXML(OpenSkyNet::Utils::uint index_);
        void loadWarriorsXMLs();
        void loadWarriorGUI(const Warrior* warrior_, const std::string& warriorWindowPrefix_);
        void loadWarriorsGUIs();
        void setupDieRollCameras();
        void setupGame();
        virtual void setupEventHandlers();
        virtual void createCamera() {}
        virtual void createViewports() {}

        inline WARRIOR_SETUP_STAGE getWarriorSetupStage(int warriorIndex_) const { return _warriorSetupStage[warriorIndex_]; }
        inline void setWarriorSetupStage(int warriorIndex_, WARRIOR_SETUP_STAGE stage_) { _warriorSetupStage[warriorIndex_] = stage_; }
        bool areWarriorsSetup() const;

        virtual void go();

        inline OpenSkyNet::Utils::uint getGameStage() { return _gameStage; }
        inline OpenSkyNet::Utils::uint incrementGameStage() { return ++_gameStage; }

        virtual void moveCamera();

        virtual bool processUnbufferedMouseInput(const Ogre::FrameEvent& evt);

        virtual bool frameStarted(const Ogre::FrameEvent& evt);
        virtual bool frameEnded(const Ogre::FrameEvent& evt);

        virtual void switchMouseMode();

        bool handleWarriorsSetupWindows(const CEGUI::EventArgs& e);
        void handleWarriorsSetupDone();

        bool handleActionDoneButton(const CEGUI::EventArgs& e);
        bool handleActionCancelButton(const CEGUI::EventArgs& e);
        bool handleActionsCombobox(const CEGUI::EventArgs& e);
        bool handleActionsListbox(const CEGUI::EventArgs& e);

        bool handleSpecialMoveCombobox(const CEGUI::EventArgs& e);
        bool handleSpecialMoveSpinner(const CEGUI::EventArgs& e);
        bool handleSpecialMoveChooseOpponentButton(const CEGUI::EventArgs& e);

        bool handleSuperPowerCombobox(const CEGUI::EventArgs& e);
        bool handleSuperPowerChooseButton(const CEGUI::EventArgs& e);

        static void onCurrCamJustBecameWarriorPOVWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onCurrCamJustBecameWarriorPOV(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onBeginRoundWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onBeginRound(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onInitiativeRolledWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onInitiativeRolled(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onAllInitiativesRolledWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onAllInitiativesRolled(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onPreGetWarriorActionsWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onPreGetWarriorActions(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onGetWarriorActionsWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onGetWarriorActions(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onPostGetWarriorActionsWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onPostGetWarriorActions(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onPostGetAllWarriorsActionsWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onPostGetAllWarriorsActions(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onPreWarriorPerformWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onPreWarriorPerform(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onPostWarriorPerformWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onPostWarriorPerform(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onPostWarriorPerformAllWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onPostWarriorPerformAll(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onWarriorAttackedWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onWarriorAttacked(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onWarriorDeadWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onWarriorDead(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onRecvPCAttributesWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onRecvPCAttributes(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onLockCoreWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onLockCore(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        static void onUnlockCoreWrapper(void* instance_, std::vector<OpenSkyNet::Utils::TaggedUnion> params_);
        virtual void onUnlockCore(std::vector<OpenSkyNet::Utils::TaggedUnion> params_);

        void pFDebugDraw(Warrior* warrior_);
        void rayTraceDebugDraw();

        virtual void notifyRenderSingleObject(Ogre::Renderable* rend, const Ogre::Pass* pass, const Ogre::AutoParamDataSource* source, const Ogre::LightList* pLightList, bool suppressRenderStateChanges);

        inline bool isOnlineGame() const { return _socket.isConnected(); }
        inline bool isServer() const { return _socket.isConnectedAsServer(); }
        inline bool isClient() const { return _socket.isConnectedAsClient(); }

        inline OpenSkyNet::Utils::uint getNumWarriors() const { return static_cast<OpenSkyNet::Utils::uint>(_warriors.size()); }

        inline Warrior* getWarrior(OpenSkyNet::Utils::uint warriorIndex_) const {
            assert(static_cast<OpenSkyNet::Utils::uint>(_warriors.size()) > warriorIndex_);
            return _warriors[warriorIndex_];
        }

        inline CEGUI::Window* getWarriorWindow(const Warrior* warrior_) const {
            std::map<const Warrior*, CEGUI::Window*>::const_iterator i = _warriorsToWindows.find(warrior_);
            if (i != _warriorsToWindows.end())
                return i->second;
            return 0;
        }

        inline Warrior* getPickedWarrior() const {
            Tactics3D::InputListener* tactics3DInputListener = static_cast<Tactics3D::InputListener*>(_inputListener);
            return tactics3DInputListener->_currPickedWarrior;
        }

        inline void shouldFocusOnPickedWarrior(bool shouldFocus_) { _shouldFocusOnPickedWarrior = shouldFocus_; }

        void focusOnWarrior(const Warrior* warrior_);

        Warrior* pickClosestEnemyAlive(const Warrior* warrior_);
        Warrior* pickNextEnemyAlive();
        Warrior* pickPrevEnemyAlive();

        void updateSpecialMoveWindow(bool reset);
        void updateSuperPowerWindow(bool reset);

        bool canAddWarriorAction(const Warrior* warrior_, const Action* action_, CEGUI::Window*& warriorWindow_, CEGUI::Listbox*& actionsListbox_);

        void addWarriorAction(Warrior* warrior_, CEGUI::Listbox* actionsListbox_, Action* action_, bool updateContinuous_, bool insertInFront_=false);

        void addWarriorActions(Warrior* warrior_, bool updateContinuous_);

        inline void setTeamThatWon(Warrior::TEAM team_) { _teamThatWon = team_; }
        inline Warrior::TEAM getTeamThatWon() const { return _teamThatWon; }

        void saveGame();

        void serializeTactics3DObjects(const char* tactics3DObjectsXML_);

        bool serializePCs(const char* inputXML_, const char* outputXML_);

        void destroyAllObjects(bool doDestroyPersistentData_);

        virtual ~App();
    };
}

#endif //TACTICS3DAPP_H