mod_sim_game.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2007 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#if COMPILING_MODULE//_SIM
#ifndef MOD_SIM_GAME_HH
#define MOD_SIM_GAME_HH 1

#include "mod_sim_sound.hh"

namespace mod_sim {
namespace game {

#define gGame (gModule.GetGame())

class Actor;
class CraftActor;

class Game : public Shared
{


public:
    typedef int TeamNum;
    enum { TEAM_NONE, TEAM1, TEAM2 };

private:
    class TimerFunctor : public Timer::Functor
    {
    public:
        TimerFunctor( Game& game ) : mGame(game) { }
        void operator()( const Milliseconds millisecElapsed );
    private:
        Game&   mGame;
    };

private:
    class IdleFunctor : public Event<>::ListenerFunctor
    {
    public:
        IdleFunctor( Game& game ) : mGame(game) { }
        void operator()( Void nothing );
    private:
        Game&   mGame;
    };
    friend class IdleFunctor;

private:
    class MultiView : public eng::View
    {
    public:
        enum eMode { eMode_DISABLED,
                     eMode_REAR_VIEW,
                     eMode_MISSILE_VIEW };

                    MultiView( const Rect<int>& rect );
        void        Reshape( const Rect<int>& mainViewRect );
        void        SetMode( eMode mode );
        eMode       GetMode( void );
        void        Tick( void );
        CLASS_VAR Rect<int> ComputeRect( const Rect<int>& mainViewRect );

    private:
        eMode       mMode;
    };

private:
    // Listener for the post-draw event of one View.
    struct ListenerPostDrawOneView : public Event<SharedPtr<View> >::ListenerFunctor
    {
        void operator()( SharedPtr<View> view );
    };
    friend struct ListenerPostDrawOneView;

//..............................................................................

// Types:
private:    typedef uint ActorId;
public:     typedef map<ActorId,SharedPtr<Actor> >      Actors;
public:     typedef map<ActorId,SharedPtr<CraftActor> > CraftActors;
public:     enum eTargets { eTargets_ALL, eTargets_MISSILE_LOCK };

// Methods:
public:                         Game( void );
public:     void                Init( void );
public:                         ~Game();
public:     mod_sim::Sound&     GetSound( void ) { return mSound; }
public:     int                 GetScore( void );
public:     void                AddScore( int points );
public:     void                AddActor( SharedPtr<Actor> actor );
public:     void                AddCraftActor( SharedPtr<CraftActor> craftActor );
public:     void                ZombifyActor( SharedPtr<Actor> actor );
public:     SharedPtr<CraftActor>   GetPlayerActor( void ) { return mPlayerActor; }
public:     CraftActors         GetPlayerTargets( const eTargets whichTargets );
public:     void                SetPlayerHasMissileLock( const bool hasLock );
public:     bool                IfPlayerHasMissileLock( void );
public:     void                UpdateMissileView( const Matrix& m );
public:     void                ReleaseMissileView( void );
public:     void                SpawnEnemyCraft( const uint num );
private:    void                Tick( const Milliseconds millisecElapsed );
private:    void                Idle( void );

// Data:
private:    CLASS_CONST uint    MAX_TARGETS = 500;
private:    CLASS_VAR set<ActorId> msZombieActors;      
private:    shptr<TimerFunctor> mTimerFunctor;          
private:    shptr<IdleFunctor>  mIdleFunctor;           
private:    shptr<MultiView>    mMultiView;             
public:     GFX::Light          mLightMissile;          
private:    mod_sim::Sound      mSound;                 
private:    shptr<CraftActor>   mPlayerActor;           
private:    Actors              mActors;                
private:    CraftActors         mCraftActors;           
private:    int                 mScore;
private:    bool                mPlayerHasMissileLock;  
private:    uint                mEnemyCraftSpawned;
};

class Actor : public Shared
{

friend class Game;
public:
                        Actor( const string& name = "", Game::TeamNum teamNum = Game::TEAM_NONE, SharedPtr0<Object> = NULL );
    virtual             ~Actor();
    virtual void        Action( const Milliseconds millisecElapsed ) { }
    SharedPtr0<Object>      GetObject( void ) { return mObject; }
    const string        GetName( void ) const { return mName; }
    virtual WorldVertex GetPosition( void ) const { return WorldVertex(0.0,0.0,0.0); }
    bool                IfFriendly( SharedPtr<Actor> other ) const { return mTeamNum == other->mTeamNum; }
    bool                IfDummy( void ) const { return mTeamNum == Game::TEAM_NONE; }  // dummy actor
    virtual bool        IfUnderMissileLock( void ) { return false; }
    virtual void        SetFollowedByMissile( bool followed ) { }  // NOP
    virtual bool        IfFollowedByMissile( void ) { return false; }  // NOP

private:
    typedef uint Id;  // for key of STL map
    Id              GetId( void ) { return mId; }

private:
    CLASS_VAR Id            msId;
    const string            mName;
    const Game::TeamNum     mTeamNum;
    SharedPtr0<Object>          mObject;
    const Id                mId;
public:
    
};

class CraftActor : public Actor
{

public:
                            CraftActor( const string& name, Game::TeamNum teamNum, SharedPtr0<Craft> craft );
    virtual                 ~CraftActor();
    virtual WorldVertex     GetPosition( void ) const { return GetCraft()->GetPosition(); }
    virtual SharedPtr<Craft>    GetCraft( void ) const { return mCraft.PTR(); }
    void                    SetUnderMissileLock( const bool lock ) { mUnderMissileLock = lock; }
    virtual bool            IfUnderMissileLock( void ) { return mUnderMissileLock; }
    virtual void            SetFollowedByMissile( bool followed ) { mFollowedByMissile = followed; }
    virtual bool            IfFollowedByMissile( void ) { return mFollowedByMissile; }

private:
    SharedPtr0<Craft>   mCraft;
    bool            mUnderMissileLock;      
    bool            mFollowedByMissile;     
};

class PlayerCraftActor : public CraftActor
{

public:
                            PlayerCraftActor( const string& name, Game::TeamNum teamNum );
    virtual                 ~PlayerCraftActor();
    virtual SharedPtr<Craft>    GetCraft( void ) const;
};

} // namespace game
} // namespace mod_sim

#endif // MOD_SIM_GAME_HH
#endif // COMPILING_MODULE//_SIM

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:12 2007