[diego_pmc]

@Fib Oh, we were supposed to design the whole system the interface. :| I was under to impression we had to write the World::update() function.

I have a question though (I don't know if this is the right place for it): why would MovableGameObjects necessarily be DrawableGameObjects? It feels a bit like mixing the model with the view.

Would it not be more appropriate to have two interface classes, class IMovableObject and class IDrawableObject, and use them in a manner similar to how you would use interfaces in Java?

class Player
    : public IMovableObject, IDrawableObject

Btw, thanks for the sketch, I just realized something I was wondering how to implement in a game. (I've read about how to code games but never really done anything very big.) I'll probably learn a few things from the examples people post here.

This post has been edited by diego_pmc: 16 February 2011 - 02:39 PM

[stayscrisp]

@Fib

That class design looks pretty good, I would consider making a base class for all game objects so that your world class could have a container of pointers to the overall base class.

std::vector<BaseGameObject*> GameObjects; // can contain all derived classes

What do you think?

This post has been edited by stayscrisp: 03 January 2012 - 04:20 AM

[Fib]

stayscrisp, on 17 February 2011 - 10:19 AM, said:

@Fib

That class design looks pretty good, I would consider making a base class for all game objects so that your world class could have a container of pointers to the overall base class.

std::vector<BaseGameObject*> GameObjects; // can contain all derived classes

What do you think?

I thought about it. But I couldn't think of any members or methods to put inside of the overall base class. But yes that is a good idea.

[stayscrisp]

Possibly something like this

Spoiler

// BaseGameObject header
class BaseGameObject
{
public:
	
	BaseGameObject() : m_id(0) {}
	virtual ~BaseGameObject() {}

	virtual bool Load() = 0;
	virtual void Update() = 0;
	virtual void Draw() = 0;

	int GetID() { return m_id; }

protected:

	int m_id;
};

// Player header
class Player : public BaseGameObject
{
public:

	Player() : m_pos(vector3d(0,0,0)), m_vel(vector3d(0,0,0)) {}

	virtual bool Load();
	virtual void Update();
	virtual void Draw();

private:

	vector3d m_pos;
	vector3d m_vel;
};

// Obstacle Header
class Obstacle : public BaseGameObject
{
public:

	Obstacle() : m_pos(vector3d(0,0,0)) {}

	virtual bool Load();
	virtual void Update();
	virtual void Draw();

private:

	vector3d m_pos;
};


// The world header
class World
{
public:

	typedef std::vector<BaseGameObject*> GameObjects;

	World() : m_nextAvailableID(0) {}
	~World() {}

	bool LoadWorld();

	void AddGameObject(GameObject* go);

	void UpdateWorld();
	void DrawWorld();
        void HandleCollisions(); 

	void CleanWorld();

	GameObjects& GetGameObjects() { return m_gameObjects; }

	int GetNextAvailableID() { return m_nextAvailableID; }

private:

	int m_nextAvailableID;

	GameObjects m_gameObjects;
};

// the world update function :)/>
void World::UpdateWorld()
{
	for(GameObjects::iterator it = m_gameObjects.begin(); it != m_gameObjects.end(); ++it)
	{
		(*it)->Update();
	}
}

This post has been edited by stayscrisp: 17 February 2011 - 12:51 PM

[(Cryptic)]

Wow, seems like I've missed out on a lot.

Well for question (2). I'd answer, I'm restless, I am too motivated, and I find everyone takes what I say to seriously, even though I'm usually debating or giving an opinion to receive and opinion to learn. Also I have a subconscious trigger that, if I feel like your testing my stupidity I'll act stupid =D <-- I think the last one is serious bahahaha... bad habbit.

As for question one, it looks like im too late ( actually happy about that, my code would of looked ugly compare to the samples I've seen here).

But anyways:
Design an OO system for a game containing a world, a player and obstacles. The player will be able to move around the world and avoid obstacles. Only the declarations are needed for all classes but the definition of the World Update function is required.

Spoiler

Method 1.
void World:Update()
{
	// INIT WHATEVER DEPENDING ON API
	
	int x = 0;
	int y = 0;
	bool dead = false;
	
	if(jump) y += MOV;
	if(down) y -= MOV;
	if(left) x -= MOV;
	if(right) x += MOV;	
	
	SData platformData = myPlatform->GetData();
	SData playerData = myPlayer->GetData();
	
	
	// Manual Collision Check... The long way.
	
	
	if(	playerData.x + playerData.w > platformData.x ||
	playerData.x < platformData.x + platformData.w)
	{
		
		// Should roughly be on the platform
		if(playerData.y + playerData.h > platformData.y ||
		playerData.y < platformData.y)  
		{
			// myPlayer->Align(myPlatform);
			y -= GetYDistance(playerData, platformData);
		}
	}
	else
	{
		y += FALLRATE;
	}

	
	
	myPlayer->Update(x,y);
	myPlatform->Update(x,y);
}


Method 2. The OOP way.. Which I always forget and need reference , for the dam math formula's ( I think I got short term memory loss... ).
The FALLRATE is a bit redundent, this this example.
{
	int x = 0;
	int y = 0;
	bool dead = false;
	
	if(jump) y += MOV;
	if(down) y -= MOV;
	if(left) x -= MOV;
	if(right) x += MOV;
	
	
	// FALSE, no collision == not on platform.
	if(!GetLinearCollision(&x, &y, myPlayer->GetData, myPlatform->GetData))
	{
		dead = myPlayer->Fall();
	}
	
	if(!dead)
	{
		myPlayer->PlayerUpdate(x,y);
		myPlatform(x,y);
	}
	else
	{
		// End the Game.
	}
	
}

class CPlayer : CImage
{
	SData data;
	float jump;
	
	void CPlayer:CPlayer();
	
	void CPlayer(float nx, float ny);
	void CPlayer(float nx, float ny, float nox, float noy);
	void Update(float x, float y);
	void Alight(CPlatform p);
	bool Fall();
	
	SData *GetData();
	
	
	
	
};

class CPlatform:CImage
{
	SData data;
	
	void CPlatform();
	void CPlatform(float nx, float ny, float nox, float noy);
	void Update(float nox, float noy);
	
	SData *GetData();
	
	
}

class CImage
{
	float x, y, w, h;
	Image myImage;
	
	// Dummy...
	// Depends on API
	
};

struct SData
{
	float x, y, ox, oy, vx, vy;
};

This post has been edited by stayscrisp: 20 February 2011 - 07:14 AM