laSegment.h

/*

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.

*/
#ifndef M_SEGMENT_H
#define M_SEGMENT_H




class laSegment: public laLoadableObj
{
protected:

    unsigned _nSegmentIndex;

    friend class laLevel;   // the level builds a list of segments at initalization time
    laSegment* _pPrev;
    laSegment* _pNext;

    laTileset* _pTileset;   // and sets the tileset
    class laLevel* _pLevel;

    // Background
    //
    unsigned      _nBackgroundElement;

    laLitterBox _arLitterBox[M_MAXLITTER_BOX];
    unsigned _nLitterBoxCount;

    // Grid of tiles
    //
    laTile _arTiles[M_SEGW][M_SEGH];
    unsigned _nCompilationID;

    unsigned _nCollisionDomains;            // n. of domains
    unsigned _nCollisionDomainSize;         // n. of lines in all domains

    // List of objects currently within the bounds of the segment
    // NOTE: This is std::list and not vector in order to speed up adding/removing obj dynamically (should be rare anyway);
    // There is no need for direct indexing, only iteration, so having an array would not result in speed up.
    //
    // See laSegment::animate() for the routine that handles obj migration.
    //
    std::list<class laObject*> _listObjects;
    M_BOOL _bObjectListReset;

    inline void _migrate_object( class laObject* pobj ) {
        _listObjects.insert( _listObjects.begin(), pobj );
        pobj->setSegment( this );
    }

    void _init_object_list (  class laObject** par, unsigned n );   // called by friend laLevel::load()

    // Animated wave / used for various effects (e[1]. lava traps)
    //
    double _arWave[M_SEGW+1];

    // Curviture parameters at the start of this segment
    // NOTE: laLevel blends those with the neighbouring semgnets, and builds terrain curviture on their basis
    //
    //
    double _arTerrainCurvitureParams[4];

    void _update_curviture_parameters();
    void _update_wave();
    void _draw_static(laRenderer *r);
    void _draw_dynamic(laRenderer *r);

public:

    inline laSegment* previous() const { return _pPrev; }
    inline laSegment* next() const { return _pNext; }

    inline void next( laSegment *pnext )
    {
        ASSERT(pnext, "Can't set NULL for next domain");
        _pNext = pnext;
        _pNext->_pPrev = this;

        lastDomain()->setNextDomain( next()->firstDomain() );
    }

    // Constructor/destructor
    //
    laSegment(unsigned nIndex=0);
    virtual ~laSegment(void);

    // Drawing the segment
    //
    void drawTerrain(laRenderer *r);
    void drawObjects(laRenderer *r);
    void drawFx(laRenderer *r, const laPoint3 &pos);

    // Animating the segment
    //
    void animate(laTimer &t);

    // This method is part of the laLoadableObj interface,
    // loads the level segment
    virtual void load(laFileParser* fp);

    // Data get/set methods
    //
    void setTS(laTileset* pTileset) { _pTileset = pTileset; };
    void setLevel(class laLevel* pLvl) { _pLevel = pLvl; };

    void setBackgroundElement(unsigned i) {_nBackgroundElement = i;};

    laTileset*  getTS() { return _pTileset; }
    unsigned        getBackgroundElement() { return _nBackgroundElement; }

    inline laTile* get(int ix, int iy) {
        ASSERT( (ix>=0) && (ix<M_SEGW), "ix out of bounds");
        ASSERT( (iy>=0) && (iy<M_SEGH), "iy out of bounds");

        // NOTE: Out of bound values here really don't make sense so
        // forcing them into the bounds would only mask a bug
        //
        //ix = M_CLAMP(0, M_SEGW-1, ix);
        //iy = M_CLAMP(0, M_SEGH-1, iy);

        return _arTiles[ix]+iy;
    }

    inline laTile* get( const laPoint3 &pos ) {
        return get(pos.x()/M_UNIT, pos.y()/M_UNIT);
    }

    // Initalize the collision domains
    //
    void bulidDomains(laPoint3 pos);
    inline unsigned collisionDomains() { return _nCollisionDomains; }

    unsigned countDomains(unsigned range)
    {
        ASSERT(range, "Nil range");
        unsigned n = 0;
        laSegment* ps = this;

        do{
            n += ps->collisionDomains();
            ps = ps->next();
        }
        while( ps && (--range) );

        return n;
    }

    inline laCollisionDomain* firstDomain() {
        return get(0,0)->getDomain();
    }

    inline laCollisionDomain* lastDomain() {
        return get(M_SEGW-1, M_SEGH-1)->getDomain();
    }

    inline laCollisionDomain* firstNonemptyDomain() {
        laCollisionDomain *pd = get(0,0)->getDomain();

        while( !(pd->countLines()) )
        {
            if( !(pd->nextDomain()) ) return pd;
            pd = pd->nextDomain();
            //ASSERT(pd, "End of domain chain reached");
        }
        return pd;
    }

    // Wave (used for e[1]. trap lava surface)
    //
    inline double getWave(int nX) {
        //ASSERT( (nX>=0) && (nX<M_SEGW) , "nX out of bounds");
        //nX = M_CLAMP(0, M_SEGW, nX);

        if( nX<0 )
            return _pPrev ? _pPrev->getWave(M_SEGW-1) : getWave(0);
        else if( nX>=M_SEGW )
            return _pNext ? _pNext->getWave(0) : getWave(M_SEGW-1);

        return _arWave[nX];
    }

    // Terrain curviture
    //
    double terrainZOffset(int nX);
    double terrainAngle(int nX);
    double terrainScale(int nX);

    inline void curvitureParams(double* ar4) {
        memcpy(ar4, _arTerrainCurvitureParams, sizeof(double)*4);
    };

};
#endif //#ifndef M_SEGMENT_H