void Scene::unlink( Object* child ) { switch( child->m_feature ) { case Object::Feature: break; case Entity::Feature: removeEntity( (Entity*)child ); break; case Camera::Feature: removeEntity( (Entity*)child ); removeCamera( (Camera*)child ); break; /*case Element::Light: break;*/ default: MAGICAL_ASSERT( false, "Invalid!" ); break; } for( auto itr : child->m_children ) { unlink( itr ); } }
void Mainscene::reset(){ for(unsigned int i = 0; i < towers.size(); i++){ removeEntity(towers[i]); delete towers[i]; towers[i] = NULL; } towers.clear(); for(unsigned int i = 0; i < enemies.size(); i ++){ removeEntity(enemies[i]); delete enemies[i]; enemies[i] = NULL; } enemies.clear(); for(unsigned int i = 0; i < bullets.size(); i ++){ removeEntity(bullets[i]); delete bullets[i]; bullets[i] = NULL; } bullets.clear(); lockedItem = NULL; dreamHealth = 100; coins = 100; wave = 0; enemiesToSpawn = 10; waveEnd = true; }
/** * Implementation of update. Updates the arrow. */ void RS_Leader::update() { // find and delete arrow: for(auto e: entities){ if (e->rtti()==RS2::EntitySolid) { removeEntity(e); break; } } if (isUndone()) { return; } RS_Entity* fe = firstEntity(); if (fe && fe->isAtomic()) { RS_Vector p1 = ((RS_AtomicEntity*)fe)->getStartpoint(); RS_Vector p2 = ((RS_AtomicEntity*)fe)->getEndpoint(); // first entity must be the line which gets the arrow: if (hasArrowHead()) { RS_Solid* s = new RS_Solid(this, RS_SolidData()); s->shapeArrow(p1, p2.angleTo(p1), getGraphicVariableDouble("$DIMASZ", 2.5)* getGraphicVariableDouble("$DIMSCALE", 1.0)); s->setPen(RS_Pen(RS2::FlagInvalid)); s->setLayer(nullptr); RS_EntityContainer::addEntity(s); } } calculateBorders(); }
bool Map::removePlayer (ClientId clientId) { assert(_entityRemovalAllowed); for (PlayerListIter i = _playersWaitingForSpawn.begin(); i != _playersWaitingForSpawn.end(); ++i) { if ((*i)->getClientId() != clientId) continue; (*i)->remove(); delete *i; _playersWaitingForSpawn.erase(i); sendPlayersList(); return true; } for (PlayerListIter i = _players.begin(); i != _players.end(); ++i) { if ((*i)->getClientId() != clientId) continue; removeEntity(0, **i); (*i)->remove(); delete *i; _players.erase(i); return true; } error(LOG_MAP, String::format("could not find the player with the clientId %i", clientId)); return false; }
void Scene::deleteSprite(Sprite **sprite) { removeCollisionSprite(*sprite); removeSurface((*sprite)->getSurface()); removeEntity(*sprite); delete *sprite; *sprite = NULL; }
/** * Removes invalid objects. * @return how many objects were removed */ int RS_Graphic::clean() { // author: ravas int how_many = 0; foreach (RS_Entity* e, entities) { if (e->getMin().x > e->getMax().x || e->getMin().y > e->getMax().y || e->getMin().x > RS_MAXDOUBLE || e->getMax().x > RS_MAXDOUBLE || e->getMin().x < RS_MINDOUBLE || e->getMax().x < RS_MINDOUBLE || e->getMin().y > RS_MAXDOUBLE || e->getMax().y > RS_MAXDOUBLE || e->getMin().y < RS_MINDOUBLE || e->getMax().y < RS_MINDOUBLE) { removeEntity(e); how_many += 1; } } return how_many; }
/** * Implementation of update. Updates the arrow. */ void RS_Leader::update() { // find and delete arrow: for (RS_Entity* e=firstEntity(); e!=NULL; e=nextEntity()) { if (e->rtti()==RS2::EntitySolid) { removeEntity(e); break; } } if (isUndone()) { setVisible(false); return; } RS_Entity* fe = firstEntity(); if (fe!=NULL && fe->isAtomic()) { RS_Vector p1 = ((RS_AtomicEntity*)fe)->getStartpoint(); RS_Vector p2 = ((RS_AtomicEntity*)fe)->getEndpoint(); // first entity must be the line which gets the arrow: if (hasArrowHead()) { RS_Solid* s = new RS_Solid(this, RS_SolidData()); s->shapeArrow(p1, p2.angleTo(p1), getGraphicVariableDouble("$DIMASZ", 2.5)); s->setPen(RS_Pen(RS2::FlagInvalid)); s->setLayer(NULL); RS_EntityContainer::addEntity(s); } } }
TEST(LuaUIOperationsTest, Rotate) { QApplication app(argc, argv); LuaInterface luaInterface; auto L = luaInterface.luaState(); luaInterface.hideUI(true); luaInterface.initLua(); auto mdiArea = LuaIntf::Lua::getGlobal<QMdiArea*>(L, "mdiArea"); if(mdiArea->subWindowList().count() == 0) { LuaIntf::LuaRef(L, "new_file")(); } mdiArea->setActiveSubWindow(mdiArea->subWindowList().at(0)); auto mdiChild = dynamic_cast<CadMdiChild*>(mdiArea->activeSubWindow()->widget()); auto storageManager = mdiChild->storageManager(); auto documentCanvas = mdiChild->viewer()->documentCanvas(); lc::entity::Line_CSPtr createdEntity; std::vector<lc::entity::CADEntity_CSPtr> entities; entities = storageManager->entityContainer().asVector(); for(auto entity : entities) { storageManager->removeEntity(entity); } EXPECT_EQ(0, storageManager->entityContainer().asVector().size()); LuaIntf::LuaRef(L, "create_line")(); LuaIntf::LuaRef(L, "event.trigger")("point", lc::geo::Coordinate(0, 0)); LuaIntf::LuaRef(L, "event.trigger")("point", lc::geo::Coordinate(100, 100)); EXPECT_EQ(1, storageManager->entityContainer().asVector().size()) << "Line was not created"; documentCanvas->makeSelection(0, 0, 100, 100, false, false); documentCanvas->closeSelection(); EXPECT_EQ(1, mdiChild->selection().size()) << "Entity not selected"; LuaIntf::LuaRef(L, "rotate_selected_entities")(); LuaIntf::LuaRef(L, "event.trigger")("point", lc::geo::Coordinate(0, 0)); LuaIntf::LuaRef(L, "event.trigger")("point", lc::geo::Coordinate(0, 100)); LuaIntf::LuaRef(L, "event.trigger")("point", lc::geo::Coordinate(100, 0)); entities = storageManager->entityContainer().asVector(); createdEntity = std::dynamic_pointer_cast<const lc::entity::Line>(entities.at(0)); EXPECT_EQ(lc::geo::Coordinate(0, 0), createdEntity->start()); EXPECT_EQ(lc::geo::Coordinate(100, -100), createdEntity->end()); }
void EntityManager::removeAllEntities() { EntityArray tmp(entities_); EntityArray::iterator it = tmp.begin(); for (; it != tmp.end(); ++it) { removeEntity(*it); } }
////////////////////////////////////////////////////////////////////////// // removeAllEntities void ScnCore::removeAllEntities() { for( ScnEntityListIterator It( EntityList_.begin() ); It != EntityList_.end(); ++It ) { ScnEntityRef Entity( *It ); removeEntity( Entity ); } }
void IfcPPModel::removeEntity( int entity_id ) { auto it_find = m_map_entities.find(entity_id); if( it_find != m_map_entities.end() ) { shared_ptr<IfcPPEntity> entity_found = it_find->second; removeEntity( entity_found ); } }
bool Scene::removePlayer(AvatarID avatarID) { auto entity = getEntityByAvatarID(avatarID); if (entity) { return removeEntity(entity->_state.eid); } return false; }
void CHUD_Radar::setSubject(ILocalEntity * entity) { m_subject = entity; // L'entité ne peut pas être dans la liste des entités suivies if (isEntity(m_subject)) { removeEntity(m_subject); } }
void Map::visitEntities (IEntityVisitor *visitor, const EntityType& type) { if (type == EntityType::NONE || type == EntityTypes::PLAYER) { bool needUpdate = false; for (PlayerListIter i = _players.begin(); i != _players.end();) { Player* e = *i; if (visitor->visitEntity(e)) { debug(LOG_SERVER, String::format("remove player by visit %i: %s", e->getID(), e->getType().name.c_str())); removeEntity(ClientIdToClientMask(e->getClientId()), *e); delete *i; i = _players.erase(i); needUpdate = true; } else { ++i; } } if (needUpdate) { if (_players.empty()) { resetCurrentMap(); return; } } } // changing the entities list is not allowed here. Adding or removing // would invalidate the iterators for (Map::EntityListIter i = _entities.begin(); i != _entities.end();) { IEntity* e = *i; if (type.isNone() || e->getType() == type) { if (visitor->visitEntity(e)) { debug(LOG_SERVER, String::format("remove entity by visit %i: %s", e->getID(), e->getType().name.c_str())); removeEntity(0, *e); (*i)->remove(); delete *i; i = _entities.erase(i); } else { ++i; } } else { ++i; } } }
void GameEntitySystem::removeDeadEntities() { std::list<int>::iterator listIterator; for(listIterator = deadList->begin(); listIterator != deadList->end(); ++listIterator) { removeEntity((*listIterator)); } deadList->clear(); }
void EntityEngine::removeEntity(Entity * ent, Engines & e) { // find the pointer auto it = std::find(getEntities().begin(), getEntities().end(), ent); if (it == getEntities().end()) { logging::Fatal() << "Could not find entity to remove in entity list"; } else { removeEntity(it, e); } }
void Level::tick() { trySpawn(1); int tilesTickAttempts = w * h / 50; for (int i = 0; i < tilesTickAttempts; ++i) { int xt = random->nextInt(w); int yt = random->nextInt(h); getTile(xt, yt)->tick(this, xt, yt); } for (list<Entity*>::iterator it = entities.begin(); it != entities.end(); it++ ) { Entity * e = *it; int xto = e->x >> 4; int yto = e->y >> 4; e->tick(); if (e->removed) { removeEntity(xto, yto, e); //we should not delete player, because it will freeze on death //we should not delete furniture, because it is used in FurnitureItem, when taken if (!e->instanceOf(PLAYER) && !e->instanceOf(FURNITURE)) delete e; it = entities.erase(it); } else { int xt = e->x >> 4; int yt = e->y >> 4; if (xto != xt || yto != yt) { removeEntity(xto, yto, e); insertEntity(xt, yt, e); } } } }
void Mainscene::removeBullet(Bullet* b){ std::vector< Bullet* >::iterator it = bullets.begin(); while (it != bullets.end()) { if ((*it)->getEntityId() == b->getEntityId()) { removeEntity((*it)); delete (*it); (*it) = NULL; it = bullets.erase(it); } else { ++it; } } }
void Mainscene::removeCloud(SimpleEntity* e){ std::vector< SimpleEntity* >::iterator it = clouds.begin(); while (it != clouds.end()) { if ((*it)->getEntityId() == e->getEntityId()) { removeEntity((*it)); delete (*it); (*it) = NULL; it = clouds.erase(it); }else { ++it; } } }
void Mainscene::removeEnemy(Enemy* e){ std::vector< Enemy* >::iterator it = enemies.begin(); while (it != enemies.end()) { if ((*it)->getEntityId() == e->getEntityId()) { removeEntity((*it)); delete (*it); (*it) = NULL; it = enemies.erase(it); }else { ++it; } } }
void Mainscene::removeTwinkle(Particle* p){ std::vector< Particle* >::iterator it = twinkles.begin(); while (it != twinkles.end()) { if ((*it)->getEntityId() == p->getEntityId()) { removeEntity((*it)); delete (*it); (*it) = NULL; it = twinkles.erase(it); }else { ++it; } } }
void Level::remove(Entity * e) { entities.remove(e); // for (list<Entity*>::iterator it = entities.begin(); it != entities.end(); it++ ) // { // if (*it == e) // { // entities.erase(it); // break; // } // } int xto = e->x >> 4; int yto = e->y >> 4; removeEntity(xto, yto, e); }
void Scene::update() { for ( std::list<Entity*>::iterator it = _entities.begin(); it != _entities.end(); it++ ) { (*it)->update(); } // Deletes entities pushed into _deleteEntities list for ( std::list<Entity*>::iterator it = _deleteEntities.begin(); it!= _deleteEntities.end(); it++) { removeEntity( (*it) ); } _deleteEntities.clear(); }
bool Scene::removePlayerByGroupID(GroupID groupID) { std::set<EntityID> removes; for (auto entity : _entitys) { if (entity.second->_state.etype == ENTITY_PLAYER && entity.second->_state.groupID == groupID) { removes.insert(entity.second->_state.eid); } } for (auto eid : removes) { removeEntity(eid); } return true; }
/** * Removes the last vertex of this polyline. */ void RS_Polyline::removeLastVertex() { RS_Entity* last = lastEntity(); if (last!=NULL) { removeEntity(last); last = lastEntity(); if (last!=NULL) { if (last->isAtomic()) { data.endpoint = ((RS_AtomicEntity*)last)->getEndpoint(); } else { RS_DEBUG->print(RS_Debug::D_WARNING, "RS_Polyline::removeLastVertex: " "polyline contains non-atomic entity"); } } } }
void gep::HavokWorld::removeCharacter(ICharacterRigidBody* character) { GEP_ASSERT(character != nullptr); size_t index; for (index = 0; index < m_characters.length(); ++index) { auto& characterPtr = m_characters[index]; if (characterPtr.get() == character) { break; } } GEP_ASSERT(index < m_characters.length(), "Attempt to remove character from world that does not exist there", character, index, m_characters.length()); m_characters.removeAtIndex(index); removeEntity(character->getRigidBody()); }
Scene::~Scene() { _vm->_screen->setSmackerDecoder(NULL); if (_palette) { removeEntity(_palette); delete _palette; } // Delete all entities for (Common::Array<Entity*>::iterator iter = _entities.begin(); iter != _entities.end(); iter++) delete *iter; // Don't delete surfaces since they always belong to an entity // Purge the resources after each scene _vm->_res->purgeResources(); }
/** * Ends polyline and adds the last entity if the polyline is closed */ void RS_Polyline::endPolyline() { RS_DEBUG->print("RS_Polyline::endPolyline"); if (isClosed()) { RS_DEBUG->print("RS_Polyline::endPolyline: adding closing entity"); // remove old closing entity: if (closingEntity!=NULL) { removeEntity(closingEntity); } // add closing entity to the polyline: closingEntity = createVertex(data.startpoint, nextBulge); if (closingEntity!=NULL) { RS_EntityContainer::addEntity(closingEntity); //data.endpoint = data.startpoint; } } }
void RenderBoxWrap::removeNode(Ogre::SceneNode* _node) { //System::Console::WriteLine("remove node {0}", gcnew System::String(_node->getName().c_str())); while(_node->numAttachedObjects() != 0) { Ogre::MovableObject* object = _node->getAttachedObject(0); removeEntity(object->getName()); } while (_node->numChildren() != 0) { Ogre::SceneNode* forDelete = (Ogre::SceneNode*)_node->getChild(0); removeNode(forDelete); } _node->getParentSceneNode()->removeAndDestroyChild(_node->getName()); }
void Scene1608::upUpperFloor() { Scene::update(); if (_carStatus == 1) { removeSurface(_klaymen->getSurface()); removeEntity(_klaymen); addSprite(_asCar); _klaymenInCar = true; clearRectList(); SetUpdateHandler(&Scene1608::upCarAtHome); SetMessageHandler(&Scene1608::hmCarAtHome); _asIdleCarLower->setVisible(false); _asIdleCarFull->setVisible(false); _asCar->setVisible(true); sendMessage(_asCar, 0x2009, 0); _asCar->handleUpdate(); _klaymen = NULL; _carStatus = 0; } updateKlaymenCliprect(); }