laLevel__init.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.

*/

//
// FILE: laLevel.cpp
//
// This class represents the entire level; Each level is
// composed of several sequential segments, arragned along the X
// axis; Segments are organized as a list of laSecment objects
//
// The level object manages this list, as well as dynamic object
// and the tileset object (laTitleset)
//
// Copyright (C) 2007-2013 Atanas Laskov, <latanas@gmail.com>
//
#include "stdafx.h"
#include "Core-Level-JR.h"
#include "laStagesJR.h"

double laLevel::_dZoom = 1;

laLevel::laLevel(void)
{
    // Object types this abstract factory can create
    //
    REGISTER_CLASS( laObject );
    REGISTER_CLASS( laMonster );
    REGISTER_CLASS( laPlayer );
    REGISTER_CLASS( laStateObject );
    REGISTER_CLASS( laCollectable );
    REGISTER_CLASS( laFinal );
    REGISTER_CLASS( laShooter );
    REGISTER_CLASS( laGateway );
    REGISTER_CLASS( laActiveObject );
    //REGISTER_CLASS( laPotion );

    strcpy(_strFileName, "");

    _pTileSet = NULL;
    _nObjCnt  = _nSegCnt = 0;
    _bValid   = _bCompleted = M_FALSE;

    _dZoom = 1;
    //_dSkyX = 0;

    _bIntroPresent = M_FALSE;
    strcpy(_strNextLevel, "none");
    strcpy(_strFileName, "untitled");
}

laLevel::~laLevel(void) {
    discard();
    MLOG("Level object destroyed");
}

// Discard level, free memory
//
void laLevel::discard()
{
    ERRORLEVEL_BEGIN;
    ASSERT(_bValid, "Not a valid level, cannot be discarded");
    _bValid = M_FALSE;

    //Discard objects
    MLOG("Discarding objects...");
    for(int i=_nObjCnt-1; i>=0; i--)
    {
        delete _arObjects[i];
        _arObjects[i] = NULL;
        //MLOG("Object %d discarded.", i);
    }

    // Discard segment chain
    //
    MLOG("Discarding segment chain...");
    laSegment *p = _cbFirstSeg.next(), *pp;

    while( p ) {
        pp = p->next();
        delete p;
        p = pp;
    }

    _nSegCnt = 1;
    _cbFirstSeg._pNext = NULL;

    laPivot::colliderRange(NULL, 0);

    // Other stuff
    //
    MLOG("Discarding tileset...");
    delete _pTileSet;
    _pTileSet = NULL;

    MLOG("Discarding terrain curviture data...");
    delete [] _arCurviture_ZOffsets;

    MLOG("Discarding noise texture...");
    delete _pNoiseTex;
    _pNoiseTex = NULL;

    MLOG("Level object discarded");
    ERRORLEVEL_END;
}

// Reset all dynamic objects
//
void laLevel::reset()
{
    ERRORLEVEL_BEGIN;

    // Reset objects
    //
    for(unsigned i=0; i<_nObjCnt; i++) {
        _arObjects[i]->respawn();
    }

    // Re-distribute objects to segments again
    // NOTE: If we don't, objects wont migrate to their respawn locations,
    // until the player happens to visit their last segment of residence.
    //
    laSegment *p = &_cbFirstSeg;

    do{
        p->_init_object_list(_arObjects, _nObjCnt);
    }while( p = p->next() );

    MLOG("Level reset");
    ERRORLEVEL_END;
}

// Create empty
//
void laLevel::create(unsigned nSegCnt, laTileset *pTS)
{
    ERRORLEVEL_BEGIN;
    ASSERT(pTS, "Nil tileset.");

    _pTileSet   = pTS;
    _bValid     = M_TRUE;

    _nSegCnt = nSegCnt;

    // Create segments chain
    //
    laSegment *p = &_cbFirstSeg;

    for(unsigned i=0; i<_nSegCnt - 1; i++)
    {
        p->setTS(_pTileSet);
        p->setLevel(this);
        p->setBackgroundElement(0);

        p->next( new laSegment(i+1) );
        p = p->next();
    }

    p->setTS(_pTileSet);
    p->setLevel(this);
    p->setBackgroundElement(0);

    // Objects
    _nObjCnt = 0;

    ERRORLEVEL_END;
}

// Load level file
//
void laLevel::load(char* strFile, M_BOOL bReload)
{
    ERRORLEVEL_BEGIN;
    ASSERT(!_bValid, "Level is valid, must discard() it first.");
    //ASSERT(bReload, "Not Implemented");
    progressReset("Loading level '%s'...", strFile);
    strcpy(_strFileName, strFile);

    laFileParser fp, fxp;
    char strFilePath[128]=M_DIR_LEVEL, junk[128], strTilesetFile[128], strIntroFile[64];
    unsigned len;

    // Open level file
    //
    strcat(strFilePath, strFile);
    fp.fileOpen(strFilePath);

    _bValid = M_TRUE;
    srand( ::GetTickCount() );

    // Section "General"
    //
    progressIncrease(0.05, "Loading general section...");

    try{ fp.readSectionSeparator(junk); }
    catch(laError& ){ throw laError("Section separator expected but not found (while parsing '%s')", strFile); }

    _strupr(junk);
    ASSERT(!strcmp(junk, "GENERAL"), "Section [GENERAL] expected, [%s] found ('%s')", junk, strFile);

    fp.readText(_strName);
    fp.readText(strTilesetFile);
    fp.readUnsigned(&len);

    // Intro
    //
    fp.readText(strIntroFile);
    fp.readText(_strNextLevel);

    _bIntroOver = M_FALSE;
    if( strcmp(strIntroFile, "none") )
    {
        laFileParser fp(strIntroFile);

        fp.readObj( (stageIntro*)(laSystemIntegrator::getGame()->getStage(M_STAGE_INTRO)), M_FALSE);

        _bIntroPresent = M_TRUE;
    }
    else _bIntroPresent = M_FALSE;

    // Load the tileset
    //
    progressIncrease(0.65);

    _pTileSet = new laTileset();

    progressSubtask(_pTileSet, 0.6);
    _pTileSet->load(strTilesetFile);
    progressSubtask(NULL,0);

    // Load segments and objects
    //
    _load_segments(fp, len);
    _load_objects(fp);

    // Noise tex
    //
    _pNoiseTex = new laTexture();
    _pNoiseTex->load( _pTileSet->getBackgroundElement()->getText("terrain-noise-texture") );

    // Distribute objects to segemnts
    //
    progressIncrease(0.1, "Distributing objects to segments...");

    laSegment *p = &_cbFirstSeg;

    do{
        p->_init_object_list(_arObjects, _nObjCnt);
    }while( p=p->_pNext );

    progressIncrease(0.1, "Precomputing terrain curviture...");
    _curviture_precompute();

    progressIncrease(0.1, "Level loaded.");
    ERRORLEVEL_END;
}

// Load list of segments from the level file
//
void laLevel::_load_segments(laFileParser &fp, unsigned len)
{
    char junk[128];
    laSegment *p = &_cbFirstSeg;
    unsigned seg_index =0;
    laCollisionDomain *pNext;

    progressIncrease(0, "Creating segment list of lenght %d...", len);
    create(len, _pTileSet);

    do{
        progressIncrease(0.2/len, "Loading segment %d...", seg_index);

        try{ fp.readSectionSeparator(junk); }
        catch(laError& ){
            throw laError("Segment separator (%d) expected but not found", seg_index);
        }

        //Read the object
        try{ fp.readObj(p, M_FALSE); }
        catch(laError&  pe){ throw laError("%s\n\nLevel segment (%d) appears to be corrupted", pe.getText(), seg_index); }

        //Build collision domains
        p->bulidDomains(laPoint3(seg_index*M_UNIT*M_SEGW,0,0));

        // Randomly assign segment background
        //
        unsigned nElement = _pTileSet->getSegmentBackground(rand()%_pTileSet->getSegmentBackgroundCount());
        p->setBackgroundElement(nElement);

        seg_index++;

    }while( p=p->_pNext );

    // Remove empty collision domains
    _cbFirstSeg.firstDomain()->optimize();

    // Set inital range; Objects may need this on init ( e[1]. static objects to project shadow )
    laPivot::colliderRange(_cbFirstSeg.firstNonemptyDomain(), _cbFirstSeg.countDomains(len));

}

// Load dynamic objects from the level file
//
void laLevel::_load_objects(laFileParser &fp)
{
    char junk[128], strElementName[32], *strInstanceType;
    unsigned nElementIndex;
    laObject *pplr;

    //Start loading the objects
    //
    progressIncrease(0, "Loading dynamic objects...");
    _nObjCnt = 0;

    while(1)
    {
        try{ fp.readSectionSeparator(junk); }
        catch(laError& ){ throw laError("Section separator expected but not found"); }

        _strupr(junk);
        if(!strcmp(junk, "END")) break;

        ASSERT(_nObjCnt < M_MAXOBJCNT, "Object count exceeds M_MAXOBJCNT");
        ASSERT(!strcmp(junk, "OBJECT"), "[OBJECT] expected, [%s] found", junk);

        // Extract the string ID of the class to be used for the dynamic object
        //
        try{ fp.readText(strElementName); }
        catch(laError& ){ throw laError("Corrupted object (%d) encountered", _nObjCnt); }

        nElementIndex = _pTileSet->getElementIndex(strElementName);

        ASSERT(_pTileSet->getElementCnt() > nElementIndex,
            "Tileset element '%s' was requested by object (%d) but not found", strElementName, _nObjCnt);

        if( /*(bReload) &&*/ (_nObjCnt==0) )
        {
            pplr = _arObjects[_nObjCnt];
        }

        // Insantiate a dynamic object of the specified class
        //
        strInstanceType = _pTileSet->getElement(nElementIndex)->getInstanceType();
        _arObjects[_nObjCnt] = (laObject*)instantiate(strInstanceType);

        // Custom loading from the .lvl file, for the instantiated object
        //
        _arObjects[_nObjCnt]->setObject(nElementIndex, (laElement*)_pTileSet->getElement(nElementIndex));
        _arObjects[_nObjCnt]->setTS(_pTileSet);
        _arObjects[_nObjCnt]->setLevel(this);

        try{ fp.readObj(_arObjects[_nObjCnt], M_FALSE); }
        catch(laError&  pe){ throw laError("%s\n\nCorrupted object (%d) encountered", pe.getText(), _nObjCnt); }

        MLOG("Object %d loaded...", _nObjCnt);

        //if( /*(bReload) &&*/ (_nObjCnt==0) )
        //  _arObjects[_nObjCnt] = pplr;
        _nObjCnt++;
    }
}

// Save player profile
//
void laLevel::_save_profile(char* strName)
{
    char strfile[64];
    sprintf(strfile, "save\\%s.profile", strName);

    FILE *f = fopen(strfile, "w+");
    fprintf(f, "[profile]\n");

    //Point to next level if this one is completed
    if(_bCompleted) fprintf(f, "[text] load-level: '%s' \n", _strNextLevel);
    else fprintf(f, "[text] load-level: '%s' \n", _strFileName);

    //Save player data
    ((laPlayer*)getPlayer())->saveProfile(f);

    fprintf(f, "\n[/profile]");
    fclose(f);
}

// Precompute terrain curviture (offsets and angles)
//
void laLevel::_curviture_precompute()
{
    double *pmem = new double [_nSegCnt*M_SEGW * 3];

    _arCurviture_ZOffsets   = pmem;// + 0 * _nSegCnt*M_SEGW;
    _arCurviture_Angles     = pmem + 1 * _nSegCnt*M_SEGW;
    _arCurviture_Scales     = pmem + 2 * _nSegCnt*M_SEGW;

    laSegment *ps = &_cbFirstSeg;
    double arParCurrent[4], arParNext[4], arPar[4];

    ps->_update_curviture_parameters();
    ps->curvitureParams(arParCurrent);

    // For every segment
    for(unsigned i=0; i<_nSegCnt; i++)
    {
        ps = ps->next();

        if(ps) // for the last segment ps->next() == NULL and we don't blend, just keep params
        {
            ps->_update_curviture_parameters();
            ps->curvitureParams(arParNext);
        }

        // For every X
        for(unsigned xs=0; xs<M_SEGW; xs++)
        {
            // Blend the paramaters of the current and next segment
            double w = 1.0 - (double)xs/M_SEGW;
            for(unsigned p=0; p<4; p++) arPar[p] = w * arParCurrent[p] + (1-w) * arParNext[p];

            // Precompute offset and rotation
            //
            unsigned ix = i*(M_SEGW) + xs;
            double dx = ix * 0.1;

            _arCurviture_ZOffsets[ ix ] =
                    arPar[0] * sin( dx/2.0 ) * (M_UNIT) +
                    arPar[1] * sin( dx ) * sin( dx*2 ) * (M_UNIT*2) * (M_UNIT*0.5) +
                    arPar[2] * sin( dx*8 ) * (M_UNIT*0.6); // 0.4

            if( ix > 0 )
            {
                //NOTE: can't use ix+1 for the angle since it doesn't exist yet
                double dOffsetDelta = _arCurviture_ZOffsets[ix-1] - _arCurviture_ZOffsets[ix];

                _arCurviture_Angles[ ix-1 ] = atan2( dOffsetDelta, M_UNIT );
                _arCurviture_Scales[ ix-1 ] = sqrt( M_UNIT*M_UNIT + dOffsetDelta*dOffsetDelta)/M_UNIT;
            }
        }

        memcpy(arParCurrent, arParNext, sizeof(double)*4);
    }

    // Last angle & scalse defaults
    _arCurviture_Angles[ (_nSegCnt)*M_SEGW -1 ] = _arCurviture_Angles[ (_nSegCnt)*M_SEGW -2 ];
    _arCurviture_Scales[ (_nSegCnt)*M_SEGW -1 ] = _arCurviture_Scales[ (_nSegCnt)*M_SEGW -2 ];
}

/*void laLevel::createCollisionDomains()
{
    unsigned seg_index =0;
    laSegment *p = &_cbFirstSeg;
    laCollisionDomain *pNext;

    do{
        //Build collision domains
        p[2]ulidDomains(laPoint3(seg_index*M_UNIT*M_SEGW,0,0));

        //Link the collision domain of this segment to the next
        if(p->_pNext)
        {
            pNext = p->_pNext[3]tIndex(0,0)getDomain();
        }
        else pNext = NULL;

        p[3]tIndex(M_SEGW-1, M_SEGH-1)getDomain()->setNextDomain(pNext);

        unsigned nElement = _pTileSet->getSegmentBackground(rand()%_pTileSet->getSegmentBackgroundCount());
        p->setBackgroundElement(nElement);

        seg_index++;

    }while( p=p->_pNext );
}*/

/*void laLevel::addObject(laObject *po)
{
    ASSERT( (_nObjCnt+1) >=M_MAXOBJCNT, "laLevel::addObject: Object count exceeds M_MAXOBJCNT" );

    _arObjects[_nObjCnt++] = po;
    po->setTS(_pTileSet);
    po->setLevel(this);
}*/