Hi, so i'm wanting to work on a small personal project, involving me building my own simplish engine, and everything related, and at the moment, i'm creating entity types similar to this (this is the header file, not cpp)

class e_ship : public g_entity
{
public:
	float x;
	float y;
	float xseepd;
	float yseepd;
	float dir;
	float dirspeed;
	g_texture spr;
public:

	void midstep();
	void draw();
	void init();

};

and entities are spawned something like this

i would also like to do similar things with my resources, materials etc, so links to articles about resource loading/management would be helpful also

thanks

hmm, interesting, though im not sure i understand fully, even if i were to assign classnames to identify these objects( i assume just for maploading or something, though magic numbers would seem to work better)

wouldnt i still need to catalogue these classes so i can loop through them and find which name belongs to which class, making it redundant for my purpose?

i'll read through it better when i get home, maybe you explained that and i missed it

so what im understanding, i would do something like

class myclass : public baseclass

{

string Cname ="c_myclass"

}

register(myclass) (or a pointer to it?)

registering it would add it to a list of all the other classes using its Cname, i would then be able to spawn shit by say

SpawnEntity(findCLassByName("c_myclass"),x,y)- and i could also register it with a "Magic number" also to facilitate smaller savefiles or, uh faster processing times (strings vs ints)

so, question time, would this register be er, pointers to the classes?, i'm still a little new to this, but i assume that if i did something like function(aclass) it would pass aclass's position in memory, and i could do something like x=aclass->x or .x or whatever.

i also found this

https://developer.valvesoftware.com/wiki/Authoring_a_Logical_Entity

though it doesnt seem to have any description of how the classes are held so it's not so helpful

+1 for string identifiers, meaningful, easy to make unique, and possible to optimise later in the unlikely event that they become a performance issue.

You can create a handler object for each type, that knows how to create, serialise or do anything else you need. I create these from a template to save writing every one from scratch.

Then store the handlers in a map using the unique identifiers as a key.

When you want to create an object and you have an identifier, look up the handler in the map and call the create function.

Here's an example:

class ObjectBase
{
public:
	virtual ~ObjectBase() {}
};

class BaseHandler
{
public:
	virtual ObjectBase* Create() const = 0;
	virtual const char* Type() const = 0;
};

template<typename T>
class Handler : public BaseHandler
{
public:
	ObjectBase* Create() const
	{
		return new T();
	}

	const char* Type() const
	{
		return T::Type();
	}
};

class Factory 
{
public:
	void Register(BaseHandler* pHandler)
	{
		m_handlerMap.emplace(pHandler->Type(), std::unique_ptr<BaseHandler>(pHandler));
	}

	ObjectBase* Create(const std::string& type) const
	{
		auto it = m_handlerMap.find(type);

		if (it != m_handlerMap.end())
			return it->second->Create();
		else
			return 0;
	}

private:
	std::map<std::string, std::unique_ptr<BaseHandler>> m_handlerMap;
};

class Bullet : public ObjectBase
{
public:
	static const char* Type() 
	{
		return "Bullet";
	}
};

class Ship : public ObjectBase
{
public:
	static const char* Type() 
	{
		return "Ship";
	}
};

void RegisterObjects(Factory *factory)
{
	factory->Register(new Handler<Bullet>());
	factory->Register(new Handler<Ship>());
}
 
int main()
{
	Factory factory;

	RegisterObjects(&factory);

	Bullet* pBullet = (Bullet*) factory.Create("Bullet");
	Ship* pShip = (Ship*) factory.Create("Ship");

	delete pBullet;
	delete pShip;
}

if i understand correctly, the idea is to just link a create function to each class, which then returns the address of the instance created, which you can then use to get the data from, rather than reading directly from the class (which i didnt think was possible anyway) ?

so for example i could do

Attributes attrib=factory.create("Bullet")->Attribs();

or something along those lines, rather than say, having the address to the class itself?

and so i could also have just a list of these instances to see these attributes themselves spawned with above method, and just keep them handy for when i need it

correct me if i'm wrong though, i think i get it though