Skins: |

NWN SCRIPTS

- Jump to comments -

Title

Narfells Creature Resize Include

Author

noth1ng

Submitted / Updated

09-12-2009 / 09-12-2009

Category

Scripting routines

Expansions

NWN-1.69

View Code

//::////////////////////////////////////////////////////////////////////////////
//:: Script: inc_creaturesize
//::////////////////////////////////////////////////////////////////////////////
/*
Script Purpose:
This script supplies the necessary functions to allow creature
resizing on the fly.  It was primarily done for the Story PW Narfell.

It uses the tail-trick to achieve this, and thus is limited
in what can be done - but it attempts to resized as many
different creatures as possible.

Resizing is done in 10% steps - typically from 10% to 200%.

WARNING!
Rearranging the Invisible Type ### from Appearance.2da
will break the script in some places!
*/

//::////////////////////////////////////////////////////////////////////////////
//:: Created by: noth1ng
//:: Created on: July 14th, 2009
//::////////////////////////////////////////////////////////////////////////////
/*
If you wish to use the script, please include the comments above.
*/

// sets the loop limit for the tailmodel.2da! Compare to file!
// setting it too high will be extremely costly!
const int SIZER_TAILMODEL_2DA_LINES = 500;

//:: APPEARANCE.2DA ENTRIES - extended APPEARANCE_TYPE_* constants
const int SIZER_APPEARANCE_INVIS_DRAGON = 569;

const int SIZER_APPEARANCE_INVIS_DWARF_F = 589;
const int SIZER_APPEARANCE_INVIS_ELF_F = 609;
const int SIZER_APPEARANCE_INVIS_GNOME_F = 629;
const int SIZER_APPEARANCE_INVIS_HALFLING_F = 649;
const int SIZER_APPEARANCE_INVIS_HALFORC_F = 669;
const int SIZER_APPEARANCE_INVIS_HUMAN_F = 689;

const int SIZER_APPEARANCE_INVIS_DWARF_M = 709;
const int SIZER_APPEARANCE_INVIS_ELF_M = 729;
const int SIZER_APPEARANCE_INVIS_GNOME_M = 749;
const int SIZER_APPEARANCE_INVIS_HALFLING_M = 769;
const int SIZER_APPEARANCE_INVIS_HALFORC_M = 789;
const int SIZER_APPEARANCE_INVIS_HUMAN_M = 809;

const int SIZER_APPEARANCE_INVIS_CREATURE_S = 829;
const int SIZER_APPEARANCE_INVIS_CREATURE_L = 849;

// Sizes: 0 = 10%, 9 = 100%, 19 = 200%
const int SIZER_NORMAL_SIZE = 9;
const int SIZER_MAX_SIZE = 19;


const string SIZER_ORIGINAL_APPEARANCE = "SIZER:OriginalAppearance";
const string SIZER_ORIGINAL_TAIL = "SIZER:OriginalTailType";
const string SIZER_TAIL_TYPE = "SIZER:TailType";
const string SIZER_BASE_APPEARANCE = "SIZER:BaseSizerAppearance";

// Failed lookup storing
const int SIZER_APPEARANCE_NO_RESIZE = -1;

//:: FUNCTIONS /////////////////////////////////////////////////////////////////

// sets the nearest possible size - 1.0f is normal size
// only works on a limited selection of models
void SIZER_SetSizeF(float fSize, object oTarget = OBJECT_SELF);

// sets the nearest possible size - 100 is normal size
// only works on a limited selection of models
void SIZER_SetSize(int nSize, object oTarget = OBJECT_SELF);


// shrinks a creature by one step - typically a step is 10% of original size
void SIZER_ShrinkCreature(object oTarget = OBJECT_SELF);

// increases creature size by one step - typically a step is 10% of original size
void SIZER_InflateCreature(object oTarget = OBJECT_SELF);


// restores a creature to normal size
void SIZER_RestoreCreatureSize(object oTarget = OBJECT_SELF);



//:: HELPER FUNCTIONS - Not for external use ///////////////////////////////////
// retrieves the name of the appearance from the appearance.2da
string SIZER_GetAppearanceModel(int nAppearance)
{
    return Get2DAString("appearance", "RACE", nAppearance);
}

// retrieves the tail number for a model from the tailmodel.2da
// returns -1 if no suitable tail is found
int SIZER_GetTailForModel(string sModel)
{
    if(sModel == "") return -1;
    int nCount = 4; //skip over the real tails
    string sCurrent = Get2DAString("tailmodel", "MODEL", nCount);
    while(nCount < SIZER_TAILMODEL_2DA_LINES
        && sCurrent != sModel)
    {
        nCount++;
        sCurrent = Get2DAString("tailmodel", "MODEL", nCount);
    }
    if(sCurrent == "") {
        return -1;
    } else {
        return nCount;
    }
}

// retrieves a good appearance type - that allows movement to work properly!
// WARNING! Loops through a 2da - can get expensive!
int SIZER_GetSizerAppearance(int nAppearance)
{
    // check for dragons
    switch(nAppearance)
    {
    case APPEARANCE_TYPE_DRAGON_BLACK:
    case APPEARANCE_TYPE_DRAGON_BLUE:
    case APPEARANCE_TYPE_DRAGON_BRASS:
    case APPEARANCE_TYPE_DRAGON_BRONZE:
    case APPEARANCE_TYPE_DRAGON_COPPER:
    case APPEARANCE_TYPE_DRAGON_GOLD:
    case APPEARANCE_TYPE_DRAGON_GREEN:
    case APPEARANCE_TYPE_DRAGON_PRIS:
    case APPEARANCE_TYPE_DRAGON_RED:
    case APPEARANCE_TYPE_DRAGON_SHADOW:
    case APPEARANCE_TYPE_DRAGON_SILVER:
    case APPEARANCE_TYPE_DRAGON_WHITE:
        return SIZER_APPEARANCE_INVIS_DRAGON;
    }

    // handle others
    string sModelType = Get2DAString("appearance", "MODELTYPE", nAppearance);
    if(sModelType == "F" || sModelType == "FW" || sModelType == "FT") {
        // humanoid
        string sSizeCat = Get2DAString("appearance", "SIZECATEGORY", nAppearance);
        int nSizeCat = StringToInt(sSizeCat);
        if(nSizeCat <= 2) return SIZER_APPEARANCE_INVIS_HALFLING_M;
        if(nSizeCat >= 4) return SIZER_APPEARANCE_INVIS_HALFORC_M;
        return SIZER_APPEARANCE_INVIS_HUMAN_M;
    } else if(sModelType == "S") {
        // creature S
        return SIZER_APPEARANCE_INVIS_CREATURE_S;
    } else if(sModelType == "L") {
        // creature L
        return SIZER_APPEARANCE_INVIS_CREATURE_L;
    } else {
        // part based models & all others - don't work, sadly
        return APPEARANCE_TYPE_INVALID;
    }
}


// fills local variables on a creature to be used for resizing
void SIZER_CalculateAppearances(object oTarget)
{
    if(!GetIsObjectValid(oTarget)) return;

    // check if the work has already been done
    int nPresetOriginal = GetLocalInt(oTarget, SIZER_ORIGINAL_APPEARANCE);
    if(nPresetOriginal) {
        if(nPresetOriginal == SIZER_APPEARANCE_NO_RESIZE) return;
        // check if the appearance has been changed outside of sizing!
        int nCurrentAppearance = GetAppearanceType(oTarget);
        int nBaseAppearance = GetLocalInt(oTarget, SIZER_BASE_APPEARANCE);
        if(nCurrentAppearance == nPresetOriginal
            || (nCurrentAppearance >= nBaseAppearance && nCurrentAppearance <= nBaseAppearance + SIZER_MAX_SIZE) )
        {
            // we're good - no change outside of sizing
            return;
        }
    }

    // preset variables
    int nTail = -1;
    int nAppearance = APPEARANCE_TYPE_INVALID;
    //int nCurrentSize = SIZER_NORMAL_SIZE;
    int nSizerAppearance = APPEARANCE_TYPE_INVALID;

    nAppearance = GetAppearanceType(oTarget);
    if(nAppearance == APPEARANCE_TYPE_INVALID) {
        // don't disallow further checks - just ignore - likely isn't a creature
        return;
    }

    if(nAppearance >= SIZER_APPEARANCE_INVIS_DRAGON
        && nAppearance <= SIZER_APPEARANCE_INVIS_CREATURE_L+SIZER_MAX_SIZE)
    {
        // size modified appearance - easy to read resize information
        nTail = GetCreatureTailType(oTarget);
        int nPredefSize = (nAppearance - SIZER_APPEARANCE_INVIS_DRAGON) % (SIZER_MAX_SIZE+1);
        nSizerAppearance = nAppearance - nPredefSize;
        //nCurrentSize = nPredefSize;

        SetLocalInt(oTarget, SIZER_ORIGINAL_APPEARANCE, nAppearance);
        SetLocalInt(oTarget, SIZER_ORIGINAL_TAIL, nTail);
        SetLocalInt(oTarget, SIZER_TAIL_TYPE, nTail);
        SetLocalInt(oTarget, SIZER_BASE_APPEARANCE, nSizerAppearance);
    }
    else
    {
        // normal appearance - lookup required
        string sModel = SIZER_GetAppearanceModel(nAppearance);
        // retrieve tail type for model
        nTail = SIZER_GetTailForModel(sModel);
        if(nTail != -1) {
            // easy stuff now - hopefully
            nSizerAppearance = SIZER_GetSizerAppearance(nAppearance);
            if(nSizerAppearance == APPEARANCE_TYPE_INVALID) {
                // no resizing possible!
                nTail = -1;
            } else {
                SetLocalInt(oTarget, SIZER_ORIGINAL_APPEARANCE, nAppearance);
                SetLocalInt(oTarget, SIZER_ORIGINAL_TAIL, GetCreatureTailType(oTarget));
                SetLocalInt(oTarget, SIZER_TAIL_TYPE, nTail);
                SetLocalInt(oTarget, SIZER_BASE_APPEARANCE, nSizerAppearance);
                //nCurrentSize = SIZER_NORMAL_SIZE;
            }
        }
        if(nTail == -1) {
            // can't resize - remember that!
            SetLocalInt(oTarget, SIZER_ORIGINAL_APPEARANCE, SIZER_APPEARANCE_NO_RESIZE);
        }
    }
}



// sets the nearest possible size - 1.0f is normal size
// only works on a limited selection of models
void SIZER_SetSizeF(float fSize, object oTarget = OBJECT_SELF)
{
    int nSize = FloatToInt(fSize*10.0f + 0.5f); //fake rounding
    SIZER_SetSize(nSize*10, oTarget);
}

// sets the nearest possible size - 100 is normal size
// only works on a limited selection of models
// This function is called by all others - changes to how things
// work should be made in here
//TODO: Including consideration for size-changed original models!
void SIZER_SetSize(int nSize, object oTarget = OBJECT_SELF)
{
    SIZER_CalculateAppearances(oTarget);
    int nInvisBase = GetLocalInt(oTarget, SIZER_BASE_APPEARANCE);
    // can't change size
    if(!nInvisBase || nInvisBase == SIZER_APPEARANCE_NO_RESIZE) return;

    int nMySize = (nSize-5)/10;
    if(nMySize < 0) nMySize = 0;
    if(nMySize > SIZER_MAX_SIZE) nMySize = SIZER_MAX_SIZE;

    /*if(nMySize == SIZER_NORMAL_SIZE) {
        SIZER_RestoreCreatureSize(oTarget);
    } else*/ {
        int nTail = GetLocalInt(oTarget, SIZER_TAIL_TYPE);

        SetCreatureAppearanceType(oTarget, nInvisBase+nMySize);
        SetCreatureTailType(nTail, oTarget);
    }
}


// shrinks a creature by one step - typically a step is 10% of original size
void SIZER_ShrinkCreature(object oTarget = OBJECT_SELF)
{
    int nAppearance = GetAppearanceType(oTarget);
    int nCurrentSize = SIZER_NORMAL_SIZE;

    if( nAppearance >= SIZER_APPEARANCE_INVIS_DRAGON
        && nAppearance <= SIZER_APPEARANCE_INVIS_CREATURE_L+SIZER_MAX_SIZE )
    {
        // size modified appearance
        int nPredefSize = (nAppearance - SIZER_APPEARANCE_INVIS_DRAGON) % (SIZER_MAX_SIZE+1);
        nCurrentSize = nPredefSize;
    }

    // call with internal current size - which is one step below real sizes
    SIZER_SetSize((nCurrentSize)*10, oTarget);
}

// increases creature size by one step - typically a step is 10% of original size
void SIZER_InflateCreature(object oTarget = OBJECT_SELF)
{
    int nAppearance = GetAppearanceType(oTarget);
    int nCurrentSize = SIZER_NORMAL_SIZE;

    if( nAppearance >= SIZER_APPEARANCE_INVIS_DRAGON
        && nAppearance <= SIZER_APPEARANCE_INVIS_CREATURE_L+SIZER_MAX_SIZE )
    {
        // size modified appearance
        int nPredefSize = (nAppearance - SIZER_APPEARANCE_INVIS_DRAGON) % (SIZER_MAX_SIZE+1);
        nCurrentSize = nPredefSize;
    }

    // call with internal current size - which is one step below real sizes
    SIZER_SetSize((nCurrentSize+2)*10, oTarget);
}


// restores a creature to normal size
void SIZER_RestoreCreatureSize(object oTarget = OBJECT_SELF)
{
    int nOriginalAppearance = GetLocalInt(oTarget, SIZER_ORIGINAL_APPEARANCE);
    // only work if there's actually been something set - and changed
    if( nOriginalAppearance
        && nOriginalAppearance != SIZER_APPEARANCE_NO_RESIZE
        && nOriginalAppearance != GetAppearanceType(oTarget) )
    {
        SetCreatureAppearanceType(oTarget, nOriginalAppearance);
        int nOriginalTail = GetLocalInt(oTarget, SIZER_ORIGINAL_TAIL);
        SetCreatureTailType(nOriginalTail, oTarget);
    }
}

Select All Text | View Code in separate window

Format

Code Only

Type

Type - Appearance

Includes

None

Description

This useful include file offers a quick way to resizing of creatures with the along the way described in the very helpful horse & creature resize guide.

By calling SIZER_SetSize(60, oCreature) the creature will be shrunk down to 60% of it's base size.

Similarily, SIZER_ShrinkCreature() and SIZER_InflateCreature() work to increase the size in 10 percent point steps - from 10% to 200%.

If you use a custom tailmodel.2da, you might want to edit the constant SIZER_TAILMODEL_2DA_LINES.

Originally done for the Narfell PW.
Enjoy!

Files

Name	Type	Size	Downloads
inc_creaturesize.erfinc_creaturesize.erf Submitted: 09-12-2009 / Last Updated: 09-12-2009	erf	12.96Kb	94
The include script as an ERF. Saves you copy & paste ;)

SCORE OUT OF 10

10
1 votes
View Stats
Cast Your Vote!

PORTFOLIO

Add this entry to your portfolio so you can track it

Manage your existing portfolios or create a new one.

SCREENS

No Images

You Must Be Logged In to Participate.

Comments (1):

Posted by Sethan at 2009-09-15 02:36:27 Voted 10.00 on 09/15/09

Great stuff - our DMs love it.
_________________________
PW Story server Narfell - Since 2002

You must be Logged In to post comments in this section.