int CmdCast::execute() { int turns = 0; SpellPtr spell = getSpell(); Engine::instance().render(); Engine::instance().flush(); ActorPtr player = Engine::instance().getPlayer(); if ( spell ) { TargetSelectorPtr selector( TargetSelector::create( spell->getTargetType() ) ); if ( selector ) { selector->setRange( spell->getRange() ); selector->setRadius( spell->getRadius() ); MapPtr map = Engine::instance().getWorld().getCurrentMap(); Target target = selector->select([&](ActorPtr a){ return map->isInFov(a->getX(), a->getY()); }); if ( player->performAction( new CastAction(spell, target) ) != ActorActionResult::Ok ) { gui::msgBox("Failed to cast spell!", gui::MsgType::Warning); } } ++turns; } return turns; }
void ActorSet::load(const PropertyBag &objects, World *_world) { ASSERT(_world!=0, "world was null"); world = _world; for(size_t i=0, n=objects.getNumInstances("object"); i<n; ++i) { const tuple<OBJECT_ID, ActorPtr> t = create(); const ActorPtr object = t.get<1>(); const PropertyBag decl = objects.getBag("object", i); const FileName templateFile = decl.getFileName("template"); const vec3 initialPosition = decl.getVec3("position"); const PropertyBag templateData = PropertyBag::fromFile(templateFile); const PropertyBag base = templateData.getBag("components"); ComponentDataSet s = ComponentDataSet::load(base, decl); // get actor name object->actorName = "(no name)"; templateData.get("name", object->actorName); object->load(s, initialPosition, vec3(0,0,0), world); object->setParentBlackBoard(this); } }
void ComponentObjectApproachable::update(float) { ASSERT(world, "World has not been set yet"); const ActorSet &players = world->players; for (ActorSet::const_iterator i=players.begin(); i!=players.end(); ++i) { ActorPtr player = i->second; if (player->hasComponent("Physics")) { shared_ptr<Component> component; shared_ptr<ComponentPhysics> physics; component = player->getComponent("Physics"); physics = dynamic_pointer_cast<ComponentPhysics>(component); if (physics) { const float distance = vec3((physics->getPosition())-lastReportedPosition).getMagnitude(); const ActorID id = player->getUID(); if (distance <= thresholdTrigger) { playerApproaches(id); } else if (distance > thresholdRelease) { playerRecedes(id); } } } } }
//---------------------------------------------------------------------------- void EditMap::CreateSphere (PX2::APoint pos) { PX2::Texture2D *tex = DynamicCast<PX2::Texture2D>( ResourceManager::GetSingleton().BlockLoad("ToolRes/images/default.png")); if (!tex) return; StandardMesh stdMesh(mVertexFormat); TriMesh *mesh = stdMesh.Sphere(16, 16, 1); mesh->SetName("NoName"); Texture2DMaterialPtr material = new0 Texture2DMaterial; mesh->SetMaterialInstance(material->CreateInstance(tex)); ActorPtr actor = new0 Actor(); actor->SetName("NoName"); actor->SetMovable(mesh); actor->SetPosition(pos); actor->ComeInToEventWorld(); AddActor(actor); Event *event = 0; event = EditorEventSpace::CreateEventX (EditorEventSpace::AddActor); event->SetData<Actor*>(actor); EventWorld::GetSingleton().BroadcastingLocalEvent(event); ActorAddDeleteCommand *command = new0 ActorAddDeleteCommand(actor); EditSystem::GetSingleton().GetCM()->PushUnDo(command); }
//---------------------------------------------------------------------------- void EditMap::CreateSphere (PX2::APoint pos) { PX2::Texture2D *tex = DynamicCast<PX2::Texture2D>( ResourceManager::GetSingleton().BlockLoad("ToolRes/images/default.png")); if (!tex) return; StandardMesh stdMesh(mVertexFormat); TriMesh *mesh = stdMesh.Sphere(16, 16, 1); mesh->SetName("NoName"); //Texture2DMaterialPtr material = new0 Texture2DMaterial; //mesh->SetMaterialInstance(material->CreateInstance(tex)); StandardESMaterial_DefaultPtr mtl = new0 StandardESMaterial_Default(); mesh->SetMaterialInstance(mtl->CreateInstance(tex, 0 ,0)); ActorPtr actor = new0 Actor(); actor->SetName("NoName"); actor->SetMovable(mesh); actor->SetPosition(pos); actor->ComeInToEventWorld(); AddActor(actor); ActorAddDeleteCommand *command = new0 ActorAddDeleteCommand(actor); EditSystem::GetSingleton().GetCM()->PushUnDo(command); }
void CmdClose::execute() { Target target = SingleNeighbourSelector("Select object to close...") .select(); auto openableIter = std::find_if(target.actors.begin(), target.actors.end(), [](ActorPtr a) { return a->getFeature<Openable>(); }); ActorPtr toClose = openableIter != target.actors.end() ? *openableIter : nullptr; if ( toClose != nullptr) { if ( target.actors.size() == 1 ) { Actor::Player->performAction( std::make_shared<CloseAction>(toClose) ); } else { gui::msgBox("Cannot close " + tolowers(toClose->getName())+":\n" "It is blocked!", gui::MsgType::Warning); } } else { gui::msgBox("Nothing to close there.", gui::MsgType::Warning); } }
int CmdUseSkill::execute() { int turns(0); if ( SkillPtr skill = getSkill() ) { Engine::instance().render(); Engine::instance().flush(); ActorPtr player = Engine::instance().getPlayer(); TargetSelectorPtr selector( TargetSelector::create( skill->getTargetType() ) ); if ( selector ) { selector->setRadius( skill->getRadius() ); MapPtr map = Engine::instance().getWorld().getCurrentMap(); ActorActionPtr action( new UseSkillAction(skill, selector->select([&](ActorPtr a){ return map->isInFov(a->getX(), a->getY()); })) ); if ( player->performAction( action ) != ActorActionResult::Ok ) { gui::msgBox(skill->getName() + " failed!", gui::MsgType::Warning); } ++turns; } } return turns; }
AnimationPtr ModelActorFactory::CreateAnimation( Actor& rootActor, const ModelAnimationMap* animationData, AlphaFunction alpha, float durationSeconds) { DALI_LOG_TRACE_METHOD(Debug::Filter::gModel); AnimationPtr animation(Animation::New(durationSeconds)); animation->SetDefaultAlphaFunction(alpha); for(EntityAnimatorMapIter it = animationData->animators.begin(); it != animationData->animators.end(); ++it) { const EntityAnimatorMap& entityAnimator(*it); // find actor for this animator ActorPtr animatedActor = rootActor.FindChildByName(entityAnimator.GetEntityName()); if (!animatedActor) { // If we can't find the actor, it may not have been instantiated, may // be a sibling or parent of rootActor or may have been removed. continue; } Dali::Actor targetActor(animatedActor.Get()); Dali::KeyFrames posKFHandle = entityAnimator.GetPositionKeyFrames(); if(posKFHandle) { const KeyFrames& positionKeyFrames = GetImplementation(posKFHandle); if(positionKeyFrames.GetKeyFramesBase()->GetNumberOfKeyFrames() > 0) { animation->AnimateBetween(Property(targetActor, Dali::Actor::POSITION), positionKeyFrames, alpha, durationSeconds); } } Dali::KeyFrames scaleKFHandle = entityAnimator.GetScaleKeyFrames(); if(scaleKFHandle) { const KeyFrames& scaleKeyFrames = GetImplementation(scaleKFHandle); if(scaleKeyFrames.GetKeyFramesBase()->GetNumberOfKeyFrames() > 0) { animation->AnimateBetween(Property(targetActor, Dali::Actor::SCALE), scaleKeyFrames, alpha, durationSeconds); } } Dali::KeyFrames rotationKFHandle = entityAnimator.GetRotationKeyFrames(); if(rotationKFHandle) { const KeyFrames& rotationKeyFrames = GetImplementation(rotationKFHandle); if(rotationKeyFrames.GetKeyFramesBase()->GetNumberOfKeyFrames() > 0) { animation->AnimateBetween(Property(targetActor, Dali::Actor::ROTATION), rotationKeyFrames, alpha, durationSeconds); } } } return animation; }
bool Openable::unlock() { ActorPtr actor = getOwner().lock(); if ( actor ) { actor->notify(Event(EventId::Actor_Unlocked)); } _locked = false; return !_locked; }
CInstance::ActorPtr CInstance::RemoveActor(uint32 actorId) { ActorPtr result; auto actorIterator = m_actors.find(actorId); assert(actorIterator != std::end(m_actors)); result = std::move(actorIterator->second); result->SetInstance(nullptr); m_actors.erase(actorIterator); return std::move(result); }
bool Openable::lock() { ActorPtr actor = getOwner().lock(); if ( actor ) { actor->notify(Event(EventId::Actor_Locked)); } _locked = true; return _locked; }
tuple<OBJECT_ID, ActorPtr> ActorSet::create() { ActorFactory &factory = getActorFactory(); const tuple<OBJECT_ID, ActorPtr> t = factory.create(); const OBJECT_ID id = t.get<0>(); const ActorPtr actor = t.get<1>(); actors.insert(make_pair(id, actor)); // record it in this actor set registerSubscriber(actor); // record it in the blackboard actor->setParentBlackBoard(this); return t; }
TEST_F(MapTest, addActor) { MapPtr map = mapGateway.fetch(MapId::GameStart); ActorPtr actor = Actor::create(ActorType::HealthPotion,1,1); map->addActor(actor); auto actors = map->getActors(1,1); EXPECT_EQ(actors.size(), (size_t)1); EXPECT_TRUE( actors.front().get() == actor.get() ); }
bool Openable::applyState(const OpenableState& state) { ActorPtr owner = getOwner().lock(); if ( owner ) { owner->setSymbol( state.symbol ); owner->setTransparent( state.transparent ); owner->setBlocking( state.blocks ); return true; } return false; }
void ActorSet::_spawn(const SpawnRequest &spawnData) { const ComponentDataSet &data = spawnData.get<0>(); const vec3 &position = spawnData.get<1>(); const vec3 &velocity = spawnData.get<2>(); const tuple<OBJECT_ID, ActorPtr> t = create(); const ActorPtr object = t.get<1>(); object->load(data, position, velocity, world); object->enableDebugRendering(displayDebugRendering); }
void Character::setHitPoints(int newHp) { _hitPoints = newHp; if ( _hitPoints <= 0 ) { ActorPtr owner = getOwner().lock(); if ( owner ) { owner->performAction( std::make_shared<DieAction>() ); } } }
void ActorManager::DestroyActor(Actor::Id id) { if (mActors.count(id)) { ActorPtr actor = mActors[id]; actor->ClearComponents(); // move to pool mActors.erase(id); mPool.AddObject(actor); } else THROW_ERROR("Unknown actor id " + id); }
bool PassNode::addChild(ActorPtr child) { auto i = mActorNodes.find(child->getId()); if (i != mActorNodes.end()) return false; if (!child->getParent().expired()) child->mpParent = WeakActorPtr(); mActorNodes[child->getId()] = child; return true; }
DeathBehavior ComponentRenderAsModel::getDeathBehavior() const { DeathBehavior db = Disappear; ActorPtr actor = getActorPtr(); const ComponentDeathBehavior* c = dynamic_cast<const ComponentDeathBehavior*>(actor->getComponent("DeathBehavior")); if(c!=0) { db = c->getDeathBehavior(); } return db; }
void ActorSet::enableDebugRendering(bool enable) { for(iterator i = begin(); i!=end(); ++i) { ActorPtr actor = i->second; if(actor) { actor->enableDebugRendering(enable); } } displayDebugRendering = enable; }
DeathBehavior ComponentHealth::getDeathBehavior() const { ActorPtr actor = getActorPtr(); const ComponentDeathBehavior* c = dynamic_cast<const ComponentDeathBehavior*>(actor->getComponent("DeathBehavior")); if(c==0) { return Disappear; } else { return c->getDeathBehavior(); } }
void Actor::AddChild(ActorPtr child) { mChildren.emplace(child); child->mParent = this; // Force the child to compute their transform matrix child->ComputeWorldTransform(); }
BagManager::ItemOperation BagManager::chooseItemOperationFromMenu(ActorPtr selected) { MenuWindow& menu = Engine::instance().windowManager().getWindow<MenuWindow>(); menu.setTitle( selected->getName() ); menu.setPosition( gui::AWidget::WINDOW_CENTER ); if ( selected->getFeature<Pickable>()->isEquippable() ) { ALabelMenuItemPtr itemEquip( new ALabelMenuItem ); itemEquip->setValue("Equip"); itemEquip->setProperty<int>("operation", EQUIP); menu.addMenuItem( itemEquip ); } ALabelMenuItemPtr itemDrop( new ALabelMenuItem ); itemDrop->setValue("Drop"); itemDrop->setProperty<int>("operation", DROP); menu.addMenuItem( itemDrop ); ALabelMenuItemPtr itemInfo( new ALabelMenuItem ); itemInfo->setValue("Inspect"); itemInfo->setProperty<int>("operation", INSPECT); menu.addMenuItem( itemInfo ); menu.show(); AMenuItemPtr sItem = menu.getSelectedItem(); return sItem ? static_cast<ItemOperation>(sItem->getProperty<int>("operation")) : INVALID; }
ActorPtr ActorManager::CreateActor() { ActorPtr actor; // first try to obtain actor from pool actor = mPool.GetObject(); // if not possible, allocate new one if (!actor) { mLastId += 1; actor.reset(new Actor(mLastId)); } // add to map mActors[actor->GetId()] = actor; return actor; }
void ModelActorFactory::BindBonesToMeshActors(ActorPtr rootActor, ActorPtr actorPtr) { MeshActor* meshActor = dynamic_cast<MeshActor*>(actorPtr.Get()); if(meshActor) { meshActor->BindBonesToMesh(rootActor); } // Descend to all child actors, not just mesh actors const ActorContainer& children = actorPtr->GetChildren(); for ( ActorConstIter iter = children.begin(); iter != children.end(); ++iter) { ActorPtr childActor = const_cast<Actor*>(&GetImplementation(*iter)); BindBonesToMeshActors(rootActor, childActor); } }
bool MoveAction::perform(ActorPtr performer) { bool moved = false; _performer = performer; if ( _performer ) { int newX = performer->getX() + _dx; int newY = performer->getY() + _dy; MapPtr map = performer->getMap(); if ( map ) { moved = true; if ( newX < 0 ) { map->onExit(Direction::West, performer); } else if ( newX >= static_cast<int>(map->getWidth()) ) { map->onExit(Direction::East, performer); } else if ( newY < 0 ) { map->onExit(Direction::North, performer); } else if ( newY >= static_cast<int>(map->getHeight()) ) { map->onExit(Direction::South, performer); } else { if ( !patchIsBlocked() ) { performer->setPosition( newX, newY ); } else { moved = false; } } } } return moved; }
std::string Wearer::debug(const std::string &linebreak) { std::string d = " " + linebreak + "-----WEARER-----"+linebreak; for(auto slot : _itemSlots) { ActorPtr eq = equipped(slot.first); bool blocked = isBlocked(slot.first); PickablePtr p = eq ? eq->getFeature<Pickable>() : nullptr; d += ItemSlotType2Str(slot.first); d += ": " + (eq ? eq->getName() : "<none>") + (p ? " [" + toStr(p->getAmount()) + "]" : "" ) + ( blocked ? " [BLOCKED] " : "" ) + linebreak; } d.append("----------------"+linebreak); return d; }
void DieAction::dropOnGround(ActorPtr item) { MapPtr map = _performer->getMap(); if ( map != nullptr ) { item->setPosition( _performer->getX(), _performer->getY() ); map->addActor(item); } }
bool Openable::close(ActorPtr executor) { bool r = false; if ( !isClosed() ) { if ( applyState(_closedState) && executeScript("onClose", executor) ) { r = true; _closed = true; ActorPtr owner = getOwner().lock(); if ( owner ) owner->interract(executor); } } return r; }
void ActorSet::update(float deltaTime) { for(iterator i = begin(); i!=end(); ++i) { ActorPtr actor = i->second; if(actor) { actor->update(deltaTime); } } while(!spawnRequests.empty()) { _spawn(spawnRequests.front()); spawnRequests.pop(); } reapZombieActors(); }