source: GTP/trunk/App/Demos/Illum/Ogre/src/Common/include/FPSPlayer.h @ 2473

#pragma once

#include "Ogre.h"
#include "OgreBillboardParticleRenderer.h"
#include "OgreIlluminationManager.h"
#include "NXOgre.h"
#include "GeoLodStripsLibrary.h"
#include "GeoMeshLoader.h"

using namespace Ogre;
using namespace NxOgre;

enum PlayerAnimState
{
        PLAYERANIMSTATE_STAND,
        PLAYERANIMSTATE_IDLE,
        PLAYERANIMSTATE_ATTACK,
        PLAYERANIMSTATE_BLOCK,
        PLAYERANIMSTATE_WALK,
        PLAYERANIMSTATE_PAIN,
        PLAYERANIMSTATE_DEATH,
        PLAYERANIMSTATE_TURN
};

class PlayerCharacter;
class FireBall;
class MyCharMoveController;

class CharacterManager
{
public:
        static CharacterManager& getSingleton()
        {
                if(mSingleton == 0)
                        mSingleton = new CharacterManager();
                return *mSingleton;
        }
        PlayerCharacter* getTrigger(NxOgre::Actor* a)
        {
                if(triggers.find(a)== triggers.end())
                        return 0;
                return triggers[a];
        }
        PlayerCharacter* getTarget(NxOgre::Actor* a)
        {
                if(targets.find(a)== targets.end())
                        return 0;
                return targets[a]; 
        }

        void addTrigger(NxOgre::Actor* a, PlayerCharacter* c){triggers[a] = c;}
        void addTarget(NxOgre::Actor* a, PlayerCharacter* c){targets[a] = c;}

        void levelUP();
        
        SceneManager* mSceneManager;
        Scene* mScene;

protected:
        CharacterManager(){}
        static CharacterManager* mSingleton;
        std::map<NxOgre::Actor*, PlayerCharacter*> triggers;
        std::map<NxOgre::Actor*, PlayerCharacter*> targets;
        
};


class PlayerCharacter  : public FrameListener
{
public:

        PlayerCharacter(String name, Scene* scene, SceneManager* sceneManager, Vector3 dimensions, Vector3 startPosition, bool debug = false);
        
        virtual void addPlayerMesh(String meshname, float meshscale, bool rotateModel);
        virtual bool frameStarted(const FrameEvent& evt);
        virtual void addWeaponModel(String meshname, String attachBoneName);
        virtual void doAction(float dt){}
        virtual float getHit(){return 0;}
        virtual void addHit(float hit){mHealth -= hit; if(mHealth < 0) mHealth = 0;}
        
        static unsigned int frameListenerPriority;

        Entity* getMeshEntity(){return mCharacterMeshEntity;}
        
protected:
        
        String mName;
        Entity* mCharacterMeshEntity;
        Entity* mWeaponEntity;
        Bone* mWeaponAttachBone;
    SceneNode* mWeaponNode;
        SceneNode*  mWeaponBoundNode;
        SceneNode*  mWeaponBoundDebugNode;
        SceneNode*  mPlayerBoundDebugNode;
        Actor* mWeaponBound;
        Scene* mScene;
        Character* mPlayerCharacter;
        SceneNode* mPlayerNode;
        float mMeshScale;
        AnimationState* mCharacterMesh_AnimState;
        SceneManager* mSceneManager;
        PlayerAnimState mCurrentAnimState;
        int mWeapon;
        bool mMoving;
        bool mForceAnimChange;
        MyCharMoveController* mCharacterController;
        Vector3 mPlayerDimensions;
        bool mRunning;
        bool isAlive;
        
        SceneNode* mWeaponNode2;
        bool mDebug;

        float mHealth;
                
        float getAnimSpeed(){return 1.2;}
        virtual String getAnimStateName(PlayerAnimState as,  int option = 0){return "stand";}
        virtual void setAnimState(PlayerAnimState as){}
        
};

class TrollCharacter : public PlayerCharacter
{
public:
        TrollCharacter(String name, Scene* scene, SceneManager* sceneManager, Vector3 dimensions, Vector3 startPosition, bool debug = false);
        ~TrollCharacter(){}

        void doAction(float dt);
        float getHit(){ if(mCurrentAnimState == PLAYERANIMSTATE_ATTACK) return 20; else return 0;}
        void addHit(float hit);
        void addPlayerMesh(String meshname, float meshscale, bool rotateModel);

        bool frameStarted(const FrameEvent& evt)
        {
        /*      OverlayElement* healthUI = OverlayManager::getSingleton().getOverlayElement("MannaColumn");
                float relHealth = mHealth / MaxHealth;
                healthUI->setHeight(0.29 * relHealth);
                healthUI->setTop(0.005 +  (1.0 - relHealth) * 0.29);*/
                
                return PlayerCharacter::frameStarted(evt);
        }
protected:
        String getAnimStateName(PlayerAnimState as,  int option = 0);
        void setAnimState(PlayerAnimState as);

        static float MaxHealth;
        static Geometry::GeoMeshLoader* meshLoader;
        static Geometry::Mesh *trollLODMesh;
        Geometry::LodStripsLibrary *lodObject;
        float lastLodLevel;
};

class FPSPlayer : public PlayerCharacter
{
public:
        FPSPlayer(Scene* scene, SceneManager* sceneManager, Vector3 dimensions, Vector3 startPosition, float cameraHeight, Camera* cam, bool debug = false);
        ~FPSPlayer(void);

        void addPlayerMesh(String meshname, float meshscale, bool rotateModel);
        virtual void processKeyInputs(InputReader* inputDevice);
        bool frameStarted(const FrameEvent& evt);
        virtual void processMouseInputs(InputReader* inputDevice);      
        void addWeaponModel(String meshname, String attachBoneName);
        Vector3 getPosition(){return mPlayerNode->getWorldPosition();
                return mPlayerCharacter->getGlobalPosition();}
        Vector3 getDirection()
        {
                Vector3 dir = mCamera->getDerivedDirection();
                dir.normalise();
                return dir;
        }
//      Vector3 getOrienation(){return mPlayerCharacter->getGlobalOrientation();}
        float getHit()
        { 
                if(mCurrentAnimState == PLAYERANIMSTATE_ATTACK){
                        if(mWeapon) return 20;
                        else return 15;
                }else return 0;
        }
        void addHit(float hit)
        {
                if(isAlive)
                {
                        PlayerCharacter::addHit(hit);
                        if(mHealth <= 0)//death
                        {
                                static deaths = 0;
                                deaths++;
                                isAlive = false;
                                OverlayElement* deathsTextBox = OverlayManager::getSingleton().getOverlayElement("Deaths");
                                        deathsTextBox->setCaption("Deaths: "+StringConverter::toString(deaths));
                        }
                }
        }

        void levelUp(){mMaxHealth += 30; mHealth = mMaxHealth;
                                        mMaxStrength += 20; mStrength = mMaxStrength;
                                        mMaxManna += 30; mManna = mMaxManna;}

        static FPSPlayer* thePlayer;
        static FPSPlayer* getPlayer(){return thePlayer;}
        void addCharacterInRange(PlayerCharacter* c){mCharactersInRange.insert(c);}
        void removeCharacterInRange(PlayerCharacter* c){mCharactersInRange.erase(c);}

protected:

        Camera* mCamera;
        float mCameraHeight;
        float mStrength;
        float mMaxStrength;
        float mManna;
        float mMaxManna;
        float mMaxHealth;
        FireBall* mFireBall;
        
        std::set<PlayerCharacter*> mCharactersInRange;

        String getAnimStateName(PlayerAnimState as,  int option = 0);
        void setAnimState(PlayerAnimState as);
};