laTypedObject.cpp

/*

Jump'n'Run Engine
http://www.atanaslaskov.com/jnr/

BSD LICENSE
Copyright (c) 2007-2013, Atanas Laskov
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL ATANAS LASKOV BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "stdafx.h"
#include "laParser.h"
#include "Core.h"
#include "Core.h"
#include "Core-Level-JR.h"
#include "RPG\RPG.h"

class laAnimatedModel_Element: public laLoadableObj
{
public:
    laAnimatedModel* pModel;
    M_BOOL bSolid;

    laAnimatedModel_Element(laAnimatedModel *ptr){
        pModel = ptr;
    }

    virtual void load(class laFileParser *fp)
    {
        char strModelFile[128], label[128];
        laPoint3 pos, scale;
        M_BOOL bSnap, bInvertAnimation;

        fp->readText(strModelFile, M_FALSE);
        pModel->load(strModelFile);

        fp->readObj(&pos, M_FALSE);
        fp->readObj(&scale, M_FALSE);
        fp->readBool(&bSnap, M_FALSE);
        fp->readBool(&bSolid /*_arSolidFlag + _nModelCnt*/, M_FALSE);
        fp->readBool(&bInvertAnimation, M_FALSE);

        pos*=M_UNIT;

        pModel->edScale(scale);
        pModel->edTranslate(pos);
        if(bSnap) pModel->edSnap();
        if(bInvertAnimation) pModel->edInvertAnimation();
    }
};

/*laTypedObject::~laTypedObject()
{
}*/

// Free memory
void laTypedObject::discard()
{
    ASSERT(_pdata, "Object is nil");

    switch(_nType)
    {
    case M_TYPE_TEXT:
        delete [] _pdata;
        return;

    default:
        delete _pdata;
    }

    _pdata = NULL;
}

void laTypedObject::_type(char* strType)
{
    _nType = M_TYPE_INVALID;

    if( !strcmp(strType, "comment") ) _nType = M_TYPE_COMMENT;
    else if( !strcmp(strType, "bool") ) _nType = M_TYPE_BOOL;
    else if( !strcmp(strType, "int") ) _nType = M_TYPE_INT;
    else if( !strcmp(strType, "double") ) _nType = M_TYPE_DOUBLE;
    else if( !strcmp(strType, "point3") ) _nType = M_TYPE_POINT3;
    else if( !strcmp(strType, "color") ) _nType = M_TYPE_COLOR;
    //else if( !strcmp(strType, "trap") ) _nType = M_TYPE_TRAP;
    else if( !strcmp(strType, "text") ) _nType = M_TYPE_TEXT;
    else if( !strcmp(strType, "model") ) _nType = M_TYPE_MODEL;
    else if( !strcmp(strType, "fx") ) _nType = M_TYPE_FX;
    else if( !strcmp(strType, "attack") ) _nType = M_TYPE_ATTACK;
    else if( !strcmp(strType, "include") ) _nType = M_TYPE_INCLUDE;
    else
    {
        _nType = M_TYPE_PLIST;
    }

    ASSERT(_nType != M_TYPE_INVALID, "Unknown type", strType);
}

void laTypedObject::load(class laFileParser *fp)
{
    //Read type if not already specified
    if(_nType==M_TYPE_INVALID)
    {
        fp->readSectionSeparator(_strType);
        _type(_strType);
    }

    //Read data of the requested type
    switch(_nType)
    {
    case M_TYPE_COMMENT:
        {
            char comment[256];
            fp->readText(comment, M_FALSE);
        }
        return;
    case M_TYPE_BOOL:
        _pdata = new M_BOOL;
        fp->readBool( (M_BOOL*)_pdata, M_FALSE);
        return;
    case M_TYPE_INT:
        _pdata = new int;
        fp->readInt( (int*)_pdata, M_FALSE);
        return;
    case M_TYPE_DOUBLE:
        _pdata = new double;
        fp->readDouble( (double*)_pdata, M_FALSE);
        return;
    case M_TYPE_POINT3:
        _pdata = new laPoint3;
        fp->readObj( (laPoint3*)_pdata, M_FALSE);
        *((laPoint3*)_pdata) *= M_UNIT;
        return;
    case M_TYPE_COLOR:
        _pdata = new laColor;
        fp->readObj( (laColor*)_pdata, M_FALSE);
        return;
    /*case M_TYPE_TRAP:
        _pdata = new rpgTrap;
        fp->readObj( (rpgTrap*)_pdata, M_FALSE);
        return;*/
    case M_TYPE_INCLUDE:
    case M_TYPE_TEXT:
        _pdata = new char[128];
        fp->readText( (char*)_pdata, M_FALSE);
        return;
    case M_TYPE_MODEL:
        {
            laAnimatedModel_Element me( new laAnimatedModel() );
            fp->readObj( &me, M_FALSE);
            me.pModel->bIsSolid = me.bSolid;

            _pdata = me.pModel;
        }
        return;
    case M_TYPE_FX:
            _pdata = new fxParticleSystem();
            fp->readObj( (laLoadableObj*)_pdata, M_FALSE);
        return;
    case M_TYPE_ATTACK:
            _pdata = new rpgAttack();
            fp->readObj( (laLoadableObj*)_pdata, M_FALSE);
        return;

    case M_TYPE_PLIST:
            _pdata = new laPropertyList();
            ((laPropertyList*)_pdata)->_bReadName = M_FALSE;    // tweak
            strcpy( ((laPropertyList*)_pdata)->_strName, _strType);
            fp->readObj( (laLoadableObj*)_pdata, M_FALSE);
        return;
    }

    ASSERT(0, "Invalid Type", _nType);  //shouldn't reach this, but still;
}

M_BOOL* laTypedObject::getBool()  {
    ASSERT(type()==M_TYPE_BOOL, "Incompatible Type");
    return ((M_BOOL*)_pdata);
}

int* laTypedObject::getInt()        {
    ASSERT(type()==M_TYPE_INT, "Incompatible Type");
    return ((int*)_pdata);
}
double* laTypedObject::getDouble()  {
    ASSERT(type()==M_TYPE_DOUBLE, "Incompatible Type");
    return ((double*)_pdata);
}

laPoint3* laTypedObject::getPoint() {
    ASSERT(type()==M_TYPE_POINT3, "Incompatible Type");
    return ((laPoint3*)_pdata);
}

laColor* laTypedObject::getColor()  {
    ASSERT(type()==M_TYPE_COLOR, "Incompatible Type");
    return ((laColor*)_pdata);
}

/*rpgTrap* laTypedObject::trap()    {
    ASSERT(type()==M_TYPE_TRAP, "Incompatible Type");
    return ((rpgTrap*)_pdata);
}*/

char* laTypedObject::getText() {
    ASSERT( (type()==M_TYPE_TEXT) || (type()==M_TYPE_INCLUDE), "Incompatible Type");
    return (char*)(_pdata);
}

class laAnimatedModel* laTypedObject::getModel() {
    ASSERT(type()==M_TYPE_MODEL, "Incompatible Type");
    return (class laAnimatedModel*) (_pdata);
}

class fxParticleSystem* laTypedObject::getFx()           {
    ASSERT(type()==M_TYPE_FX, "Incompatible Type");
    return (class fxParticleSystem*) (_pdata);
}

class rpgAttack* laTypedObject::attack()         {
    ASSERT(type()==M_TYPE_ATTACK, "Incompatible Type");
    return (class rpgAttack*) (_pdata);
}

class laPropertyList* laTypedObject::getPList()
{
    ASSERT(type()==M_TYPE_PLIST, "Incompatible Type");
    return (class laPropertyList*) (_pdata);
}