CERBERUS'S PROFILE

/*
	animated_monsters.cpp
	A dynRPG plugin to animate your monsters with the DBS!
	Feel free to use or modify this as you see fit.
	Your safety is not guaranteed.

	--dragonheartman
	6 JUN 2012

*/

/*
    Modification by Cerberus:
    only several monsters are animated
    26 JAN 2013
*/
#define AUTO_DLLMAIN
#define NUM_POSES 7
#define MAX_MONSTERS 8

#include <DynRPG/DynRPG.h>
#include <sstream>

RPG::Image* monsterPoses[MAX_MONSTERS][NUM_POSES];		/* table containing all images created */
RPG::Image* oldPose;									/* rm2k3's old monster pose, saved off */
boolean resetTable = false;								/* reset table flag */
int frameTimer = 0;										/* global frame updater */
int hurtTimer[MAX_MONSTERS];							/* a timer for how many frames we ought to show the hurt pose */
int oldHP[MAX_MONSTERS];								/* old hp vals to check for damaged enemy */
int poseIndex[MAX_MONSTERS];							/* which monster pose do we show? */
int animationCycle[NUM_POSES] = {1, 2, 3, 2, 4, 5, 6};	/* index for which animation file to display */
/* 1-3 idle, 4 (RPG::monsters[id]->databaseId<=maxnum) &&
      (Animate[RPG::monsters[id]->databaseId]))dead, 5-6 hurt */

int maxnum=0; //in fact, it's the size of Animate array; basely, it means "no animations at all"
bool *Animate; //if Animate[i]=true, the monster which DB number is i+1 is to be anmated
std::map<std::string, std::string> configuration;
bool in_use=false; //is the battler drawn now animated?

bool onStartup(char *pluginName)
{
    int i, len, curnum=0;
               // We load the configuration from the DynRPG.ini file here
               configuration = RPG::loadConfiguration(pluginName);
                if (configuration["Animate"][1]) // i.e. found the list
                {
                    for (i=0, len=configuration["Animate"].length(); i<len; i++)
                    {
                        if (isdigit(configuration["Animate"][i]))
                            curnum=curnum*10+configuration["Animate"][i]-'0';
                        else
                        {
                            if (curnum>maxnum)
                                maxnum=curnum;
                            curnum=0;
                        }
                    }
                    if (curnum>maxnum)
                        maxnum=curnum;
                    curnum=0;
                    //we run through the list and found the highest number
                    //better would be to know how many monster are in DB, but I haven't found this
                    Animate=(bool *)malloc((maxnum+1)*sizeof(bool));
                    memset (Animate, 0, (maxnum+1)*sizeof(bool)); // all the array is filled with "false"
                    curnum=0;
                    for (i=0, len=configuration["Animate"].length(); i<len; i++)
                    {
                        if (isdigit(configuration["Animate"][i]))
                            curnum=curnum*10+configuration["Animate"][i]-'0';
                        else
                        {
                            Animate[curnum]=true;
                            //it's correct, because curnum<=maxnum
                            curnum=0;
                        }
                    }
                    Animate[curnum]=true;
                    //it's correct, because 0<=curnum<=maxnum
                    curnum=0;
                }
                //now, we have an array of booleans, where true means "animate this"
               return true;
}


// destroy ALL the images!!
void initializeBattle()
{
    // update our initial pose indexes (0-3)
    for (int i=0; i<MAX_MONSTERS; i++)
    {
        poseIndex[i]=i%4;
        hurtTimer[i]=0;
        oldHP[i]=0;

        // destroy any remaining images -- no leaks pls
        for (int j=0; j<NUM_POSES; j++){
			if(monsterPoses[i][j])
			{
				RPG::Image::destroy(monsterPoses[i][j]);
			}
        }
    }
}

// called every time a batter is drawn
bool onDrawBattler(RPG::Battler *battler, bool isMonster, int id)
{
    // we will be updating the battler dynamically iff the battler is of type RPG::Monster
    if ((isMonster) &&
        (RPG::monsters[id]->databaseId<=maxnum) &&
        (Animate[RPG::monsters[id]->databaseId]))
    // first, as mentioned above, is that we check is it the monster or the actor
    // second, we check whether the third will be correct
    // third, we check whether the monster have to be animated (according to DynRPG.ini)
    // if one of conditions isn't met, we simply don't do anything
    {
        in_use=true; //this monster is animated, so we need to perform actions after it's drawn
        // if the current HP is less than old HP, we need to set the appropriate hurt timer
        // else: reset oldhp in the case where the enemy is healed
        if(battler->hp < oldHP[id])
        {
            hurtTimer[id] = 30;
            oldHP[id] = battler->hp;
        }
        else if(battler->hp > oldHP[id])
        {
            oldHP[id] = battler->hp;
        }

        // if the monster has hurt poses to display, we need to hard set the frame index to 5 (HURT)
        if(hurtTimer[id] > 0)
        {
            poseIndex[id] = 5 + (frameTimer-1)/5;
            hurtTimer[id]--;
        }

        // if the monster dies, we want to hard set the frame index to 4 (DEAD)
        if(battler->hp <= 0)
        {
            poseIndex[id]=4;
        }

        if(!monsterPoses[id][animationCycle[poseIndex[id]]])
        {
        	// create the new blank image
			monsterPoses[id][animationCycle[poseIndex[id]]] = RPG::Image::create();
			monsterPoses[id][animationCycle[poseIndex[id]]]->useMaskColor = true;

			// load the image file into our image we created
			std::stringstream fileName;
			fileName << "Monster\\" << battler->getName() << "\\" << animationCycle[poseIndex[id]] << ".png";
			monsterPoses[id][animationCycle[poseIndex[id]]]->loadFromFile(fileName.str(), true);
        }
		// we do this (UGLY) cast to update the monster's image to the image in the loader table
        oldPose = static_cast<RPG::Monster*>(battler)->image;
		static_cast<RPG::Monster*>(battler)->image = monsterPoses[id][animationCycle[poseIndex[id]]];
    }
    return true;
}

// after the battler is drawn, we need to set the monster's default image to point back to the saved off image
bool onBattlerDrawn(RPG::Battler *battler, bool isMonster, int id)
{
	if ((isMonster) && (in_use))
	{
		static_cast<RPG::Monster*>(battler)->image = oldPose;
	}
	else in_use=false;
	return true;
}

// called every frame refresh
void onFrame(RPG::Scene scene)
{

    // for battle scenes only, we update a frame timer
    if(RPG::system->scene == RPG::SCENE_BATTLE)
    {
        frameTimer++;

        // every ten frames, update the index to be displayed in our monster's image
        if(frameTimer > 10)
        {
            frameTimer=0;
            for(int i=0; i<MAX_MONSTERS; i++)
            {
                if(hurtTimer[i]==0)
                {
                    poseIndex[i] = (poseIndex[i]+1)%4;
                }
            }
        }

        // set a flag notifying that we need to reset the loader table after combat
        resetTable = true;

    }
    else if (resetTable)
    {

        // reset the loader table post-battle
        initializeBattle();
        resetTable = false;
        in_use=false;
    }
}