bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e) { // Store the player for future reference m_PlayerEntities[e.PlayerID] = e.Player; m_PlayerIDs[e.Player.ID] = e.PlayerID; // When a player is actually spawned (since the actual spawning is handled on the server) // Hack should be moved. // TODO: Set the player name to whatever EntityWrapper playerName = e.Player.FirstChildByName("PlayerName"); if (playerName.Valid()) { playerName["Text"]["Content"] = e.PlayerName; } if (!IsClient) { return false; } // Set the camera to the correct entity EntityWrapper cameraEntity = e.Player.FirstChildByName("Camera"); bool outOfBodyExperience = ResourceManager::Load<ConfigFile>("Config.ini")->Get<bool>("Debug.OutOfBodyExperience", false); if (cameraEntity.Valid() && !outOfBodyExperience) { Events::SetCamera e; e.CameraEntity = cameraEntity; m_EventBroker->Publish(e); Events::LockMouse lock; m_EventBroker->Publish(lock); } return true; }
bool MultiplayerSnapshotFilter::FilterComponent(EntityWrapper entity, SharedComponentWrapper& component) { if (entity == m_LocalPlayer || entity.IsChildOf(m_LocalPlayer)) { if ( component.Info.Name == "Transform" || component.Info.Name == "Physics" || component.Info.Name == "AssaultWeapon" || component.Info.Name == "DefenderWeapon" || component.Info.Name == "SidearmWeapon" || component.Info.Name == "Animation" || component.Info.Name == "Blend" || component.Info.Name == "BlendAdditive" || component.Info.Name == "BlendOverride" || entity.Name() == "PlayerName" ) { return false; } } if (component.Info.Name == "Physics") { return false; } if (component.Info.Name == "Transform" || component.Info.Name == "Physics") { m_EventBroker->Publish(Events::Interpolate(entity, component)); return false; } return true; }
void DefenderWeaponBehaviour::spawnTracers(ComponentWrapper cWeapon, WeaponInfo& wi, std::vector<glm::vec2> pattern) { EntityWrapper flashSpawner = getRelevantWeaponEntity(wi).FirstChildByName("WeaponMuzzleFlash"); if (flashSpawner.Valid()) { std::uniform_real_distribution<float> randomSpreadAngle(0.f, 3.1415f*2); EntityWrapper flash = SpawnerSystem::Spawn(flashSpawner, flashSpawner); if (flash.Valid()) { ((Field<glm::vec3>)flash["Transform"]["Orientation"]).z(randomSpreadAngle(m_RandomEngine)); } } EntityWrapper muzzle = getRelevantWeaponEntity(wi).FirstChildByName("WeaponMuzzleRay"); if (!muzzle.Valid()) { return; } EntityWrapper camera = wi.Player.FirstChildByName("Camera"); if (!camera.Valid()) { return; } float spreadAngle = glm::radians((float)cWeapon["SpreadAngle"]); for (auto& pellet : pattern) { glm::quat pelletRotation = glm::quat(TransformSystem::AbsoluteOrientationEuler(camera)) * glm::quat(glm::vec3(pellet.y, pellet.x, 0) * spreadAngle); glm::vec3 cameraPosition = TransformSystem::AbsolutePosition(camera); glm::vec3 direction = pelletRotation * glm::vec3(0, 0, -1); float distance; glm::vec3 hitPosition; if (Collision::EntityFirstHitByRay(Ray(cameraPosition, direction), m_CollisionOctree, distance, hitPosition) != boost::none) { // don't spawn ray if you "miss the world" EntityWrapper ray = SpawnerSystem::Spawn(muzzle); if (ray.Valid()) { ComponentWrapper cTransform = ray["Transform"]; Field<glm::vec3> rayOrigin = cTransform["Position"]; Field<glm::vec3> rayOrientation = cTransform["Orientation"]; Field<glm::vec3> rayScale = cTransform["Scale"]; glm::vec3 muzzlePosition = TransformSystem::AbsolutePosition(muzzle); glm::quat muzzleOrientation = TransformSystem::AbsoluteOrientation(muzzle); glm::vec3 muzzleToHit = hitPosition - muzzlePosition; rayOrigin = muzzlePosition + (muzzleToHit/2.f); glm::vec3 lookVector = glm::normalize(-muzzleToHit); float pitch = std::asin(-lookVector.y); float yaw = std::atan2(lookVector.x, lookVector.z); glm::quat orientation = glm::quat(glm::vec3(pitch, yaw, 0)); rayOrientation = glm::eulerAngles(orientation); rayScale.x(glm::length(muzzleToHit)); } } } }
glm::vec3 TransformSystem::AbsoluteOrientationEuler(EntityWrapper entity) { glm::vec3 orientation; while (entity.Valid()) { ComponentWrapper transform = entity["Transform"]; orientation += (Field<glm::vec3>)transform["Orientation"]; entity = entity.Parent(); } return orientation; }
bool AnimationGroup::initialize(const DataProxy& dict, Ogre::SceneManager* sceneManager) { for(auto& pair : dict) { std::string fullId = pair.second.as<std::string>(); std::vector<std::string> id = split(fullId, '.'); std::string entityID; mAnimations[pair.first] = Animation(); if(id.size() < 2) { LOG(TRACE) << "Added empty animation to group " << pair.first; continue; } SceneNodeWrapper* containerNode = mRenderComponent->getRoot(); int i; for(i = 0; i < id.size() - 2; i++) { containerNode = containerNode->getChildOfType<SceneNodeWrapper>(id[i]); if(containerNode == 0) { break; } } if(containerNode == 0) { LOG(TRACE) << "Failed to find node with name " << id[i]; continue; } EntityWrapper* w = containerNode->getChildOfType<EntityWrapper>(id[i]); OgreV1::Entity* e = w->getEntity(); // no entity was found with such id if(e == 0) { LOG(ERROR) << "Failed to add animation: entity with id \"" << id[0] << "\" not found in scene manager"; return false; } // no such state if(!e->hasAnimationState(id[1])) { LOG(ERROR) << "Failed to add animation: animation state with id \"" << id[1] << "\" not found in entity"; return false; } LOG(TRACE) << "Adding animation " << fullId << " to group " << pair.first; mAnimations[pair.first].initialize(e->getAnimationState(id[1])); } return true; }
void KillFeedSystem::Update(double dt) { auto killFeeds = m_World->GetComponents("KillFeed"); if (killFeeds == nullptr) { return; } for (auto it = m_DeathQueue.begin(); it != m_DeathQueue.end(); it++) { (*it).TimeToLive -= dt; } for (auto& killFeedComponent : *killFeeds) { EntityWrapper entity = EntityWrapper(m_World, killFeedComponent.EntityID); for (int i = 1; i <= 3; i++) { EntityWrapper child = entity.FirstChildByName("KillFeed" + std::to_string(i)); if (child.HasComponent("Text")) { (Field<std::string>)child["Text"]["Content"] = ""; } } int feedIndex = 1; for (auto it = m_DeathQueue.begin(); it != m_DeathQueue.end(); ) { bool remove = false; EntityWrapper child = entity.FirstChildByName("KillFeed" + std::to_string(feedIndex)); if (child.HasComponent("Text")) { std::string str = ""; //Add killer to the start of string. str = (*it).KillerColor + "\\" + std::to_string((*it).KillerClass) + "\\CFFFFFF" + " " + (*it).KillerName + " "; //Add Weapon to middle of string. str += "\\" + std::to_string((*it).KillerClass+3) + " "; //Add victim to the end of string str += (*it).VictimColor + "\\" + std::to_string((*it).VictimClass) + "\\CFFFFFF" + " " + (*it).VictimName; (Field<std::string>)child["Text"]["Content"] = str; if ((*it).TimeToLive <= 0.f) { (Field<std::string>)child["Text"]["Content"] = ""; remove = true; } } feedIndex++; if(feedIndex > 3) { break; } if(remove) { it = m_DeathQueue.erase(it); } else { it++; } } } }
glm::quat TransformSystem::AbsoluteOrientation(EntityWrapper entity) { if (!entity.Valid()) { return glm::quat(); } auto cacheIt = OrientationCache.find(entity); ComponentWrapper cTransform = entity["Transform"]; ComponentWrapper::SubscriptProxy cTransformOrientation = cTransform["Orientation"]; if (cacheIt != OrientationCache.end() && !cTransformOrientation.Dirty(DirtySetType::Transform)) { return cacheIt->second; } else { EntityWrapper parent = entity.Parent(); // Calculate orientation glm::quat orientation = AbsoluteOrientation(parent) * glm::quat((const glm::vec3&)cTransformOrientation); // Cache it OrientationCache[entity] = orientation; RecalculatedOrientations++; // Unset dirty flag cTransformOrientation.SetDirty(DirtySetType::Transform, false); return orientation; } }
glm::vec3 TransformSystem::AbsoluteScale(EntityWrapper entity) { if (!entity.Valid()) { return glm::vec3(1.f); } auto cacheIt = ScaleCache.find(entity); ComponentWrapper cTransform = entity["Transform"]; ComponentWrapper::SubscriptProxy cTransformScale = cTransform["Scale"]; if (cacheIt != ScaleCache.end() && !cTransformScale.Dirty(DirtySetType::Transform)) { return cacheIt->second; } else { EntityWrapper parent = entity.Parent(); // Calculate scale glm::vec3 scale = AbsoluteScale(parent) * (const glm::vec3&)cTransformScale; // Cache it ScaleCache[entity] = scale; RecalculatedPositions++; // Unset dirty flag cTransformScale.SetDirty(DirtySetType::Transform, false); return scale; } }
EntityWrapper EntityManagerWrapper::createEntityF(const std::string& entity_name) { luabridge::LuaRef handle = global.scriptManager.getGlobal(entity_name); EntityWrapper entity = createEntity(); entity.setProperty("tableName", entity_name); entity.setProperty("type", handle["type"]); if (handle["GraphicsComponent"]) m_addGraphicsComponent(entity.getEntity(), handle["GraphicsComponent"]); if (handle["PhysicsComponent"]) m_addPhysicsComponent(entity.getEntity(), handle["PhysicsComponent"]); if (handle["AnimationComponent"]) m_addAnimationComponent(entity.getEntity(), handle["AnimationComponent"]); return entity; }
void BoneAttachmentSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& BoneAttachmentComponent, double dt) { if(!entity.HasComponent("Transform")) { return; } auto parent = entity.FirstParentWithComponent("Model"); if(!parent.Valid()) { return; } Model* model; try { model = ResourceManager::Load<::Model, true>(parent["Model"]["Resource"]); } catch (const std::exception&) { return; } if (!model->IsSkinned()) { return; } Skeleton* skeleton = model->m_Skeleton; if(skeleton == nullptr) { return; } int id = skeleton->GetBoneID(entity["BoneAttachment"]["BoneName"]); if (id == -1) { return; } if (skeleton->BlendTrees.find(parent) != skeleton->BlendTrees.end()) { glm::mat4 boneTransform = skeleton->BlendTrees.at(parent)->GetBoneTransform(id); glm::vec3 scale; glm::quat rotation; glm::vec3 translation; glm::vec3 skew; glm::vec4 perspective; glm::decompose(boneTransform, scale, rotation, translation, skew, perspective); rotation = glm::quat((glm::vec3)entity["BoneAttachment"]["OrientationOffset"]) * rotation; rotation = glm::inverse(rotation); glm::vec3 angles = glm::eulerAngles(rotation); if ((bool)entity["BoneAttachment"]["InheritPosition"]) { entity["Transform"]["Position"] = translation + (glm::vec3)entity["BoneAttachment"]["PositionOffset"]; } if ((bool)entity["BoneAttachment"]["InheritOrientation"]) { entity["Transform"]["Orientation"] = angles; } if ((bool)entity["BoneAttachment"]["InheritScale"]) { entity["Transform"]["Scale"] = scale * (glm::vec3)entity["BoneAttachment"]["ScaleOffset"]; } } }
void PlayerSpawnSystem::Update(double dt) { // If there are no CapturePointGameMode components we will just spawn immediately. // Should be able to support older maps with this. // TODO: In the future we might want to return instead, to avoid spawning in the menu for instance. auto pool = m_World->GetComponents("CapturePointGameMode"); if (pool != nullptr && pool->size() > 0) { // Take the first CapturePointGameMode component found. ComponentWrapper& modeComponent = *pool->begin(); // Increase timer. Field<double> timer = modeComponent["RespawnTime"]; timer += dt; if (m_DbgConfigForceRespawn) { (Field<double>)modeComponent["MaxRespawnTime"] = m_ForcedRespawnTime; } double maxRespawnTime = (double)modeComponent["MaxRespawnTime"]; EntityWrapper spectatorCam = m_World->GetFirstEntityByName("SpectatorCamera"); if (spectatorCam.Valid()) { EntityWrapper HUD = spectatorCam.FirstChildByName("SpectatorHUD"); if (HUD.Valid()) { EntityWrapper respawnTimer = spectatorCam.FirstChildByName("RespawnTimer"); if (respawnTimer.Valid()) { //Update respawn time in the HUD element. respawnTimer["Text"]["Content"] = std::to_string(1 + (int)(maxRespawnTime - timer)); } } } if (timer < maxRespawnTime) { return; } // If respawn time has passed, we spawn all players that have requested to be spawned. timer = 0; } // If there are no spawn requests, return immediately, if we are client the SpawnRequests should always be empty. if (m_SpawnRequests.size() == 0) { return; } auto playerSpawns = m_World->GetComponents("PlayerSpawn"); if (playerSpawns == nullptr) { return; } int numSpawnedPlayers = 0; int playersSpectating = 0; const int numRequestsToHandle = (int)m_SpawnRequests.size(); for (auto it = m_SpawnRequests.begin(); it != m_SpawnRequests.end(); ++it) { // It is valid if they didn't pick class yet // but don't spawn anything, goto next spawnrequest. if (it->Class == PlayerClass::None) { ++playersSpectating; continue; } for (auto& cPlayerSpawn : *playerSpawns) { EntityWrapper spawner(m_World, cPlayerSpawn.EntityID); if (!spawner.HasComponent("Spawner")) { continue; } // If the spawner has a team affiliation, check it if (spawner.HasComponent("Team")) { auto cSpawnerTeam = spawner["Team"]; if ((int)cSpawnerTeam["Team"] != it->Team) { // If they somehow has a valid class as spectator, don't spawn them. if (it->Team == cSpawnerTeam["Team"].Enum("Spectator")) { ++playersSpectating; break; } else { continue; } } } // TODO: Choose a different spawner depending on class picked? std::string playerEntityFile; if (it->Class == PlayerClass::Assault) { playerEntityFile = (const std::string&)cPlayerSpawn["AssaultFile"]; } else if (it->Class == PlayerClass::Defender) { playerEntityFile = (const std::string&)cPlayerSpawn["DefenderFile"]; } else if (it->Class == PlayerClass::Sniper) { playerEntityFile = (const std::string&)cPlayerSpawn["SniperFile"]; } // Spawn the player! EntityWrapper player = SpawnerSystem::SpawnEntityFile(playerEntityFile, spawner, EntityWrapper::Invalid, "Player"); // Set the player team affiliation player["Team"]["Team"] = it->Team; // Publish a PlayerSpawned event Events::PlayerSpawned e; e.PlayerID = it->PlayerID; e.Player = player; e.Spawner = spawner; m_EventBroker->Publish(e); ++numSpawnedPlayers; it = m_SpawnRequests.erase(it); break; } if (it == m_SpawnRequests.end()) { break; } } if (numSpawnedPlayers != numRequestsToHandle - playersSpectating) { LOG_DEBUG("%i players were supposed to be spawned, but only %i was successfully.", numRequestsToHandle - playersSpectating, numSpawnedPlayers); } else { std::string dbg = numSpawnedPlayers != 0 ? std::to_string(numSpawnedPlayers) + " players were spawned. " : ""; dbg += playersSpectating != 0 ? std::to_string(playersSpectating) + " players are spectating/picking class. " : ""; LOG_DEBUG(dbg.c_str()); } }
void DefenderWeaponBehaviour::CheckBoost(ComponentWrapper cWeapon, WeaponInfo& wi) { // Only check ammo client side if (!IsClient) { return; } // Only handle ammo check for the local player if (wi.Player != LocalPlayer) { return; } // Make sure the player isn't checking from the grave if (!wi.Player.Valid()) { return; } // 3D-pick middle of screen Rectangle viewport = m_Renderer->GetViewportSize(); glm::vec2 centerScreen(viewport.Width / 2, viewport.Height / 2); // TODO: Some horizontal spread PickData pickData = m_Renderer->Pick(centerScreen); EntityWrapper victim(m_World, pickData.Entity); if (!victim.Valid()) { return; } // Don't let us somehow shoot ourselves in the foot if (victim == LocalPlayer) { return; } // Only care about players being hit if (!victim.HasComponent("Player")) { victim = victim.FirstParentWithComponent("Player"); } if (!victim.Valid()) { return; } // If friendly fire, reduce damage to 0 (needed to make Boosts, Ammosharing work) if ((ComponentInfo::EnumType)victim["Team"]["Team"] == (ComponentInfo::EnumType)wi.Player["Team"]["Team"]) { EntityWrapper friendlyBoostHudSpawner = wi.FirstPersonPlayerModel.FirstChildByName("FriendlyBoostAttachment"); if (friendlyBoostHudSpawner.Valid()) { EntityWrapper assaultBoost = victim.FirstChildByName("BoostAssault"); EntityWrapper defenderBoost = victim.FirstChildByName("BoostDefender"); EntityWrapper sniperBoost = victim.FirstChildByName("BoostSniper"); auto children = m_World->GetDirectChildren(friendlyBoostHudSpawner.ID); if (children.first == children.second) { if (friendlyBoostHudSpawner.HasComponent("Spawner")) { EntityWrapper friendlyBoostHud = SpawnerSystem::Spawn(friendlyBoostHudSpawner, friendlyBoostHudSpawner); if (friendlyBoostHud.Valid()) { EntityWrapper assaultBoostEntity = friendlyBoostHud.FirstChildByName("AssaultBoost"); if (assaultBoostEntity.Valid()) { EntityWrapper active = assaultBoostEntity.FirstChildByName("Active"); if (active.HasComponent("Text")) { if (assaultBoost.Valid()) { (Field<bool>)active["Text"]["Visible"] = true; } else { (Field<bool>)active["Text"]["Visible"] = false; } } } EntityWrapper defenderBoostEntity = friendlyBoostHud.FirstChildByName("DefenderBoost"); if (defenderBoostEntity.Valid()) { EntityWrapper active = defenderBoostEntity.FirstChildByName("Active"); if (active.HasComponent("Text")) { if (defenderBoost.Valid()) { (Field<bool>)active["Text"]["Visible"] = true; } else { (Field<bool>)active["Text"]["Visible"] = false; } } } EntityWrapper sniperBoostEntity = friendlyBoostHud.FirstChildByName("SniperBoost"); if (sniperBoostEntity.Valid()) { EntityWrapper active = sniperBoostEntity.FirstChildByName("Active"); if (active.HasComponent("Text")) { if (sniperBoost.Valid()) { (Field<bool>)active["Text"]["Visible"] = true; } else { (Field<bool>)active["Text"]["Visible"] = false; } } } } } } else { EntityWrapper friendlyBoostHud = friendlyBoostHudSpawner.FirstChildByName("FriendlyBoostHUD"); if (friendlyBoostHud.Valid()) { if (friendlyBoostHud.HasComponent("Lifetime")) { (Field<double>)friendlyBoostHud["Lifetime"]["Lifetime"] = 0.5; } EntityWrapper assaultBoostEntity = friendlyBoostHud.FirstChildByName("AssaultBoost"); if (assaultBoostEntity.Valid()) { EntityWrapper active = assaultBoostEntity.FirstChildByName("Active"); if (active.HasComponent("Text")) { if (assaultBoost.Valid()) { (Field<bool>)active["Text"]["Visible"] = true; } else { (Field<bool>)active["Text"]["Visible"] = false; } } } EntityWrapper defenderBoostEntity = friendlyBoostHud.FirstChildByName("DefenderBoost"); if (defenderBoostEntity.Valid()) { EntityWrapper active = defenderBoostEntity.FirstChildByName("Active"); if (active.HasComponent("Text")) { if (defenderBoost.Valid()) { (Field<bool>)active["Text"]["Visible"] = true; } else { (Field<bool>)active["Text"]["Visible"] = false; } } } EntityWrapper sniperBoostEntity = friendlyBoostHud.FirstChildByName("SniperBoost"); if (sniperBoostEntity.Valid()) { EntityWrapper active = sniperBoostEntity.FirstChildByName("Active"); if (active.HasComponent("Text")) { if (sniperBoost.Valid()) { (Field<bool>)active["Text"]["Visible"] = true; } else { (Field<bool>)active["Text"]["Visible"] = false; } } } } } } } }
void DefenderWeaponBehaviour::fireShell(ComponentWrapper cWeapon, WeaponInfo& wi) { cWeapon["FireCooldown"] = 60.0 / (double)cWeapon["RPM"]; // Stop reloading Field<bool> isReloading = cWeapon["IsReloading"]; isReloading = false; // Ammo Field<int> magAmmo = cWeapon["MagazineAmmo"]; if (magAmmo <= 0) { return; } else { magAmmo -= 1; } // We can't really do any valuable calculations without a valid camera if (!m_CurrentCamera.Valid()) { return; } int numPellets = cWeapon["NumPellets"]; // Create a spread pattern std::vector<glm::vec2> pattern; // The first pellet is always centered pattern.push_back(glm::vec2(0, 0)); // Any additional pellets form circles around the middle int numOuterPellets = numPellets - 1; float angleIncrement = glm::two_pi<float>() / numOuterPellets; for (int i = 0; i < numOuterPellets; ++i) { float angle = angleIncrement * i; glm::vec2 pellet = glm::vec2(glm::cos(angle), glm::sin(angle)); pattern.push_back(pellet); } // Deal damage (clientside) dealDamage(cWeapon, wi, pattern); // Spawn tracers spawnTracers(cWeapon, wi, pattern); // View punch if (IsClient) { EntityWrapper camera = wi.Player.FirstChildByName("Camera"); if (camera.Valid()) { Field<glm::vec3> cameraOrientation = camera["Transform"]["Orientation"]; float viewPunch = cWeapon["ViewPunch"]; float maxTravelAngle = (const float&)cWeapon["MaxTravelAngle"]; Field<float> currentTravel = cWeapon["CurrentTravel"]; if (currentTravel < maxTravelAngle) { float change = viewPunch; if (currentTravel + change > maxTravelAngle) { change = maxTravelAngle - currentTravel; } cameraOrientation.x(cameraOrientation.x() + change); currentTravel += change; } } } // Play animation playAnimationAndReturn(wi.FirstPersonEntity, "FinalBlend", "Fire"); playAnimationAndReturn(wi.ThirdPersonPlayerModel, "FinalBlend", "Fire"); // Sound Events::PlaySoundOnEntity e; e.Emitter = wi.Player; e.FilePath = "Audio/weapon/Blast.wav"; m_EventBroker->Publish(e); }
bool DefenderWeaponBehaviour::OnInputCommand(ComponentWrapper cWeapon, WeaponInfo& wi, const Events::InputCommand& e) { if (e.Command == "SpecialAbility") { EntityWrapper attachment = wi.Player.FirstChildByName("ShieldAttachment"); if (attachment.Valid()) { if (e.Value > 0) { if(wi.Player.Valid()) { if(wi.Player.HasComponent("ShieldAbility")) { (Field<bool>)wi.Player["ShieldAbility"]["Active"] = true; } } if (IsServer) { SpawnerSystem::Spawn(attachment, attachment); } EntityWrapper backAttachment = attachment.FirstChildByName("Back"); if (backAttachment.Valid()) { Events::AutoAnimationBlend eDeployShieldAttachement; eDeployShieldAttachement.RootNode = backAttachment; eDeployShieldAttachement.NodeName = "Deploy"; eDeployShieldAttachement.Restart = true; eDeployShieldAttachement.Start = true; m_EventBroker->Publish(eDeployShieldAttachement); } EntityWrapper frontAttachment = attachment.FirstChildByName("Front"); if (frontAttachment.Valid()) { Events::AutoAnimationBlend eDeployShieldAttachement; eDeployShieldAttachement.RootNode = frontAttachment; eDeployShieldAttachement.NodeName = "Deploy"; eDeployShieldAttachement.Restart = true; eDeployShieldAttachement.Start = true; m_EventBroker->Publish(eDeployShieldAttachement); } if (IsClient) { EntityWrapper root = wi.FirstPersonEntity; if (root.Valid()) { EntityWrapper animationNode = root.FirstChildByName("Shield"); if (animationNode.Valid()) { Events::AutoAnimationBlend eShieldBlend; eShieldBlend.RootNode = root; eShieldBlend.NodeName = "Shield"; eShieldBlend.Restart = true; eShieldBlend.Start = true; m_EventBroker->Publish(eShieldBlend); } } } else { // server only EntityWrapper root = wi.ThirdPersonPlayerModel; if (root.Valid()) { Events::AutoAnimationBlend eShieldActivateBlend; eShieldActivateBlend.RootNode = root; eShieldActivateBlend.NodeName = "ActivateShield"; eShieldActivateBlend.Restart = true; eShieldActivateBlend.Start = true; m_EventBroker->Publish(eShieldActivateBlend); EntityWrapper animationNode = root.FirstChildByName("ActivateShield"); if (animationNode.Valid()) { Events::AutoAnimationBlend eShieldIdleBlend; eShieldIdleBlend.RootNode = root; eShieldIdleBlend.NodeName = "ShieldFront"; eShieldIdleBlend.Restart = true; eShieldIdleBlend.Start = true; eShieldIdleBlend.AnimationEntity = animationNode; m_EventBroker->Publish(eShieldIdleBlend); } } } } else { attachment.DeleteChildren(); if (wi.Player.Valid()) { if (wi.Player.HasComponent("ShieldAbility")) { (Field<bool>)wi.Player["ShieldAbility"]["Active"] = false; } } if (IsClient) { EntityWrapper root = wi.FirstPersonEntity; if (root.Valid()) { EntityWrapper animationNode = root.FirstChildByName("ActionBlend"); if (animationNode.Valid()) { Events::AutoAnimationBlend eFireBlend; eFireBlend.RootNode = root; eFireBlend.NodeName = "ActionBlend"; eFireBlend.Restart = true; eFireBlend.Start = true; m_EventBroker->Publish(eFireBlend); } } } else { // server only EntityWrapper root = wi.ThirdPersonPlayerModel; if (root.Valid()) { Events::AutoAnimationBlend eShieldDeactivateBlend; eShieldDeactivateBlend.RootNode = root; eShieldDeactivateBlend.NodeName = "ActivateShield"; eShieldDeactivateBlend.Restart = true; eShieldDeactivateBlend.Start = true; eShieldDeactivateBlend.Reverse = true; m_EventBroker->Publish(eShieldDeactivateBlend); EntityWrapper animationNode = root.FirstChildByName("ActivateShield"); if (animationNode.Valid()) { Events::AutoAnimationBlend eActionBlend; eActionBlend.RootNode = root; eActionBlend.NodeName = "ActionBlend"; eActionBlend.AnimationEntity = animationNode; m_EventBroker->Publish(eActionBlend); } } } } } } return false; }
void DefenderWeaponBehaviour::UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) { CheckBoost(cWeapon, wi); // Decrement reload timer Field<double> reloadTimer = cWeapon["ReloadTimer"]; reloadTimer = glm::max(0.0, reloadTimer - dt); // Start reloading automatically if at 0 mag ammo Field<int> magAmmo = cWeapon["MagazineAmmo"]; if (m_ConfigAutoReload && magAmmo <= 0) { OnReload(cWeapon, wi); } // Handle reloading Field<bool> isReloading = cWeapon["IsReloading"]; if (isReloading && reloadTimer <= 0.0) { double reloadTime = cWeapon["ReloadTime"]; Field<int> magSize = cWeapon["MagazineSize"]; Field<int> ammo = cWeapon["Ammo"]; if (magAmmo < magSize && ammo > 0) { ammo -= 1; magAmmo += 1; reloadTimer = reloadTime; Events::PlaySoundOnEntity e; e.Emitter = wi.Player; e.FilePath = "Audio/weapon/Zoom.wav"; m_EventBroker->Publish(e); } else { isReloading = false; playAnimationAndReturn(wi.FirstPersonEntity, "FinalBlend", "ReloadEnd"); if (wi.ThirdPersonPlayerModel.Valid()) { Events::AutoAnimationBlend eFireIdle; eFireIdle.Duration = 0.2; eFireIdle.RootNode = wi.ThirdPersonPlayerModel; eFireIdle.NodeName = "Fire"; eFireIdle.Start = false; m_EventBroker->Publish(eFireIdle); } } } // Restore view angle if (IsClient) { Field<float> currentTravel = cWeapon["CurrentTravel"]; Field<float> returnSpeed = cWeapon["ViewReturnSpeed"]; if (currentTravel > 0) { float change = returnSpeed * dt; currentTravel = glm::max(0.f, currentTravel - change); EntityWrapper camera = wi.Player.FirstChildByName("Camera"); if (camera.Valid()) { Field<glm::vec3> cameraOrientation = camera["Transform"]["Orientation"]; cameraOrientation.x(cameraOrientation.x() - change); } } } // Fire if we're able to fire if (canFire(cWeapon, wi)) { fireShell(cWeapon, wi); } }