Sample OO simple game.

//enumeration to identify raw data blob types to allow you to convert from blob->real typeenum GameTypeIDEnum{	eUnenmeratedType,	eDashRawType,		//this tells us the data blob is of type struct Dash::Raw};//raw data blob struct holds data to non-primitive game specific data typesstruct RawDataBlob{	RawDataBlob():mGameTypeID(0),mPtr(NULL),mSize(0){}	RawDataBlob(int gameTypeID, const char* ptr, int size):mGameTypeID(gameTypeID),mPtr(ptr),mSize(size){}	int			mGameTypeID;	const char* mPtr;	int			mSize;};//variable data object, can hold variety of data types has somewhat safe interface. Note these bindings//are bound to the variables by reference so this eliminate the need to constantly reenumerate the class once//you have them. This of course poses a problem with scope of the bound data which is left up to the application//to manage.class VarTypeConst{public:	enum VarTypeEnum	{		eIsUnknown,		eIsFloat,		eIsInt,		eIsString,		eIsBlob,	};	VarTypeConst() : mInt(NULL),mFloat(NULL),mString(NULL){} 	explicit VarTypeConst(const RawDataBlob blob) : mInt(NULL),mFloat(NULL),mString(NULL){mBlob=blob;}	explicit VarTypeConst(const int* var) : mInt(var),mFloat(NULL),mString(NULL){}	explicit VarTypeConst(const float* var) : mInt(NULL),mFloat(var),mString(NULL){}	explicit VarTypeConst(const std::string* var) : mInt(NULL),mFloat(NULL),mString(var){}	VarTypeConst& operator = (const float* var)	{		Reset();		mFloat = var;				return *this;	}	VarTypeConst& operator = (const int* var)	{		Reset();		mInt = var;				return *this;	}	VarTypeConst& operator = (const std::string* var)	{		Reset();		mString = var;				return *this;	}	VarTypeConst& operator = (const RawDataBlob& var)	{		Reset();		mBlob = var;				return *this;	}	VarTypeEnum	GetType()	{		if (mInt!=NULL)		{			return eIsInt;		}		else if (mFloat!=NULL)		{			return eIsFloat;		}		else if (mString!=NULL)		{			return eIsString;		}		else if(mBlob.mPtr!=NULL && mBlob.mSize!=0)		{			return eIsBlob;		}		return eIsUnknown;	}	float GetFloat()	{		assert(GetType()==eIsFloat);		if (mFloat==NULL)		{			return 0.0f;		}		return *mFloat;	}	int  GetInt()	{		assert(GetType()==eIsInt);		if (mInt==NULL)		{			return 0;		}		return *mInt;	}	const std::string& GetString()	{		assert(GetType()==eIsString);		if (mString==NULL)		{			static std::string nullString;			return nullString;		}		return *mString;	}	const RawDataBlob& GetBlob()	{			assert(GetType()==eIsBlob);		return mBlob;	}private:	void Reset(){mFloat=NULL;mInt=NULL;mString=NULL;mBlob.mPtr=NULL;mBlob.mSize=0;}	const int*				mInt;	const float*			mFloat;	const std::string*		mString;	RawDataBlob				mBlob;};//binding object used to enumerate the data within a game object classstruct DataBinderReadOnly{	std::map<std::string,VarTypeConst>	mData;};//base game object class, demonstrates data binding ( a primitive type of reflection ) and proper use//of inheritance chaining for enumeration.class GameObejct{	public:	virtual bool EnumerateData(DataBinderReadOnly& bindings)	{		bindings.mData["mGameObjectID"]=&mGameObjectID;		bindings.mData["mName"]=&mName;		return true;	}private:	int			mGameObjectID;		//test int binding	std::string mName;				//test string binding};//simple child class demonstrating various data bindingsclass Boulder : public GameObejct{public:	virtual bool EnumerateData(DataBinderReadOnly& bindings)	{		bindings.mData["mBoulderRadius"]=&mBouderRadius;		bindings.mData["mBouderMass"]=&mBouderMass;		bindings.mData["mPosX"]=&mPosX;		bindings.mData["mPosY"]=&mPosY;		return GameObejct::EnumerateData(bindings);	}private:	float mBouderRadius;		//test float binding	float mBouderMass;	float mPosX;	float mPosY;};//simple child class demonstrating various data bindingsclass Dash : public GameObejct{	virtual bool EnumerateData(DataBinderReadOnly& bindings)	{		bindings.mData["mDashSpeed"]=&mDashSpeed;		bindings.mData["mRawData"]=RawDataBlob(eDashRawType,(const char*)&mRawData,sizeof(mRawData));		return GameObejct::EnumerateData(bindings);	}	struct Raw	{		int mVar1;		int mVar2;	};	float		mDashSpeed;			Raw			mRawData;				//raw data object to test Blob type};

class Board   {     IBoardObject[,] _mapBoard;}interface IBoardObject{  void Draw(SpriteBatch sb, Camera cam, ref int tilex, ref int tiley);}class BoardObject : IBoardObject {    public virtual void Draw(SpriteBatch sb, Camera cam, ref int tilex, ref int tiley) { }}interface IUpdatable {  void Update(int x, int y, IBoardObject[,] map);}interface IDestroyable{ void Destroy();}......class FireFly : BoardObject, IUpdatable, IDestroyable {        public override void Update(int x, int y, IBoardObject[,] map) { .. }        public override void Destroy() { ... } ;}....

for (int i = minx; i <= maxx; ++i)  {  for (int j = miny; j <= maxy; ++j)    {      _mapBoard[i, j].Draw(sb, cam,ref i,ref j);    }}

for (int y = Height() - 1; y >= 0; --y){   for (int x = 0; x < Width(); ++x)   {     IUpdatable up= _mapBoard[x,y] as IUpdatable;     if(up!=null) {         if(up.UpdateCheck!=UpdateCheck) {            up.Update(x,y,_mapBoard);         }     }   }}