Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Data Fields | Globals | Related Pages

CSGame.h

Go to the documentation of this file.
00001 #ifndef CSGAME_H
00002 #define CSGAME_H
00003 
00004 // USES SDL_Rect 
00005 // USES SDL_Events
00006 
00007 #ifdef WIN32
00008 #pragma warning(disable : 4786 )
00009 #endif
00010 
00011 #include "CSMessageDispatchable.h"
00012 #include "CSMessageListener.h"
00013 #include "CSMessage.h"
00014 #include "CSSprite.h"
00015 #include "CSWorld.h"
00016 #include "CSFont.h"
00017 #include "CSDesktop.h"
00018 #include "CSMenuBar.h"
00019 #include "CSMenu.h"
00020 #include "CSMenuItem.h"
00021 #include "CSXMLHelper.h"
00022 #include "CSLog.h"
00023 #include <map>
00024 
00025 const int INIT_COUNT = 100;
00026 
00027 const int CHECK_PIXEL = 0;
00028 const int CHECK_HIT = 1;
00029 const int CHECK_JUST_HIT = 2;
00030 
00031 class CSGame;
00032 class CSSample;
00033 
00034 class TimedEvent;
00035 typedef std::map<int, TimedEvent *> CSEventMap;
00036 class TimedEvent
00037 {
00038     public:
00039         int id; 
00040         bool useRepeat;
00041         int repeat;
00042         unsigned int finishTime;
00043         unsigned int intervall;
00044         void *data;
00045         void (*answer)(TimedEvent *);   //!< function pointer as CallBack
00046         TimedEvent()
00047         {
00048             id = 0; 
00049             useRepeat = false;
00050             repeat = 0;
00051             finishTime = 0;
00052             intervall = 0;
00053             data = 0;
00054             answer = 0;
00055         }
00056 };
00057 
00058 //! a data class just for level loading
00059 class SpriteData
00060 {
00061     public:
00062         char *name;
00063         unsigned int x;
00064         unsigned int y;
00065         unsigned int z;
00066         unsigned int speed;
00067         int behaviour;
00068 };
00069 typedef std::vector<SpriteData *> SpriteDatas;
00070 
00071 //! a data class just for level loading
00072 class SampleData
00073 {
00074     public:
00075         char *name;
00076         char *sid;
00077 };
00078 typedef std::vector<SampleData *> SampleDatas;
00079 
00080 class CSLevelData
00081 {
00082     public:
00083         char *id;           
00084         SpriteData mainSprite;
00085         StringVector worlds;
00086         SpriteDatas sprites;
00087         SampleDatas samples;
00088         StringVector descriptions;
00089 
00090         CSLevelData()
00091         {
00092             id = 0;
00093         }
00094 
00095         ~CSLevelData()
00096         {
00097             if (id != 0)
00098             {
00099                 free (id);
00100                 id = 0;
00101             }
00102 
00103             if (mainSprite.name != 0)
00104             {
00105                 free(mainSprite.name);
00106                 mainSprite.name = 0;
00107             }
00108 
00109             for (StringVector::iterator diter = descriptions.begin(); diter != descriptions.end(); diter++)
00110             {
00111                 delete *diter;
00112             }
00113             descriptions.clear();
00114 
00115             for (StringVector::iterator witer = worlds.begin(); witer != worlds.end(); witer++)
00116             {
00117                 delete *witer;
00118             }
00119             worlds.clear();
00120 
00121             for (SpriteDatas::iterator siter = sprites.begin(); siter != sprites.end(); siter++)
00122             {
00123                 SpriteData *sprite = *siter;
00124                 if (sprite->name != 0)
00125                 {
00126                     free(sprite->name);
00127                 }
00128                 delete sprite;
00129             }
00130             sprites.clear();
00131 
00132             for (SampleDatas::iterator ssiter = samples.begin(); ssiter != samples.end(); ssiter++)
00133             {
00134                 SampleData *sample = *ssiter;
00135                 if (sample->name != 0)
00136                 {
00137                     free(sample->name);
00138                 }
00139                 if (sample->sid != 0)
00140                 {
00141                     free(sample->sid);
00142                 }
00143                 delete sample;
00144             }
00145             samples.clear();
00146         }
00147 };
00148 
00149 class OutOfBoundsData
00150 {
00151     public:
00152         int threshold;
00153         CSSprite *sprite;
00154         CSMessageListener *listener;
00155 };
00156 
00157 class TileCollisionCheckData
00158 {
00159     public:
00160         TileCollisionCheckData()
00161         {
00162             sprite = 0;
00163             layer = 0;
00164             listener = 0;
00165             type = 0;
00166             threshold = 0;
00167         }
00168         CSSprite *sprite;
00169         int layer;
00170         CSMessageListener *listener;
00171         int type;
00172         int threshold;
00173 };
00174 
00175 class SpriteCollisionCheckData
00176 {
00177     public:
00178         SpriteCollisionCheckData()
00179         {
00180             sprite = 0;
00181             other = 0;
00182             listener = 0;
00183             type = 0;
00184             threshold = 0;
00185         }
00186         CSSprite *sprite;
00187         CSSprite *other;
00188         CSMessageListener *listener;
00189         int type;
00190         int threshold;
00191 };
00192 
00193 typedef std::vector<OutOfBoundsData *> OutOfBoundsDatas;
00194 typedef std::vector<TileCollisionCheckData *> TileCollisionCheckDatas;
00195 typedef std::vector<SpriteCollisionCheckData *> SpriteCollisionCheckDatas;
00196 
00197 class CSGame: public CSMessageDispatchable, public CSMessageListener
00198 {
00199     private:
00200         char *mId;
00201         bool dummyGame;
00202         bool mIsGui;
00203         bool mLastIsGui;
00204         bool mEnableCheck;
00205         bool mDisplayScaled;
00206         unsigned int mThreshold;
00207         bool mIsWorldOutOfBounds;
00208 
00209         int mCurrentFrameRate;
00210         long mDiffTimeGUI;
00211         long mDiffTimeGame;
00212         long mDiffTimeAll;
00213 
00214         StringVector mLevels;
00215         CSEventMap *mEventMap;
00216 
00217         std::map<std::string, CSSample *> mSampleMap;
00218         TileCollisionCheckDatas mTileCollisionCheckDatas;
00219         SpriteCollisionCheckDatas mSpriteCollisionCheckDatas;
00220         OutOfBoundsDatas mOutOfBoundsDatas;
00221         
00222         void initialize();
00223         void toggleFullscreen();
00224         void toggleGui();
00225         void screenChanged();
00226         void adjustDisplay();
00227         void checkTimedEvent();
00228         void onMouseMotion(SDL_MouseMotionEvent event);
00229         void onMouseButtonDown(SDL_MouseButtonEvent event);
00230         void onMouseButtonUp(SDL_MouseButtonEvent event);
00231     
00232     protected:
00233         CSLevelData *mLevelData;
00234         bool mQuit;
00235         bool mPause;
00236         bool mLevelFinished;
00237 
00238         int mInitCount;
00239         float mCurrentTime;
00240         int mAverageFrameRate;
00241         float mGameTime;
00242         float mDiffTime;
00243         float mSecPerFrame;
00244         void handleEvents();
00245         int getLevelDataNum(CSSprite *sprite);
00246 
00247         CSDesktop *mDesktop;
00248         CSMenuBar *mMenuBar;
00249         CSMenu *mFileMenu;
00250         CSMenu *mHelpMenu;
00251         CSMenuItem *mMenuItemExit;
00252         CSMenuItem *mMenuItemAbout;
00253         CSSprites mSprites;
00254         CSSprite *mMainSprite;
00255         CSSprite *mScaleCenterSprite;
00256         CSWorld **mWorld;
00257         CSWorld *mCurrentWorld;
00258         unsigned int mCurrentLevel;
00259         unsigned int mStartLevel;
00260         unsigned int mWorldCount;
00261         CSFont *mFont;
00262         void initSpeed();
00263         void setLevelFinished(bool b) {mLevelFinished = true;}
00264         virtual void addMainSprite(CSSprite* sprite) 
00265         {
00266             mMainSprite = sprite;
00267             addSprite(sprite);
00268         }
00269         virtual void addSprite(CSSprite* sprite);
00270         virtual void removeSprite(CSSprite* sprite);
00271         virtual void startRun() {};
00272         virtual void endRun() {};
00273         virtual void displayGameData() {};
00274         virtual void checkCollisions();
00275         virtual void checkOutOfBounds();
00276         virtual void setDisplayScaled(bool b) {mDisplayScaled = b;}
00277         virtual bool isDisplayScaled() {return mDisplayScaled;}
00278         virtual void setScaleDisplayLayer(bool b, int layer);
00279         void loadLevelData(const std::string &filename, CSLevelData *data);
00280         void initLevel(std::string levelName);
00281         void freeLevel();
00282 
00283         virtual void loadGameData(const std::string &filename);
00284         
00285         void setCurrentWorld(unsigned int w);
00286         virtual SDL_Rect getDisplayArea();
00287         virtual SDL_Rect getScaledDisplayArea();
00288         virtual double getScaleFactor() {return 0.5;}
00289         void addSample(CSSample *sample, const char *sid);
00290         void removeSample(const char *sid);
00291         void clearSamples();
00292 void nextLevel();
00293 
00294         void virtual reactOnTimedEvent(TimedEvent *event){}
00295         void disableSpriteMovement();
00296         void resetSprites();
00297         void clearTimedEvents();
00298         void enableCheck(bool b) {mEnableCheck = b;}
00299 
00300         virtual void loadLevelDataSpecific(CSXMLHelper &xmlSupport){}
00301         virtual void initLevelSpecific(CSLevelData *data){}
00302         virtual void freeLevelSpecific(){}
00303         virtual void resetSpritesSpecific(){}
00304         bool isSamplePlaying(void);
00305 
00306     public:
00307         CSGame(std::string gameFileName);
00308         virtual ~CSGame();
00309 
00310         static const char *CLASS;
00311         virtual std::string getType() {return (std::string) CLASS;}
00312 
00313         virtual void intro(void);
00314         virtual void run(void);
00315         void reactOnMessageGame(CSMessage *message);
00316         virtual void reactOnMessage(CSMessage *message);
00317         CSSprites *getSprites() {return &mSprites;}
00318         CSSprite *getMainSprite() {return mMainSprite;}
00319         CSWorld *getWorld() {return mCurrentWorld;}
00320         void checkWorld();
00321 
00322         void enableOutOfBoundsCheck(CSSprite *sprite, CSMessageListener *listener, int threshold);
00323         void enableTileCollisionCheckJustHit(CSSprite *sprite, int layer, CSMessageListener *listener);
00324         void enableTileCollisionCheck(CSSprite *sprite, int layer, CSMessageListener *listener);
00325         void enableTileCollisionCheckPixel(CSSprite *sprite, int layer, CSMessageListener *listener, int pixelThreshold = 1);
00326         void enableSpriteCollisionCheck(CSSprite *sprite, CSSprite *other, CSMessageListener *listener);
00327         void enableSpriteCollisionCheckPixel(CSSprite *sprite, CSSprite *other, CSMessageListener *listener, int pixelThreshold = 1);
00328 
00329         void disableOutOfBoundsCheck(CSSprite *sprite, CSMessageListener *listener);
00330         void disableTileCollisionCheck(CSSprite *sprite, int layer, CSMessageListener *listener);
00331         void disableSpriteCollisionCheck(CSSprite *sprite, CSSprite *other, CSMessageListener *listener);
00332         void setThreshold(unsigned int threshold) {mThreshold = threshold;}
00333         void setStartLevel(unsigned int l) {mStartLevel = l;}
00334         void playSample(const char *sid);
00335         void doPause(void);
00336         void addTimedEvent(unsigned int timeSpace, int id, void *data, int repeat = 1, bool repeatUse = false);
00337         void addTimedEvent(unsigned int timeSpace, int id, void *data, void (*answer)(TimedEvent *), int repeat = 1, bool repeatUse = false);
00338         void removeTimedEvent(int id);
00339         void removeTimedEvent(int id, void *data);
00340         void enableDesktop(bool b);
00341 
00342         void print(int x, int y, char *text)
00343         {
00344             if (mFont == 0)
00345             {
00346                 printf(text);
00347             }
00348             else
00349             {
00350                 mFont->putString(x, y, text);
00351             }
00352         }
00353         void print(int x, int y, int number)
00354         {
00355             char t[40];
00356             sprintf(t, "%i", number);
00357             print(x, y, t);
00358         }
00359 
00360         GameMessage MESSAGE_TOGGLE_FULLSCREEN;
00361         GameMessage MESSAGE_END;
00362         GameMessage MESSAGE_PAUSE;
00363         GameMessage MESSAGE_SPRITE_TILE_COLLISION;
00364         GameMessage MESSAGE_SPRITE_SPRITE_COLLISION;
00365         GameMessage MESSAGE_SPRITE_OUT_OF_BOUNDS;
00366         GameMessage MESSAGE_TOGGLE_GUI;
00367 
00368         ActionMessage MESSAGE_DEATH;
00369         ActionMessage MESSAGE_UP;
00370         ActionMessage MESSAGE_DOWN;
00371         ActionMessage MESSAGE_LEFT;
00372         ActionMessage MESSAGE_RIGHT;
00373         ActionMessage MESSAGE_FIRE;
00374         ActionMessage MESSAGE_DEFAULT;
00375         
00376         InputMessage MESSAGE_KEY_UP;
00377         InputMessage MESSAGE_KEY_DOWN;
00378         InputMessage MESSAGE_KEY_LEFT;
00379         InputMessage MESSAGE_KEY_RIGHT;
00380         InputMessage MESSAGE_KEY_FIRE;
00381 
00382         SpriteMessage MESSAGE_SPRITE_STATE_CHANGE;
00383 };      
00384 
00385 #endif // CSGAME_H

Generated on Wed Jul 14 00:43:29 2004 for CSLib by doxygen 1.3.6