RpgCharacter.h

#pragma once
#include "BipedObject.h"
#include <vector>
namespace ParaEngine
{

    using namespace std;
    // forward declare
    //class CDnDCharacterAttribute;
    struct CNpcDbItem;

    class CDnDCharacterAttribute : public IAttributeFields
    {
    public:
        CDnDCharacterAttribute();
        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_CDndCharacterAttribute;}
        virtual const char* GetAttributeClassName(){static const char name[] = "Typical DnD Character"; return name;}
        virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

    public:
        float m_fLifePoint;
        float m_fAge;
        float m_fHeight;
        float m_fWeight;
        int m_nOccupation;
        int m_nRaceSex;

        float m_fStrength;
        float m_fDexterity;
        float m_fIntelligence;
        float m_fBaseDefense;
        float m_fDefense, m_fDefenseflat, m_fDefenseMental;
        float m_fBaseAttack;
        float m_fAttackMelee, m_fAttackRanged, m_fAttackMental;
        float m_fMaxLifeLoad;

        int m_nHeroPoints;

        vector<int> m_skills;
        vector<int> m_tools;
    };

    class CRpgCharacter : public CBipedObject
    {
    public:
        CRpgCharacter(void);
        virtual ~CRpgCharacter(void);
        virtual CBaseObject::_SceneObjectType GetType(){return CBaseObject::RPGBiped;};
    public:
        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_CRpgCharacter;}
        virtual const char* GetAttributeClassName(){static const char name[] = "RPG Character"; return name;}
        virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);
        
        ATTRIBUTE_METHOD1(CRpgCharacter, GetCharacterID_s, int*)        {*p1 = cls->GetCharacterID(); return S_OK;}
        ATTRIBUTE_METHOD1(CRpgCharacter, SetCharacterID_s, int)     {cls->SetCharacterID(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CRpgCharacter, GetCharacterType_s, int*)      {*p1 = cls->GetCharacterType(); return S_OK;}
        ATTRIBUTE_METHOD1(CRpgCharacter, SetCharacterType_s, int)       {cls->SetCharacterType(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CRpgCharacter, GetMentalState0_s, int*)       {*p1 = cls->GetMentalState(0); return S_OK;}
        ATTRIBUTE_METHOD1(CRpgCharacter, SetMentalState0_s, int)        {cls->SetMentalState(0, (byte)p1); return S_OK;}
        ATTRIBUTE_METHOD1(CRpgCharacter, GetMentalState1_s, int*)       {*p1 = cls->GetMentalState(1); return S_OK;}
        ATTRIBUTE_METHOD1(CRpgCharacter, SetMentalState1_s, int)        {cls->SetMentalState(1, (byte)p1); return S_OK;}
        ATTRIBUTE_METHOD1(CRpgCharacter, GetMentalState2_s, int*)       {*p1 = cls->GetMentalState(2); return S_OK;}
        ATTRIBUTE_METHOD1(CRpgCharacter, SetMentalState2_s, int)        {cls->SetMentalState(2, (byte)p1); return S_OK;}
        ATTRIBUTE_METHOD1(CRpgCharacter, GetMentalState3_s, int*)       {*p1 = cls->GetMentalState(3); return S_OK;}
        ATTRIBUTE_METHOD1(CRpgCharacter, SetMentalState3_s, int)        {cls->SetMentalState(3, (byte)p1); return S_OK;}

#ifndef DEFINE_ATTRIBUTE_METHODS_DND
#define DEFINE_ATTRIBUTE_METHODS_DND(type, AttriName) \
        ATTRIBUTE_METHOD1(CRpgCharacter, Get##AttriName##_s, type*)     {*p1 = cls->Get##AttriName(); return S_OK;}\
        ATTRIBUTE_METHOD1(CRpgCharacter, Set##AttriName##_s, type)      {cls->Set##AttriName(p1); return S_OK;}
#endif

        DEFINE_ATTRIBUTE_METHODS_DND(float, LifePoint);
        DEFINE_ATTRIBUTE_METHODS_DND(float, Age);
        DEFINE_ATTRIBUTE_METHODS_DND(float, BodyHeight);
        DEFINE_ATTRIBUTE_METHODS_DND(float, Weight);
        DEFINE_ATTRIBUTE_METHODS_DND(int, Occupation);
        DEFINE_ATTRIBUTE_METHODS_DND(int, RaceSex);
        DEFINE_ATTRIBUTE_METHODS_DND(float, Strength);
        DEFINE_ATTRIBUTE_METHODS_DND(float, Dexterity);
        DEFINE_ATTRIBUTE_METHODS_DND(float, Intelligence);
        DEFINE_ATTRIBUTE_METHODS_DND(float, BaseDefense);
        DEFINE_ATTRIBUTE_METHODS_DND(float, Defense);
        DEFINE_ATTRIBUTE_METHODS_DND(float, Defenseflat);
        DEFINE_ATTRIBUTE_METHODS_DND(float, DefenseMental);
        DEFINE_ATTRIBUTE_METHODS_DND(float, BaseAttack);

        DEFINE_ATTRIBUTE_METHODS_DND(float, AttackMelee);
        DEFINE_ATTRIBUTE_METHODS_DND(float, AttackRanged);
        DEFINE_ATTRIBUTE_METHODS_DND(float, AttackMental);
        DEFINE_ATTRIBUTE_METHODS_DND(float, MaxLifeLoad);
        DEFINE_ATTRIBUTE_METHODS_DND(int, HeroPoints);
        // TODO: define GetSkill and GetTool
        
    public:
        enum CHARACTER_TYPE{
            CHAR_NPC,
            CHAR_BOSS,
            CHAR_HERO,
            CHAR_SPAWN,
            CHAR_NONE, // character without any attributes
        };
        
        int GetCharacterID(){return m_nCharacterID;}
        void SetCharacterID(int nID){m_nCharacterID = nID;}

        int GetCharacterType(){return m_nCharacterType;};
        void SetCharacterType(int nType);

        DWORD GetMentalState(int nIndex);
        void SetMentalState(int nIndex, DWORD data);

        //
        // define a group of attribute get/set member functions.
        //
#ifndef DEFINE_CLASS_ATTRIBUTE_DND
        #define DEFINE_CLASS_ATTRIBUTE_DND(type, AttriName, memberName, defaultValue) \
            type Get##AttriName(){return (m_pDnDAttribute!=0)?m_pDnDAttribute->memberName : defaultValue;} \
            void Set##AttriName(type p1){if(m_pDnDAttribute!=0) m_pDnDAttribute->memberName = p1;}
#endif

        DEFINE_CLASS_ATTRIBUTE_DND(float, LifePoint, m_fLifePoint, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, Age, m_fAge, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, BodyHeight, m_fHeight, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, Weight, m_fWeight, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(int, Occupation, m_nOccupation, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(int, RaceSex, m_nRaceSex, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, Strength, m_fStrength, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, Dexterity, m_fDexterity, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, Intelligence, m_fIntelligence, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, BaseDefense, m_fBaseDefense, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, Defense, m_fDefense, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, Defenseflat, m_fDefenseflat, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, DefenseMental, m_fDefenseMental, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, BaseAttack, m_fBaseAttack, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, AttackMelee, m_fAttackMelee, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, AttackRanged, m_fAttackRanged, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, AttackMental, m_fAttackMental, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(float, MaxLifeLoad, m_fMaxLifeLoad, 1);
        DEFINE_CLASS_ATTRIBUTE_DND(int, HeroPoints, m_nHeroPoints, 1);
        
        int GetSkill(int nIndex);
        void SetSkill(int nIndex, int nSkillID);

        int GetTool(int nIndex);
        void SetTool(int nIndex, int ntoolID);


        bool ToNpcDbItem(CNpcDbItem& npc);

        bool UpdateFromNPCDbItem(const CNpcDbItem& npc, DWORD dwFields);
    private:
        int m_nCharacterID;
        int m_nCharacterType;

        vector<DWORD> m_MentalStates;

        union{
            CDnDCharacterAttribute* m_pDnDAttribute;
            void* m_pAttributes;
        };
    };

}