C++ I need to adapt system

[kikinsio]

Can anyone help me adapt this to TFS 1.3?

Spoiler

monsters.h

Spoiler

bool isSummonable, isIllusionable, isConvinceable, isAttackable, isHostile, isLureable,
isWalkable, canPushItems, canPushCreatures, pushable, hideName, hideHealth;

Replace with:

bool isSummonable, isIllusionable, isConvinceable, isAttackable, isHostile, isLureable,
isWalkable, canPushItems, canPushCreatures, pushable, hideName, hideHealth, hideLevel;

Search for:

int32_t defense, armor, health, healthMax, baseSpeed, lookCorpse, corpseUnique, corpseAction,
maxSummons, targetDistance, runAwayHealth, conditionImmunities, damageImmunities,
lightLevel, lightColor, changeTargetSpeed, changeTargetChance;

Replace with:

int32_t defense, armor, health, healthMax, baseSpeed, lookCorpse, corpseUnique, corpseAction,
maxSummons, targetDistance, runAwayHealth, conditionImmunities, damageImmunities,
lightLevel, lightColor, changeTargetSpeed, changeTargetChance, levelMin, levelMax;

monsters.cpp

Spoiler

Search for:

canPushItems = canPushCreatures = isSummonable = isIllusionable = isConvinceable = isLureable = isWalkable = hideName = hideHealth = false;

Replace with:

canPushItems = canPushCreatures = isSummonable = isIllusionable = isConvinceable = isLureable = isWalkable = hideName = hideHealth = hideLevel = false;

Search for:

baseSpeed = 200;

Below, add:

levelMin = levelMax = 1;

Find it:

bool Monsters :: loadMonster

Inside the function, look for:

for(xmlNodePtr p = root->children; p; p = p->next)
    {
        if(p->type != XML_ELEMENT_NODE)
            continue;

        if(!xmlStrcmp(p->name, (const xmlChar*)"health"))
        {
            if(!readXMLInteger(p, "max", intValue))
            {
                SHOW_XML_ERROR("Missing health.max");
                monsterLoad = false;
                break;
            }

            mType->healthMax = intValue;
            if(!readXMLInteger(p, "now", intValue))
                mType->health = mType->healthMax;
            else
                mType->health = intValue;
        }

Below, add:

else if(!xmlStrcmp(p->name, (const xmlChar*)"level"))
        {
            if(!readXMLInteger(p, "max", intValue))
                mType->levelMax = 1;
            else
                mType->levelMax = intValue;

            if(!readXMLInteger(p, "min", intValue))
                mType->levelMin = mType->levelMax;
            else
                mType->levelMin = intValue;
        }

Search for:

if(readXMLString(tmpNode, "emblem", strValue))
    mType->guildEmblem = getEmblems(strValue);

Below, add:

if(readXMLString(tmpNode, "hidelevel", strValue))
        mType->hideLevel = booleanString(strValue);

monster.h

Spoiler

Find it:

class Monster : public Creature
{

Just below:

    public:
#ifdef __ENABLE_SERVER_DIAGNOSTIC__
        static uint32_t monsterCount;
#endif
        virtual ~Monster();

Add:

std::string name, nameDescription;
int32_t level;
double bonusAttack, bonusDefense;

Replace:

virtual const std::string& getName() const {return mType->name;}
virtual const std::string& getNameDescription() const {return mType->nameDescription;}
virtual std::string getDescription(int32_t) const {return mType->nameDescription + ".";}

Per:

virtual const std::string& getName() const {return name;}
virtual const std::string& getNameDescription() const {return nameDescription;}
virtual std::string getDescription(int32_t) const {return nameDescription + ".";}

monster.cpp

Spoiler

Search for:

Monster::Monster(MonsterType* _mType):

Just below:

isIdle = true;

Add:

name = _mType->name;
nameDescription = _mType->nameDescription;
level = (int32_t)random_range(_mType->levelMin, _mType->levelMax, DISTRO_NORMAL);
bonusAttack = 1.0;
bonusDefense = 1.0;

Search for:

Monster :: onCreatureAppear

Replace the entire function with:

void Monster::onCreatureAppear(const Creature* creature)
{
    Creature::onCreatureAppear(creature);
    if(creature == this)
    {
        //We just spawned lets look around to see who is there.
        if(isSummon())
        {
            std::string value;
            this->master->getStorage((std::string)"monster_level", value);

            uint8_t intValue = atoi(value.c_str());
            if(intValue || value == "0")
                level = intValue;
            else
                level = 1;
            isMasterInRange = canSee(master->getPosition());
        }

        if(g_config.getBool(ConfigManager::MONSTER_HAS_LEVEL))
        {
            this->healthMax = std::floor(this->getMaxHealth() * (1. + (0.1 * (level - 1))));
            this->health = this->healthMax;

            this->bonusAttack += (0.01 * (level - 1));
            this->bonusDefense += (0.005 * (level - 1));
        }



        updateTargetList();
        updateIdleStatus();
    }
    else
        onCreatureEnter(const_cast<Creature*>(creature));
}

Replace all:

g_config.getDouble(ConfigManager::RATE_MONSTER_DEFENSE)

Per:

g_config.getDouble(ConfigManager::RATE_MONSTER_DEFENSE) * bonusDefense

Replace all:

g_config.getDouble(ConfigManager::RATE_MONSTER_ATTACK)

Per:

g_config.getDouble(ConfigManager::RATE_MONSTER_ATTACK) * bonusAttack

map.cpp

Spoiler

Search for:

#include "game.h"

Add:

#include "configmanager.h"

Search for:

extern Game g_game;

Add below:

extern ConfigManager g_config;

Look for the function:

bool Map::placeCreature
{

Add shortly after:

 Monster* monster = creature->getMonster();
    if(monster && g_config.getBool(ConfigManager::MONSTER_HAS_LEVEL))
    {
        uint8_t level;
        if(!monster->getMonsterType()->hideLevel)
        {
            if(monster->isSummon())
            {
                std::string value;
                monster->getMaster()->getStorage((std::string)"monster_level", value);

                uint8_t intValue = atoi(value.c_str());
                if(intValue || value == "0")
                    level = intValue;
                else
                    level = 1;
            }
            else
                level = monster->level;

            char buffer [10];
            monster->name = monster->getName() + " [" + itoa(level, buffer, 10) + "]";
        }
    }

configmanager.h

Spoiler

Search for:

MONSTER_SPAWN_WALKBACK,

And add below:

MONSTER_HAS_LEVEL,

configmanager.cpp

Spoiler

Search for:

m_loaded = true;

Add a little earlier:

m_confBool[MONSTER_HAS_LEVEL] = getGlobalBool("monsterHasLevel", true);