mob.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2007
        www.grinninglizard.com/lilith

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

        The full text of the license can be found in license.txt
*/

#ifndef LILITH_MOB_INCLUDED
#define LILITH_MOB_INCLUDED

#ifdef _MSC_VER
#pragma warning( disable : 4786 )       // Debugger truncating names.
#pragma warning( disable : 4530 )       // Exception handler isn't used
#endif

#include <set>
#include <vector>

#include "../grinliz/gldebug.h"
#include "../grinliz/glrandom.h"
#include "../grinliz/glvector.h"
#include "genericobject.h"

namespace lilith3d
{

class TimeClock;
class TerrainMesh;
class AnimatedMesh;
class Lilith3D;
class DecalMesh;
class MeshResource;
class AnimatedResource;
class LilithObject;
class MD2Resource;
class MD2Mesh;
class BuildingMesh;


class Mob
{
  public:
        Mob();
        virtual ~Mob();

        virtual void Update( TimeClock* tc ) = 0;

        bool Alive()    { return alive; }       
        void Kill();                                            

        virtual void KillAnimation() = 0;

  protected:

  private:
        bool alive;
};

const float MOB_STAND = -360.0f;

class WalkingMob : public Mob
{
  public:

        WalkingMob( const MD2Resource* res, float x, float y );
        virtual ~WalkingMob();

        // internal
        virtual void Update( TimeClock* tc );

        void PathTo( float x, float y, float z=0.0f );

        void PathTo( const LilithObject& object );

        bool IsPathing()        { return path != 0; }

        void Move( float rotationBias );

        void Rotate( int dir );
        int Rotating() {
                if ( !path ) return rotate;
                return 0;
        }

        void SetPos( const grinliz::Vector3F& location, float rotation );

        void SetPos( float x, float y, float rotation )
        {
                grinliz::Vector3F at = { x, y, 0.0f };
                SetPos( at, rotation );
        }
        
        const grinliz::Vector3F& Pos(); 
        const float    ZRot();                  

        bool Attack();
        bool Emote( int id );
        bool Stun();
        bool Stand();

        int GetAction();

        void SetPathIllumination( bool _illuminate )    { this->illuminate = _illuminate; }

        virtual void KillAnimation();

        const MD2Mesh* GetMD2Mesh() const                               { return mobileMesh; }
        //const AnimatedMesh* GetAnimatedMesh() const           { return mobileMesh; }

        const MD2Resource* GetMD2Resource() const;
        void UpdateZFromPSI( PathSurfaceInstance* psi );

  private:
        // States:
        // Pathing, then 'path' is a valid pointer
        // else:
        //              Moving, then the current action is checked, and rotationBias applied of running
    //          Rotation, the value of 'rotate' 

        float CalcRotation( float subDestX, float subDestY, float x, float y );
        void FindSpace();

        MD2Mesh                                                         *mobileMesh;
        std::vector< grinliz::Vector2F >        *path;                  // allocated to follow a path
        int                                                                     pathIndex;              // Where the mob is in the path vector.
        float                                                           rotationBias;   // for RELATIVE, motion relative to face (set up strafing)
        int                                                                     rotate;                 // +/- 1 or 0 for RELATIVE
        bool                                                            illuminate;             // light up the path for debugging or showing off
        bool                                                            repath;                 // repath if the path changes

        PathSurfaceInstance*                            standingOnPSI;
        PSIMobRing                                                      psiMobRing;

        static grinliz::Random random;
};

/*
class MobGroup
{
  public:
        MobGroup()                                      {       magic1= 0x01234567; magic2 = 0x89abcdef; }
        ~MobGroup()                                     {}

        void Add( Mob* mob )            {       GLASSERT( allMobs.find( mob ) == allMobs.end() ); 
                                                                        allMobs.insert( mob ); 
                                                                }
        void Remove( Mob* mob )         {       GLASSERT( allMobs.find( mob ) != allMobs.end() );
                                                                        allMobs.erase( mob ); 
                                                                        GLASSERT( allMobs.find( mob ) == allMobs.end() );
                                                                }

        void UpdateAll( TimeClock* tc )
        {
                std::set< Mob* >::iterator it = allMobs.begin();
                while ( it != allMobs.end() )
                {
                        (*it)->Update( tc );
                        ++it;
                }
        }

  private:
        U32 magic1;
        std::set< Mob* > allMobs;
        U32 magic2;
};
*/

class MobGroup
{
  public:
        MobGroup()                                      {       magic1= 0x01234567; magic2 = 0x89abcdef; }
        ~MobGroup()                                     {}

        void Add( Mob* mob )            {       GLASSERT( Find( mob ) == allMobs.size() ); 
                                                                        allMobs.push_back( mob ); 
                                                                }
        void Remove( Mob* mob )         {       unsigned i = Find( mob );
                                                                        GLASSERT( i != allMobs.size() );
                                                                        allMobs.erase( allMobs.begin()+i ); 
                                                                        GLASSERT( Find( mob ) == allMobs.size() );
                                                                }

        void UpdateAll( TimeClock* tc )
        {
                std::vector< Mob* >::iterator it = allMobs.begin();
                while ( it != allMobs.end() )
                {
                        (*it)->Update( tc );
                        ++it;
                }
        }

        unsigned Find( Mob* mob ) 
        {
                for( unsigned i=0; i<allMobs.size(); ++i ) {
                        if ( allMobs[i] == mob ) 
                                return i;
                }
                return allMobs.size();
        }

  private:
        U32 magic1;
        std::vector< Mob* > allMobs;
        U32 magic2;
};

};

#endif

---