Example #1
0
CPhysicsSystem::CPhysicsSystem(entityx::ptr<entityx::EntityManager> em)
{
    //ctor
    emptr = (entityx::EntityManager*)em.get();


}
Example #2
0
			/**
			* This function will write into json file
			*/
			void JSONReader::update(entityx::ptr<entityx::EntityManager> es, entityx::ptr<entityx::EventManager> events, double dt)
			{
				entityx::ptr<Comp::File> file;
				entityx::ptr<Comp::Read> read;
				for (auto entity : es->entities_with_components(file, read))
				{
					rapidjson::Document doc;

					bool fileread = file->read();

					//we try to read
					if (fileread && file->getContents() != "")
					{
						doc.Parse<0>(file->getContents().c_str());
						if (doc.HasParseError()) {
							CCLOG("GetParseError %s\n", doc.GetParseError());
							//signal error
							events->emit<Events::Error>(entity, "JSONReader system file read error");
							//WHAT TO DO ?
						}
						//else everything is ok with this json file
					}
					else // read fail : lets create first content
					{
						doc.SetObject();
						rapidjson::StringBuffer strbuf;
						rapidjson::Writer<rapidjson::StringBuffer> writer(strbuf);
						doc.Accept(writer);
						file->setContents( strbuf.GetString());
						//CCLOG("new contents :  %s", file->getContents().c_str());
					}

					entity.remove<Comp::Read>();
				}
			}
Example #3
0
			/**
			* This function will call the callback with the current progress of the timer.
			*/
			void AlarmRinger::update(entityx::ptr<entityx::EntityManager> es, entityx::ptr<entityx::EventManager> events, double dt)
			{
				entityx::ptr<Comp::ID> id;
				entityx::ptr<Comp::Alarm> alarm;
				for (auto entity : es->entities_with_components(id, alarm))
				{
					time_t start = mktime(&alarm->m_end);
					time_t nowtime = mktime(&alarm->m_now);
					// actually returns long long, despite double declaration
					double delta = difftime(start, nowtime); 
					if (delta < 0) // becomes true when delta is -1, this adds 1 sec to alarm length
					{
						events->emit<Events::AlarmOff>(entity);
					}
				}
			};
Example #4
0
Entity Factory::createBlock(entityx::ptr<entityx::EntityManager> entityMgr, int x, int y, int z, std::string material)
{
    Entity block = entityMgr->create();
    Ogre::SceneManager* sceneMgr = RenderManager::getPtr()->getSceneManager();
    Ogre::Entity* wall = sceneMgr->createEntity("Cube.mesh");
    wall->setMaterialName(material);
    Ogre::SceneNode* wallNode = sceneMgr->getRootSceneNode()->createChildSceneNode();

    wallNode->attachObject(wall);

    block.assign<Position>(x,y,z);
    wallNode->setPosition(x,y,z);
    block.assign<Orientation>(wallNode->getOrientation());
    block.assign<Renderable>(wallNode);
    block.assign<Name>("Block");
    if(material == "Wall"){
        block.assign<Destroyable>(200);
    }

    return block;
}
Example #5
0
			void Timer::update(entityx::ptr<entityx::EntityManager> entities, entityx::ptr<entityx::EventManager> events, double dt)
			{

				entityx::ptr<Comp::ServerTime> st;
				for (auto entity : entities->entities_with_components(st))
				{
					if (st->done)
					{
						entity.remove<Comp::ServerTime>();
						//if mask at 0 no request in this entity anymore
						if (entity.component_mask() == 0)
							entity.destroy();
					}
					else if (!st->in_progress)
					{
						m_timer_service->GetCurrentTimeNoWinBase(st->m_cb);
						st->in_progress = true;
					}
				}

			}
Example #6
0
entityx::Entity Factory::createProjectile(entityx::ptr<EntityManager> where, Ogre::Vector3 pos, Ogre::Quaternion ori, Ogre::Real velocity, std::string materialName)
{
    Ogre::Entity *projMesh;
    Ogre::SceneManager *sceneMgr = RenderManager::getPtr()->getSceneManager();

    projMesh = sceneMgr->createEntity("ProjectileMesh.mesh");
    projMesh->setMaterialName(materialName);

    Entity proj = where->create();

    Ogre::SceneNode *projNode = sceneMgr->getRootSceneNode()->createChildSceneNode();
    projNode->attachObject(projMesh);

    Ogre::Light *light = sceneMgr->createLight();
    if(materialName == "RedLaser")
        light->setDiffuseColour(Ogre::ColourValue(.8, .2, .2));
    else
        light->setDiffuseColour(Ogre::ColourValue(.2, .2, .8));

    light->setType(Ogre::Light::LT_POINT);
    projNode->attachObject(light);



    projNode->setPosition(pos);
    projNode->setOrientation(ori);

    //projNode->translate(0, 0, -2, Ogre::SceneNode::TS_LOCAL);

    proj.assign<Position>(projNode->getPosition());
    proj.assign<Orientation>(ori);

    proj.assign<Velocity>(0, 0, velocity);
    proj.component<Velocity>()->direction.z = -1;
    proj.assign<Renderable>(projNode);
    proj.assign<AngularVelocity>(0, 0, 10);
    proj.assign<Name>("proiettile");
    proj.assign<LightComponent>(light);
    return proj;
}
Example #7
0
			void DLCchecking::update(entityx::ptr<entityx::EntityManager> es, entityx::ptr<entityx::EventManager> events, double dt)
			{
				for (auto entity : es->entities_with_components<Comp::DataVerCheck>())
				{
					entityx::ptr<Comp::DataVerCheck> dllist = entity.component<Comp::DataVerCheck>();
					std::string url = dllist->m_url;

					if (!dllist->m_verlist.empty())
					{
						//we need to check if the version url is valid ( contains a manifest.json )
						url += "/" + dllist->m_verlist.back() + "/manifest.json";
						m_manifest = "";
						CCLOG("DLCchecking reading from %s", url.c_str());

						//list all files at given url
						CURLcode res;
						curl_easy_setopt(_curl, CURLOPT_URL, url.c_str());
#ifdef _DEBUG
						curl_easy_setopt(_curl, CURLOPT_VERBOSE, 1L);
#endif
						curl_easy_setopt(_curl, CURLOPT_WRITEFUNCTION, write_data);
						curl_easy_setopt(_curl, CURLOPT_WRITEDATA, &m_manifest);
						if (_connectionTimeout) curl_easy_setopt(_curl, CURLOPT_CONNECTTIMEOUT, _connectionTimeout);
						curl_easy_setopt(_curl, CURLOPT_NOSIGNAL, 1L);
						curl_easy_setopt(_curl, CURLOPT_LOW_SPEED_LIMIT, LOW_SPEED_LIMIT);
						curl_easy_setopt(_curl, CURLOPT_LOW_SPEED_TIME, LOW_SPEED_TIME);
						res = curl_easy_perform(_curl);

						CCLOG("DLCchecking read from %s", url.c_str());

						if (res != 0)
						{

							CCLOG("DLCchecking can not read from %s, error code is %d", url.c_str(), res);

							dllist->m_retries--;
							if (0 == dllist->m_retries)
							{
								CCLOGERROR("DLCchecking can not read from %s, error code is %d", url.c_str(), res);
								//signal error
								events->emit<Events::Error>(entity, "DLCchecking system");
								//we give up on this entity
								entity.destroy();
							}
						}
						else
						{
							//read the downloaded manifest to compare md5
							rapidjson::Document json;
							json.Parse<0>(m_manifest.c_str());
							if (json.HasParseError()) {
								CCLOG("GetParseError %s\n", json.GetParseError());
								//version will be removed from the list later.
							}
							else
							{
								//is it possible to update ?
								bool dlc_update_allowed = false;

								//do we need to update ?
								bool dlc_update_required = false;

								std::string version = cocostudio::DictionaryHelper::getInstance()->getStringValue_json(json, "version", "");
								if (version == dllist->m_current_version) //if we have the exact same string : developer update or current version hotfix.
								{
									dlc_update_required = true;
								}
								else if (version.length() > 0 )  //we need to compare string to find if the online version is more recent
								{
									unsigned long lver = 0;
									try {
										lver = ToolBox::stoul(version);
										CCLOG("DLC at %s has Manifest version %lu", url.c_str(), lver);
									}
									catch (std::out_of_range oor)
									{
										lver = 0; //disabling update if online version is too high ( developer version )
									}

									unsigned long lcver = 0;
									try {
										lcver = ToolBox::stoul(dllist->m_current_version);
										CCLOG("Local DLC has Manifest version %lu", url.c_str(), lcver);
									}
									catch (std::out_of_range oor)
									{
										lcver = LONG_MAX; // if local version is too high, update should have been done before
									}

									if (lver > lcver) //not == to prevent LONG_MAX == LONG_MAX
									{
										dlc_update_required = true;
									}
								}

								std::string minAppVersion = cocostudio::DictionaryHelper::getInstance()->getStringValue_json(json, "minAppVersion", "error");
								if (minAppVersion != "error" && dllist->m_current_minAppVersion != "" )
								{
									//CAREFUL HERE with version comparison
									std::vector<unsigned long> mav = splitVersion(minAppVersion);
									std::vector<unsigned long> cmav = splitVersion(dllist->m_current_minAppVersion);

									dlc_update_allowed = true;
									while ( mav.size() < cmav.size() )
									{
										mav.push_back(0);
									}
									for (unsigned int i = 0; i < cmav.size(); ++i)
									{
										if (mav.at(i) > cmav.at(i))
										{
											dlc_update_allowed = false; break;
										}
									}
								}//if we cannot read the minimum app version. we dont download. better safe than sorry.

								if (dlc_update_allowed && dlc_update_required)
								{

									//prepare the list of downloads
									const rapidjson::Value & assets = cocostudio::DictionaryHelper::getInstance()->getSubDictionary_json(json, "assets");

									for (rapidjson::Value::ConstMemberIterator m = assets.MemberonBegin(); m != assets.MemberonEnd(); ++m)
									{
										std::string filename = m->name.GetString();
										std::string filehash = cocostudio::DictionaryHelper::getInstance()->getStringValue_json(m->value, "md5", "error");

										//lowering filehash to be sure
										std::transform(filehash.begin(), filehash.end(), filehash.begin(), ::tolower);

										//std::cout << filename << " : " << filehash << std::endl;

										entityx::Entity newentity = es->create();
										newentity.assign<Comp::LocalFile>(filename);
										newentity.assign<Comp::RemoteMD5>(filehash);
										newentity.assign<Comp::RemoteFile>(dllist->m_url + "/" + dllist->m_verlist.back(), filename);
										
										newentity.assign<Comp::ProgressValue>(1);
									}


									//downloading only the last verison should always be enough ( avoiding too many downloads - keeping all data for one version in same place )
									//if (dllist->m_verlist.empty()) //if we checked all versions
									//{
									entity.remove<Comp::DataVerCheck>();
									//}

									//we dont need to do anything more with this entity
									entity.destroy();
								}

							}

							//remove the version checked from the list
							dllist->m_verlist.pop_back();
							//In case of error, we should check the next version in stack on next update.
							//If success this will not be done ( entity destroyed )
							//TODO : check behavior

						}

						//exit this loop. one per update is enough
						break;
			
					}
					else //no version left to check
					{
						//we dont need to do anything more with this entity
						entity.destroy();
					}
				}
			};
Example #8
0
Entity Factory::createTank(entityx::ptr<entityx::EntityManager> entityMgr, std::string prefix,Ogre::Real velocity,Ogre::Real angularVelocity ,Ogre::Vector3 overHating,int health,bool ai)
{
    DotSceneLoader loader;
    Ogre::SceneManager* sceneMgr = RenderManager::getPtr()->getSceneManager();

    loader.parseDotScene("tank.scene", "General", sceneMgr, 0, prefix);

    Ogre::SceneNode* ctl = sceneMgr->getSceneNode(prefix + "TankControl");
    Ogre::SceneNode* body = sceneMgr->getSceneNode(prefix + "TankBody");
    Ogre::SceneNode* turret = sceneMgr->getSceneNode(prefix + "TankTurret");
    Ogre::SceneNode* cannon = sceneMgr->getSceneNode(prefix +"TankCannon");

    Entity tankEmptyControl = entityMgr->create();
    Entity tankTurret = entityMgr->create();
    Entity tankBody = entityMgr->create();
    Entity tankCannon = entityMgr->create();

    tankEmptyControl.assign<Position>(ctl->getPosition());
    tankEmptyControl.assign<Orientation>(ctl->getOrientation());
    tankEmptyControl.assign<Velocity>(0, 0, velocity);
    tankEmptyControl.assign<AngularVelocity>(0, angularVelocity, 0);
    tankEmptyControl.assign<Renderable>(ctl);
    tankEmptyControl.assign<OverHeating>(overHating.x,overHating.y,overHating.z);
    tankEmptyControl.assign<Destroyable>(health,health);
    tankEmptyControl.assign<Collidable>();
    tankEmptyControl.assign<Name>(prefix);
    if(ai){
        tankEmptyControl.assign<AI>();
        Ogre::Entity *model = static_cast<Ogre::Entity*>(body->getAttachedObject(0));
        model->getSubEntity(1)->setMaterialName("Red");

        model = static_cast<Ogre::Entity*>(turret->getAttachedObject(0));
        model->getSubEntity(1)->setMaterialName("Red");

        model = static_cast<Ogre::Entity*>(cannon->getAttachedObject(0));
        model->getSubEntity(1)->setMaterialName("Red");

    }

    ptr<Children> child = tankEmptyControl.assign<Children>();
    child->children["body"] = tankBody;
    child->children["turret"] = tankTurret;
    //child->children.push_back(tankBody);
    //child->children.push_back(tankTurret);

    tankTurret.assign<Position>(turret->getPosition());
    tankTurret.assign<Orientation>(turret->getOrientation());
    tankTurret.assign<Renderable>(turret);
    child = tankTurret.assign<Children>();
    child->children["cannon"] = tankCannon;

    tankBody.assign<Position>(body->getPosition());
    tankBody.assign<Orientation>(body->getOrientation());
    tankBody.assign<Renderable>(body);

    tankCannon.assign<Position>(cannon->getPosition());
    tankCannon.assign<Renderable>(cannon);
    tankCannon.assign<Orientation>(cannon->getOrientation());


    ctl->scale(.35, .55, .35);
    return tankEmptyControl;
}
Example #9
0
			/**
			* This function will write into json file
			*/
			void JSONPlayerData::update(entityx::ptr<entityx::EntityManager> es, entityx::ptr<entityx::EventManager> events, double dt)
			{
				entityx::ptr<Comp::File> file;
				entityx::ptr<Comp::PlayerData_v1> playerData;
				for (auto entity : es->entities_with_components(file, playerData))
				{
					if (!entity.component<Comp::Read>())
					{
						rapidjson::Document doc;
						doc.Parse<0>(file->getContents().c_str());
						if (doc.HasParseError()) {
							CCLOG("GetParseError %s\n", doc.GetParseError());
							//callback empty on invalid json
							if (playerData->m_load_cb)
							{
								playerData->m_load_cb("");
							}
						}
						else if (playerData->m_load_cb) //if we want to load data
						{
							if (doc.HasMember(playerData->m_name.c_str()))
							{
								rapidjson::Value& playerdatavalue = doc[playerData->m_name.c_str()];
								//writing json structure in a string
								rapidjson::StringBuffer strbuf;
								rapidjson::Writer<rapidjson::StringBuffer> writer(strbuf);
								playerdatavalue.Accept(writer);
								//passing the string to the callback
								playerData->m_data = strbuf.GetString();
								playerData->m_load_cb(playerData->m_data);

							}
							else
							{
								playerData->m_load_cb("");
							}
						}
						else //write request
						{
							//clearing original saved data
							doc.SetObject();

							rapidjson::Document data;
							data.Parse<0>(playerData->m_data.c_str());
							if (data.HasParseError()) {
								CCLOG("GetParseError %s\n", data.GetParseError());
								//signal error
								events->emit<Events::Error>(entity, "JSONPlayerData system parse error");
								//WHAT TO DO ?
							}
							else
							{
								rapidjson::Value vholder;
								vholder.SetObject();
								for (auto dm = data.MemberonBegin(); dm != data.MemberonEnd(); ++dm)
								{
									vholder.AddMember(dm->name, dm->value, doc.GetAllocator());
								}
								doc.AddMember(playerData->m_name.c_str(), vholder, doc.GetAllocator());

								//TMP debug
								rapidjson::StringBuffer strbuf;
								rapidjson::Writer<rapidjson::StringBuffer> writer(strbuf);
								doc.Accept(writer);

								file->setContents( strbuf.GetString());
								//CCLOG("new contents :  %s", file->getContents().c_str());
							}
						}

						//we finished working with this component.
						entity.remove<Comp::PlayerData_v1>();
					}
				}
			};
Example #10
0
			/**
			* This function will write into json file
			*/
			void JSONLoginID::update(entityx::ptr<entityx::EntityManager> es, entityx::ptr<entityx::EventManager> events, double dt)
			{
				entityx::ptr<Comp::File> file;
				entityx::ptr<Comp::LoginID_v1> loginid;
				for (auto entity : es->entities_with_components(file, loginid))
				{
					if (!entity.component<Comp::Read>())
					{
						rapidjson::Document doc;
						doc.Parse<0>(file->getContents().c_str());
						
						if (loginid->m_load_cb)//if we want to load data
						{
							if (doc.HasParseError()) {
								CCLOG("GetParseError %s\n", doc.GetParseError());
								events->emit<Events::Error>(entity, "JSONLogin system parse error");
								loginid->m_load_cb("","");
							}
							else
							{
								rapidjson::Value& loginvalue = doc[loginid->m_name.c_str()];
								if (!loginvalue.IsNull()){
									if (loginvalue.HasMember("user"))
									{
										loginid->m_user = loginvalue["user"].GetString();
									}
									if (loginvalue.HasMember("passwd"))
									{
										loginid->m_passwd = loginvalue["passwd"].GetString();
									}
								}
								loginid->m_load_cb(loginid->m_user, loginid->m_passwd);
							}
						}
						else //write request
						{
							// must pass an allocator when the object may need to allocate memory
							rapidjson::Document::AllocatorType& allocator = doc.GetAllocator();

							if (!doc.HasParseError() && doc.HasMember(loginid->m_name.c_str()))
							{
								//if we already have a login value in the file, we need to replace it
								rapidjson::Value& vholder = doc[loginid->m_name.c_str()];
								if (vholder.HasMember("user"))
								{
									vholder["user"] = loginid->m_user.c_str();
								}
								if (vholder.HasMember("passwd"))
								{
									vholder["passwd"] = loginid->m_passwd.c_str();
								}
							}
							else
							{
								if (doc.HasParseError())
								{
									//CCLOG("GetParseError %s\n", doc.GetParseError());
									//no big deal we replace everything.
									doc.SetObject();
								}
								rapidjson::Value vholder;
								vholder.SetObject();
								vholder.AddMember("user", loginid->m_user.c_str(), allocator);
								vholder.AddMember("passwd", loginid->m_passwd.c_str(), allocator);
								doc.AddMember(loginid->m_name.c_str(), vholder, allocator);
							}
							
							//TMP debug
							rapidjson::StringBuffer strbuf;
							rapidjson::Writer<rapidjson::StringBuffer> writer(strbuf);
							doc.Accept(writer);

							file->setContents(strbuf.GetString());
							//CCLOG("new contents :  %s", file->getContents().c_str());
						}

						//we finished working with this component.
						entity.remove<Comp::LoginID_v1>();
					}
				}
			};
Example #11
0
            void DLCchecking::update(entityx::ptr<entityx::EntityManager> es, entityx::ptr<entityx::EventManager> events, double dt)
			{
				for (auto entity : es->entities_with_components<Comp::DataVerCheck>())
				{
					entityx::ptr<Comp::DataVerCheck> dllist = entity.component<Comp::DataVerCheck>();
					std::string url = dllist->m_url;

                    CCLOG("Comp::DataVerCheck detected for %s", url.c_str());
					if (!dllist->m_verlist.empty())
					{
						//order the list of versions ascendantly
						std::sort(dllist->m_verlist.begin(), dllist->m_verlist.end());
						//needed to make sure we should check from the last one first.

						//we need to check if the version url is valid ( contains a manifest.json )
						std::string manifest_path = "manifest.json";
						url += "/" + to_string(dllist->m_verlist.back()) + "/" + manifest_path;
						m_manifest = "";
						CCLOG("DLCchecking reading from %s", url.c_str());

						//list all files at given url
						CURLcode res;
						curl_easy_setopt(_curl, CURLOPT_URL, url.c_str());
#ifdef _DEBUG
						//curl_easy_setopt(_curl, CURLOPT_VERBOSE, 1L);
#endif
						curl_easy_setopt(_curl, CURLOPT_WRITEFUNCTION, write_data);
						curl_easy_setopt(_curl, CURLOPT_WRITEDATA, &m_manifest);
						if (_connectionTimeout) curl_easy_setopt(_curl, CURLOPT_CONNECTTIMEOUT, _connectionTimeout);
						curl_easy_setopt(_curl, CURLOPT_NOSIGNAL, 1L);
						curl_easy_setopt(_curl, CURLOPT_LOW_SPEED_LIMIT, LOW_SPEED_LIMIT);
						curl_easy_setopt(_curl, CURLOPT_LOW_SPEED_TIME, LOW_SPEED_TIME);
						res = curl_easy_perform(_curl);

						CCLOG("DLCchecking read from %s", url.c_str());

						if (res != 0)
						{

							CCLOG("DLCchecking can not read from %s, error code is %d", url.c_str(), res);

							dllist->m_retries--;
							if (0 == dllist->m_retries)
							{
								CCLOGERROR("DLCchecking can not read from %s, error code is %d", url.c_str(), res);
								//signal error
								events->emit<Events::Error>(entity, "DLCchecking system");
								//we give up on this entity
								entity.destroy();
							}
						}
						else
						{
							//read the downloaded manifest to compare versions
							rapidjson::Document json;
							json.Parse<0>(m_manifest.c_str());
							if (json.HasParseError()) {
								CCLOG("GetParseError %s\n", json.GetParseError());
								//version will be removed from the list later.
							}
							else
							{
								//is it possible to update ?
								bool dlc_update_allowed = false;

								//do we need to update ?
								bool dlc_update_required = false;

                                std::string minAppVersionstr = cocostudio::DictionaryHelper::getInstance()->getStringValue_json(json, "minAppVersion", "");
								std::string dataVersionstr = cocostudio::DictionaryHelper::getInstance()->getStringValue_json(json, "dataVersion", "");
								if ( minAppVersionstr != "" && dataVersionstr != "") //if we cannot read the version. we dont download. better safe than sorry.
								{
								    Version version(dataVersionstr);
								    Version maversion(minAppVersionstr);
								    //guarantee same major + minor version number
								    if (version[0] == dllist->m_current_dataVersion[0] && version[1] == dllist->m_current_dataVersion[1] )
                                    {
                                        if(dllist->m_current_dataVersion <= version) //if we have the exact same data version : developer update or current version hotfix.
                                        {
                                            dlc_update_required = true;
                                            if (maversion <= dllist->m_currentAppVersion) // instead of minAppVersion we could use the current app version name from APK
                                            {
                                                dlc_update_allowed = true;
                                            }
                                        }
                                    }
								} // ( version != "")

								if (dlc_update_required && dlc_update_allowed)
								{
								    //We found the advised download. we emit event and start downloading already.
								    events->emit<Events::DownloadAdvised>(dllist->m_url , dllist->m_verlist.back(), manifest_path , true);

									//prepare the list of downloads
									const rapidjson::Value & assets = cocostudio::DictionaryHelper::getInstance()->getSubDictionary_json(json, "assets");

									for (rapidjson::Value::ConstMemberIterator m = assets.MemberonBegin(); m != assets.MemberonEnd(); ++m)
									{
										std::string filename = m->name.GetString();
										std::string filehash = cocostudio::DictionaryHelper::getInstance()->getStringValue_json(m->value, "md5", "error");

										//lowering filehash to be sure
										std::transform(filehash.begin(), filehash.end(), filehash.begin(), ::tolower);

										//std::cout << filename << " : " << filehash << std::endl;

										entityx::Entity newentity = es->create();
										newentity.assign<Comp::LocalFile>(filename);
										newentity.assign<Comp::RemoteMD5>(filehash);
										newentity.assign<Comp::RemoteFile>(dllist->m_url + "/" + to_string(dllist->m_verlist.back()), filename);

										newentity.assign<Comp::ProgressValue>(1);
									}


									//downloading only the last version should always be enough ( avoiding too many downloads - keeping all data for one version in same place )
									//if (dllist->m_verlist.empty()) //if we checked all versions
									//{
									entity.remove<Comp::DataVerCheck>();
									//}

									//we dont need to do anything more with this entity
									//updating from the latest data url is enough.
									entity.destroy();
								}

							}

							//remove the version checked from the list
							dllist->m_verlist.pop_back();
							//In case of error, we should check the next version in stack on next update.
							//If success this will not be done ( entity destroyed )

						}

						//exit this loop. one per update is enough.
						//The remaining versions will be checked on next update.
						break;

					}
					else //no version left to check
					{
						//we dont need to do anything more with this entity
						entity.destroy();
					}
				}
			};