Engine design and resources

[source lang=cpp]class SIResource{protected:	unsigned int id;	bool needed;	vector<unsigned int> dependecies;public:	SIResource();	virtual bool load()=0;	virtual bool isLoaded() const=0;	virtual void unload()=0;	virtual unsigned int getID() const;		virtual bool isNeeded() const;	virtual void setNeeded(bool needed);	virtual bool loadIfNeeded();	virtual bool readHeader()=0;	virtual bool readDependencies(const string &dependenciesList);	virtual bool isLoadedLast() const;};

[source lang=cpp]SIResource::SIResource(){	SIResource::id=id;}unsigned int SIResource::getID() const{	return id;}bool SIResource::isNeeded() const{	return needed;}void SIResource::setNeeded(bool needed){	if(needed&&!SIResource::needed)	{		for(vector<unsigned int>::iterator it=dependecies.begin();it!=dependecies.end();++it)			SResourcesManager::markAsNeeded(*it);	}	SIResource::needed=needed;}bool SIResource::loadIfNeeded(){	if(isNeeded()&&!isLoaded())		return load();	if(!isNeeded()&&isLoaded())		unload();	return true;}bool SIResource::readDependencies(const std::string &dependenciesList){	return sAddToUIntVector(dependecies,dependenciesList);}bool SIResource::isLoadedLast() const{	return false;}

[source lang=cpp]class SResourcesManager{private:	static SResourcesManager *instance;	SResourcesManager();	map<unsigned int,SIResource*> resourceMap;	map<unsigned int,SImage*> loadedImages;	map<unsigned int,SObjectPlacer*> loadedPlacers;	map<unsigned int,SLEntity*> lEntities;	map<unsigned int,SObjectBatch*> loadedBatches;	map<unsigned int,STexture*> loadedTextures;		map<unsigned int,SGUIBatch*> loadedGUIBatches;public:	static void init();	static void destroy();	static bool readFromListFile(string fileName);	static void beginMarking();	static bool markAsNeeded(unsigned int id);	static bool endMarking();	static void addImage(unsigned int id,SImage *image);	static void removeImage(unsigned int id);	static SImage *getImage(unsigned int id);		static void addPlacer(SObjectPlacer *placer);	static void removePlacer(unsigned int id);	static SObjectPlacer *getPlacer(unsigned int id);	static void addLEntity(unsigned int id,SLEntity *lEntity);	static void removeLEntity(unsigned int id);	static void clearLEntities();	static SLEntity *getLEntity(unsigned int id);	static void addAllLEntitiesToWorld(SLWorld *target);	static void addBatch(SObjectBatch *batch);	static void removeBatch(unsigned int id);	static SObjectBatch *getBatch(unsigned int id);	static bool deployBatchesWithConditionMet(SWorld *target);	static void addTexture(unsigned int id,STexture *texture);	static void removeTexture(unsigned int id);	static STexture *getTexture(unsigned int id);	static void addGUIBatch(SGUIBatch *guiBatch);	static void removeGUIBatch(unsigned int id);	static SGUIBatch *getGUIBatch(unsigned int id);};

[source lang=cpp]SResourcesManager *SResourcesManager::instance=0;SResourcesManager::SResourcesManager(){}void SResourcesManager::init(){	if(instance)		destroy();	instance=new SResourcesManager();}void SResourcesManager::destroy(){	for(map<unsigned int,SIResource*>::iterator it=instance->resourceMap.begin();it!=instance->resourceMap.end();++it)	{		it->second->unload();		delete it->second;	}	instance->resourceMap.clear();	instance=0;}bool SResourcesManager::readFromListFile(std::string fileName){	SObjectFileReader reader(fileName);	reader.beginReading();	reader.readNext();	SIResource *tmpResource=0;	while(!reader.isEOF())	{		tmpResource=0;		if(reader.getCommand()=="textureMap")			tmpResource=new STextureMap(reader.getArguments());		else if(reader.getCommand()=="objectPoll")			tmpResource=new SObjectPoll(reader.getArguments());		else if(reader.getCommand()=="level")			tmpResource=new SLevelLoader(reader.getArguments());		else if(reader.getCommand()=="texture")			tmpResource=new STextureLoader(reader.getArguments());		else if(reader.getCommand()=="guiLayout")			tmpResource=new SGUILoader(reader.getArguments());		if(tmpResource)		{			if(!tmpResource->readHeader())				return false;			instance->resourceMap.insert(pair<unsigned int,SIResource*>(tmpResource->getID(),tmpResource));		}		reader.readNext();	}	return true;}void SResourcesManager::beginMarking(){	for(map<unsigned int,SIResource*>::iterator it=instance->resourceMap.begin();it!=instance->resourceMap.end();++it)	{		it->second->setNeeded(false);	}}bool SResourcesManager::markAsNeeded(unsigned int id){	map<unsigned int,SIResource*>::iterator it=instance->resourceMap.find(id);	if(it==instance->resourceMap.end())	{				stringstream err;		err<<"Unable to find resource number ";		err<<id;		err<<".";				SSystem::addError(err.str());		return false;	}	it->second->setNeeded(true);	return true;}bool SResourcesManager::endMarking(){	queue<SIResource*> loadedLast;	for(map<unsigned int,SIResource*>::iterator it=instance->resourceMap.begin();it!=instance->resourceMap.end();++it)	{		if(it->second->isLoadedLast())			loadedLast.push(it->second);		else if(!it->second->loadIfNeeded())			return false;	}	while(!loadedLast.empty())	{		if(!loadedLast.front()->loadIfNeeded())			return false;		loadedLast.pop();	}	return true;}void SResourcesManager::addImage(unsigned int id, SImage *image){	instance->loadedImages.insert(pair<unsigned int,SImage*>(id,image));}void SResourcesManager::removeImage(unsigned int id){	instance->loadedImages.erase(id);}SImage *SResourcesManager::getImage(unsigned int id){	map<unsigned int,SImage*>::iterator it=instance->loadedImages.find(id);	if(it==instance->loadedImages.end())		return 0;	return it->second;}void SResourcesManager::addPlacer(SObjectPlacer *placer){	instance->loadedPlacers.insert(pair<unsigned int,SObjectPlacer*>(placer->getID(),placer));}void SResourcesManager::removePlacer(unsigned int id){	instance->loadedPlacers.erase(id);}SObjectPlacer *SResourcesManager::getPlacer(unsigned int id){	map<unsigned int,SObjectPlacer*>::iterator it=instance->loadedPlacers.find(id);	if(it==instance->loadedPlacers.end())		return 0;	return it->second;}void SResourcesManager::addLEntity(unsigned int id, SLEntity *lEntity){	instance->lEntities.insert(pair<unsigned int,SLEntity*>(id,lEntity));}void SResourcesManager::removeLEntity(unsigned int id){	instance->lEntities.erase(id);}void SResourcesManager::clearLEntities(){	instance->lEntities.clear();}SLEntity *SResourcesManager::getLEntity(unsigned int id){	map<unsigned int,SLEntity*>::iterator it=instance->lEntities.find(id);	if(it==instance->lEntities.end())		return 0;	return it->second;}void SResourcesManager::addAllLEntitiesToWorld(SLWorld *target){	for(map<unsigned int,SLEntity*>::iterator it=instance->lEntities.begin();it!=instance->lEntities.end();++it)		target->add(it->second);}void SResourcesManager::addBatch(SObjectBatch *batch){	instance->loadedBatches.insert(pair<unsigned int,SObjectBatch*>(batch->getID(),batch));}void SResourcesManager::removeBatch(unsigned int id){	instance->loadedBatches.erase(id);}SObjectBatch *SResourcesManager::getBatch(unsigned int id){	map<unsigned int,SObjectBatch*>::iterator it=instance->loadedBatches.find(id);	if(it==instance->loadedBatches.end())		return 0;	return it->second;}bool SResourcesManager::deployBatchesWithConditionMet(SWorld *target){	queue<unsigned int>batchesToRemove;	map<unsigned int,SObjectBatch*>::iterator it=instance->loadedBatches.begin();	while(it!=instance->loadedBatches.end())	{		SObjectBatch *batch=it->second;		if(batch->isDeployingConditionMet(target))		{			if(!batch->place(target))				return false;			if(batch->isRemoveWhenDeployed())				batchesToRemove.push(it->first);			if(batch->isDeleteWhenDeployed())				delete batch;		}		++it;	}	while(!batchesToRemove.empty())	{		instance->loadedBatches.erase(batchesToRemove.front());		batchesToRemove.pop();	}	return true;}void SResourcesManager::addTexture(unsigned int id,STexture *texture){	instance->loadedTextures.insert(pair<unsigned int,STexture*>(id,texture));}void SResourcesManager::removeTexture(unsigned int id){	instance->loadedTextures.erase(id);}STexture *SResourcesManager::getTexture(unsigned int id){	map<unsigned int,STexture*>::iterator it=instance->loadedTextures.find(id);	if(it==instance->loadedTextures.end())		return 0;	return it->second;}void SResourcesManager::addGUIBatch(SGUIBatch *guiBatch){	instance->loadedGUIBatches.insert(pair<unsigned int,SGUIBatch*>(guiBatch->getID(),guiBatch));}void SResourcesManager::removeGUIBatch(unsigned int id){	instance->loadedGUIBatches.erase(id);}SGUIBatch *SResourcesManager::getGUIBatch(unsigned int id){	map<unsigned int,SGUIBatch*>::iterator it=instance->loadedGUIBatches.find(id);	if(it==instance->loadedGUIBatches.end())		return 0;	return it->second;}

struct Texture{	SDL_Rect srcRect; //where to blit from srcSurface.	SDL_Surface* srcSurface;};

/// <summary>/// Resource manager/// </summary>static public class ResourceManager{	#region Providers	/// <summary>	/// Adds a provider	/// </summary>	/// <param name="provider">The provider</param>	static public void AddProvider(Provider provider)	{		if (provider == null)			throw new ArgumentNullException("provider");		if (Providers.Contains(provider))			throw new ArgumentException("Provider already present", "provider");		// Adds the provider to the list		Providers.Add(provider);		// Register asset's tags		foreach (string tag in provider.Tags)			Tags.Add(tag, provider);		// Register assets		foreach (Type type in provider.Assets)			Assets.Add(type, provider);	}	/// <summary>	/// Returns a provider's instance	/// </summary>	/// <typeparam name="T">Type of the provider</typeparam>	/// <returns>Instance or null</returns>	static public T GetProvider<T>() where T : Provider	{		foreach (Provider provider in Providers)		{			if (provider is T)				return (T)(object)provider;		}		return default(T);	}	/// <summary>	/// Returns the provider of a tag	/// </summary>	/// <param name="tag">Xml tag</param>	/// <returns>Provider or null</returns>	static public Provider GetTagProvider(string tag)	{		if (string.IsNullOrEmpty(tag))			throw new ArgumentNullException("tag");		if (!Tags.ContainsKey(tag))			return null;		return Tags[tag];	}	/// <summary>	/// Returns the <see cref="Provider"/> of an asset	/// </summary>	/// <param name="type">asset type</param>	/// <returns>Provider of the asset or null</returns>	static public Provider GetAssetProvider(Type type)	{		if (type == null)			throw new ArgumentNullException("type");		if (Assets.ContainsKey(type))			return Assets[type];		return null;	}	/// <summary>	/// Removes a specific provider	/// </summary>	/// <param name="provider">Provider to remove</param>	static public void RemoveProvider(Provider provider)	{		if (provider == null)			throw new ArgumentNullException("provider");		// Remove tags		foreach (string tag in provider.Tags)			Tags.Remove(tag);		// Remove provider		Providers.Remove(provider);	}	#endregion	/// <summary>	/// Creates an asset	/// </summary>	/// <typeparam name="T">Type of the asset</typeparam>	/// <param name="name">ASset name</param>	/// <returns>The asset or null</returns>	static public T CreateAsset<T>(string name)	{		if (!Assets.ContainsKey(typeof(T)))			throw new ArgumentException("Unknown asset type");		return Assets[typeof(T)].Create<T>(name);	}	/// <summary>	/// Removes an asset	/// </summary>	/// <typeparam name="T">Asset type</typeparam>	/// <param name="name">Name of the asset</param>	static public void RemoveAsset<T>(string name)	{		if (!Assets.ContainsKey(typeof(T)))			throw new ArgumentException("Unknown asset type");		Assets[typeof(T)].Remove<T>(name);	}	/// <summary>	/// Returns an asset	/// </summary>	/// <typeparam name="T">Asset type</typeparam>	/// <returns>A list of available assets</returns>	static public List<string> GetAssets<T>()	{		if (!Assets.ContainsKey(typeof(T)))			throw new ArgumentException("Unknown asset type");		return Assets[typeof(T)].GetAssets<T>();	}	/// <summary>	/// Returns all assets of a type	/// </summary>	/// <typeparam name="T">Asset type</typeparam>	/// <returns>Assets</returns>	static public T GetAsset<T>(string name)	{		if (!Assets.ContainsKey(typeof(T)))			throw new ArgumentException("Unknown asset type");		return Assets[typeof(T)].Get<T>(name);	}	/// <summary>	/// Flush all unused assets	/// </summary>	static public void FlushAssets()	{		foreach (Provider provider in Providers)			provider.Flush();	}	/// <summary>	/// Flush a specified asset type	/// </summary>	/// <typeparam name="T"></typeparam>	static public void FlushAsset<T>()	{		Provider provider = GetAssetProvider(typeof(T));		if (provider == null)			return;		provider.Flush<T>();	}	/// <summary>	/// Removes all assets	/// </summary>	static public void ClearAssets()	{		foreach (Provider provider in Providers)			provider.Clear();	}	/// <summary>	/// Removes a specific asset	/// </summary>	/// <typeparam name="T"></typeparam>	static public void ClearAsset<T>()	{		Provider provider = GetAssetProvider(typeof(T));		if (provider == null)			return;		provider.Clear<T>();	}}

/// <summary>/// Provider interface /// </summary>public abstract class Provider{		#region Asset management		/// <summary>		/// Creates an asset		/// </summary>		/// <typeparam name="T">Asset type</typeparam>		/// <param name="name">Name of the asset</param>		/// <returns></returns>		public abstract T Create<T>(string name);		/// <summary>		/// Returns an asset		/// </summary>		/// <typeparam name="T">Type of the asset</typeparam>		/// <param name="name">Name of the asset</param>		/// <returns></returns>		public abstract T Get<T>(string name);		/// <summary>		/// Returns a list of available assets		/// </summary>		/// <typeparam name="T">Asset type</typeparam>		/// <returns>List of available assets</returns>		public abstract List<string> GetAssets<T>();		/// <summary>		/// Delete a specific asset		/// </summary>		/// <typeparam name="T"></typeparam>		public abstract void Remove<T>(string name);		/// <summary>		/// Flush unused assets		/// </summary>		/// <typeparam name="T"></typeparam>		public abstract void Flush<T>();		/// <summary>		/// Flush all unsued assets		/// </summary>		public abstract void Flush();		/// <summary>		/// Erases a specific asset type		/// </summary>		public abstract void Clear<T>();		/// <summary>		/// Erases all assets		/// </summary>		public abstract void Clear();		#endregion		/// <summary>		/// Checks if <paramref name="T"/> is a registred asset type, and <paramref name="name"/> is not null or empty		/// </summary>		/// <typeparam name="T">Type to check</typeparam>		/// <param name="name"><c>string</c> to check</param>		protected void CheckValue<T>(string name)		{			if (string.IsNullOrEmpty(name))				throw new ArgumentNullException("name");			foreach (Type type in Assets)			{				if (type == typeof(T))					return;			}			throw new ArgumentException("Unknown asset type", "T");		}		#region IO routines		/// <summary>		/// Saves assets to a xml file		/// </summary>		/// <returns></returns>		public abstract  bool Save(XmlWriter xml);		/// <summary>		/// Loads assets from a xml node		/// </summary>		public abstract bool Load(XmlNode xml);		#endregion		#region Properties		/// <summary>		/// Display name of the asset		/// </summary>		/// <remarks>This is also used in the bank file as the name of the directory asset</remarks>		public abstract string Name { get; }		/// <summary>		/// Handled XML tags		/// </summary>		public abstract string[] Tags { get; }		/// <summary>		/// Managed assets types		/// </summary>		public abstract Type[] Assets { get; }		#endregion	}

/// <summary>/// Tileset provider/// </summary>public class TileSetProvider : Provider{	/// <summary>	/// Constructor	/// </summary>	public TileSetProvider()	{		TileSets = new Dictionary<string, TileSet>();	}	#region IO routines	/// <summary>	/// Saves all scripts	/// </summary>	/// <returns></returns>	public override bool Save(XmlWriter xml)	{		foreach (TileSet tileset in TileSets.Values)			tileset.Save(xml);		return true;	}	/// <summary>	/// Loads a script	/// </summary>	/// <param name="xml"></param>	/// <returns></returns>	public override bool Load(XmlNode xml)	{		switch (xml.Name.ToLower())		{			case "tileset":			{				string name = xml.Attributes["name"].Value;				TileSet tileset = Create<TileSet>(name);				if (tileset != null)					tileset.Load(xml);			}			break;			default:			{			}			break;		}		return true;	}	#endregion	/// <summary>	/// Returns an array of all available Tilesets	/// </summary>	/// <returns>Script's name array</returns>	public override List<string> GetAssets<T>()	{		List<string> list = new List<string>();		foreach (string key in TileSets.Keys)		{			list.Add(key);		}		list.Sort();		return list;	}	/// <summary>	/// Creates a TileSet	/// </summary>	/// <typeparam name="T"></typeparam>	/// <param name="name"></param>	/// <returns></returns>	public override T Create<T>(string name)	{		CheckValue<T>(name);		if (TileSets.ContainsKey(name))			throw new ArgumentException("TileSet already exists", name);		// Creates a Texture		TileSet tileset = new TileSet(name);		TileSets.Add(name, tileset);		return (T)(object)tileset;	}	/// <summary>	/// Returns a <c>Script</c>	/// </summary>	/// <typeparam name="T">Type of the asset</typeparam>	/// <param name="name">Asset's name</param>	/// <returns></returns>	public override T Get<T>(string name)	{		CheckValue<T>(name);		if (!TileSets.ContainsKey(name))			return default(T);		return (T)(object)TileSets[name];	}	/// <summary>	/// Flush unused scripts	/// </summary>	/// <typeparam name="T"></typeparam>	public override void Flush<T>()	{	}	/// <summary>	/// Flush all unsused assets	/// </summary>	public override void Flush()	{	}	/// <summary>	/// Removes a script	/// </summary>	/// <typeparam name="T"></typeparam>	/// <param name="name"></param>	public override void Remove<T>(string name)	{	}	/// <summary>	/// Removes all assets	/// </summary>	public override void Clear()	{	}	/// <summary>	/// Removes all specific asset type	/// </summary>	public override void Clear<T>()	{	}	#region Progerties	/// <summary>	/// Name of the asset	/// </summary>	public override string Name	{		get		{			return "Tileset";		}	}	/// <summary>	/// Scripts	/// </summary>	Dictionary<string, TileSet> TileSets;	/// <summary>	/// Handled tags	/// </summary>	public override string[] Tags	{		get		{			return new string[] { "tileset" };		}	}	/// <summary>	/// Managed assets	/// </summary>	public override Type[] Assets	{		get		{			return new Type[] { typeof(TileSet) };		}	}	#endregion}

	//  class TileSetPrivder is derived from Provider interface	ResourceManager.AddProvider(new TileSetProvider());	// Loads some datas	ResourceManager.LoadBank("data.bnk");		// Gets the tileset by its name	TileSet tiles = ResourceManager.GetAsset<TileSet>("tileset");