In this new tutorial, as I had promised before, we are going to take our hand at creating entities. Entities, for all gaming purposes, are anything that can be interacted with in any way, shape, or form. Some examples might be a monster or a treasure chest that you can open. In this sense, practically everything within the game that moves is an Entity. A rock that is part of a map, which never moves, is not an entity. But if you wanted that rock to move for whatever reason, then we'd make it an Entity. This tutorial will be split into 3 different tutorials. The first, this one you are reading, will deal with a basic Entity class structure. The next tutorial will veer off slightly to build a Map class via a tileset. Then, the last tutorial, which is what a lot of people have trouble with, will deal with Entity to Map collision, and Entity to Entity Collision.
Update:
- Fixed class below to have a virtual destructor.
(Thanks Andras!)
Lets get started by creating two new files called CEntity.cpp and CEntity.h. Open up the header file and add the following:
#include <vector>
#include "CAnimation.h"
#include "CSurface.h"
class CEntity {
public:
static std::vector<CEntity*> EntityList;
protected:
CAnimation Anim_Control;
SDL_Surface* Surf_Entity;
public:
float X;
float Y;
int Width;
int Height;
int AnimState;
public:
CEntity();
virtual ~CEntity();
public:
virtual bool OnLoad(char* File, int Width, int Height, int MaxFrames);
virtual void OnLoop();
virtual void OnRender(SDL_Surface* Surf_Display);
virtual void OnCleanup();
};
Now, open up the cpp file and add the following:
#include "CEntity.h"
std::vector<CEntity*> CEntity::EntityList;
CEntity::CEntity() {
Surf_Entity = NULL;
X = Y = 0.0f;
Width = Height = 0;
AnimState = 0;
}
CEntity::~CEntity() {
}
bool CEntity::OnLoad(char* File, int Width, int Height, int MaxFrames) {
if((Surf_Entity = CSurface::OnLoad(File)) == NULL) {
return false;
}
CSurface::Transparent(Surf_Entity, 255, 0, 255);
this->Width = Width;
this->Height = Height;
Anim_Control.MaxFrames = MaxFrames;
return true;
}
void CEntity::OnLoop() {
Anim_Control.OnAnimate();
}
void CEntity::OnRender(SDL_Surface* Surf_Display) {
if(Surf_Entity == NULL || Surf_Display == NULL) return;
CSurface::OnDraw(Surf_Display, Surf_Entity, X, Y, AnimState * Width, Anim_Control.GetCurrentFrame() * Height, Width, Height);
}
void CEntity::OnCleanup() {
if(Surf_Entity) {
SDL_FreeSurface(Surf_Entity);
}
Surf_Entity = NULL;
}
Okay, now for some basic explanation. What we are doing here is encapsulating the basic 5 components I mentioned within the first lesson (excluding Events, which will be handled in a later lesson). This allows us to handle Entities within the game much more easily, rather than clumping them together with everything else in the game within the main CApp class. This will also be the way we handle other things as well. The first thing you may notice is a static vector called EntityList. This vector will hold all of our entities, easily accessible through CEntity::EntityList, because it's declared as a static. I should make a special note here: we declare this EntityList within CEntity because it prevents from circular dependencies later on. An example of this is trying to get a Map to communicate with Entities, and Entities to get to communicate with the Map. Such as CMap declaring a CEntity member, and CEntity declaring a CMap member. It would cause problems on the compile level.
So this vector contains all of our Entities within the game. Notice that each member of the vector is a pointer. This is because later on we are going to inherit this CEntity class for Entity specific classes. So, for example, if we were going to make a Megaman game, we would have a CMegaMan class inheriting the CEntity class. And, via polymorphism, we can store that CMegaMan class within the EntityList. This is the very reason why we declared the functions above as virtuals, and certain members as protected.
Next, we have basic information about the Entity, common to all Entities, coordinates, dimensions, and a surface for its image. Next, we have a loading function that basically takes a filename, and loads the image. By default, we have it setting a transparent color. I'd like to step aside here for a moment to let you all know that certain things I do aren't set in stone. You can, and are encourage, to take this code and modify to your liking. You may want more parameters on your OnLoad function, or you may want less. You may not want a default transparent color, who knows. I encourage you to test different things. Don't worry, my code will still be here if you mess things up.
Next, we have a basic OnLoop function that handles basic calculations. Right now we are only calculating Animation. Also please note that we have only set the MaxFrames for the Animation, and left the defaults in place. Next, we have the OnRender function. Instead of making it render to the display only, I've allowed a parameter to specify where to render this entity. This could be any surface you want. So you could, if you wanted, render one entity onto another.
Lastly, we have an OnCleanup function that restores memory and all that stuff.
Like I mentioned in the beginning, this is a basic Entity class structure, it basically doesn't do much yet, but don't fret, it soon will in coming lessons. So lets get it working. Open up CApp.h and add the header file to the top, and declare two Entities:
#include "CEntity.h"
//...
private:
CEntity Entity1;
CEntity Entity2;
Now, lets load these two Entities. Open up CApp_OnInit.cpp and add the following:
if(Entity1.OnLoad("./entity1.bmp", 64, 64, 8) == false) {
return false;
}
if(Entity2.OnLoad("./entity2.bmp", 64, 64, 8) == false) {
return false;
}
Entity2.X = 100;
CEntity::EntityList.push_back(&Entity1);
CEntity::EntityList.push_back(&Entity2);
Now, depending on the images you use, you need to set the values appropriately on the OnLoad function. I've reused the yoshi image from the previous lesson, and if you still need it:

Now, remember how I stated we are basically encapsulating the basic functions of a game within the Entity class? We have to call those functions now in the respective CApp functions. So, open up CApp_OnLoop.cpp and add the following:
for(int i = 0;i < CEntity::EntityList.size();i++) {
if(!CEntity::EntityList[i]) continue;
CEntity::EntityList[i]->OnLoop();
}
We are basically running through each Entity in our vector, and calling the OnLoop function. Simple enough! (And we're doing an error checking so we don't call any NULL pointers). Now, lets do the same things in CApp_OnRender.cpp:
for(int i = 0;i < CEntity::EntityList.size();i++) {
if(!CEntity::EntityList[i]) continue;
CEntity::EntityList[i]->OnRender(Surf_Display);
}
And the same thing in CApp_OnCleanup.cpp:
for(int i = 0;i < CEntity::EntityList.size();i++) {
if(!CEntity::EntityList[i]) continue;
CEntity::EntityList[i]->OnCleanup();
}
CEntity::EntityList.clear();
Note that I added the clear function call, which clears out the vector to nothing. Basically a reset.
Great, now try getting this thing to compile. You should see two yoshis running together on the screen. In the next lesson we're going to looking at making Maps, and creating a basic file format for our Maps.
for ( int i = 0; i < C_Entity::EntityList.size(); i++)
warning: comparison between signed and unsigned integer expressions
?? Why do I get that warning and is that a problem?
Email (required, not published):
Website:
Email (required, not published):
Website:
I have modified the constructor of CEntity, to add the CEntity to the static array. It's a simple change, but then you don't need to think about add the entity afterwards.
CEntity::CEntity() {
Surf_Entity = NULL;
X = Y = 0.0f;
Width = Height = 0;
AnimState = 0;
CEntity::EntityList.push_back(this);
}
cheers
Email (required, not published):
Website:
ex.
CEntity* p_ent = new CEntity; // Calls Ctor, pushes itself into EntityList
< Do stuff with the entity >
delete p_ent; // Pointer not removed, but the Entity doesn't exist
Accessing the entity list will now de-reference a bogus pointer and crash.
Email (required, not published):
Website:
But probably, separating the new and the add to the EntityList will be better, in this case, to have better control about the references.
Sorry about my horrible english =P
Kind regards!
Email (required, not published):
Website:
I suspect this is only working because int literals are being stored in the fields as ints and retrieved as ints, so why not declare them as int? Has someone tried setting these to a float value? I'll do so shortly and post the results.
Email (required, not published):
Website:
Email (required, not published):
Website:
| 'CEntity' does not name a type |
Don't know why that is happening, everything is equal to the tutorial...
Email (required, not published):
Website:
Email (required, not published):
Website:
if((surf_ent = CSurface::OnLoad(File)) == NULL) return false;
CSurface::Transparent(surf_ent,255,0,255);
this->width = w;
this->height = h;
anim_contr.maxFrames = maxFrames;
return true;
}
I have a question, why do we need to use "this->" on the width and height but not on the anim_contr?
Email (required, not published):
Website:
Email (required, not published):
Website:
Email (required, not published):
Website:
You'll notice with vertical sprite sheets, the X coordinate is always zero, but the Y coordinate is the frame number multiplied by the frame height for each frame (as each frame is stacked on top of one-another, you'll always be starting at the same position on the left).
To get this to work with horizontal sprite sheets, just reverse the above. So, the Y coordinate is always zero (because each frame is at the same height) BUT the X coordinate will be the frame width multiplied by the current frame number (because each frame is stuck side-by-side, you need to move the X position, not the Y).
So, assuming your frames are 64 pixels in width (could be anything), an example of the x-coordinate would be:
first frame = 0 (far left of screen)
second frame = 64
third frame = 128
and so on.. as I mentioned, this is exactly the same as with vertical sheets, only with the axes in reverse.
Hopefully this makes sense and I haven't misinterpreted your question :)
Email (required, not published):
Website:
Email (required, not published):
Website:
This code solves this problem:
entities.cpp:
bool CEntity::OnLoad(char* File, int Width, int Height, int MaxFrames) {
OnCleanup();// call before Loading a new Imgage...
if((Surf_Entity = CSurface::OnLoad(File)) == NULL) {
return false;
}
CSurface::Transparent(Surf_Entity, 255, 0, 255);
this->Width = Width;
this->Height = Height;
Anim_Control.MaxFrames = MaxFrames;
return true;
}
Email (required, not published):
Website:
Im currently doing my masters degree in software engineering where one of my tasks is to write a game-engine.
These tutorials are helping a lot.
I have this silly issue where the entities are not displaying on the screen at all. I have been programing for years now, and i have debugged through the code, everything is initialized correctly.. there is just no display??
is any one else running into similar problems?
Regards,
Spook
Email (required, not published):
Website:
No idea what's causing it :(
Email (required, not published):
Website:
Email (required, not published):
Website:
Just something to watch out for.
Email (required, not published):
Website:
This code solves this problem:
entities.cpp:
bool CEntity::OnLoad(char* File, int Width, int Height, int MaxFrames) {
if((Surf_Entity = CSurface::OnLoad(File)) == NULL) {
return false;
}
OnCleanup();
CSurface::Transparent(Surf_Entity, 255, 0, 255);
this->Width = Width;
this->Height = Height;
Anim_Control.MaxFrames = MaxFrames;
return true;
}
Email (required, not published):
Website:
Email (required, not published):
Website:
Email (required, not published):
Website: