public void UnloadEnergy(TimeUpdateEvent evt, StreamWeaponUnloadingEnergyNode weapon) { float num = weapon.streamWeaponEnergy.UnloadEnergyPerSec * evt.DeltaTime; weapon.weaponEnergy.Energy -= num; weapon.weaponEnergy.Energy = Mathf.Clamp(weapon.weaponEnergy.Energy, 0f, 1f); }
public void UpdateSelfCommonWeapon(TimeUpdateEvent e, SimpleWeaponNode weapon, [JoinByTank] SelfTankNode tank, [JoinByUser] SingleNode <MouseControlStateHolderComponent> mouseControlStateHolder) { float deltaTime = e.DeltaTime; base.ScheduleEvent(BaseWeaponRotationUpdateDeltaTimeEvent <WeaponRotationUpdateGyroscopeEvent> .GetInstance(deltaTime), weapon); this.UpdateWeaponRotation(weapon, mouseControlStateHolder, deltaTime, false); }
public void UpdateTransparencyTransition(TimeUpdateEvent evt, TransitionRendererNode renderer) { TransparencyTransitionComponent transparencyTransition = renderer.transparencyTransition; transparencyTransition.CurrentTransitionTime += evt.DeltaTime; if (renderer.baseRenderer.Renderer) { float targetAlpha; if (transparencyTransition.CurrentTransitionTime < transparencyTransition.TransparencyTransitionTime) { targetAlpha = transparencyTransition.OriginAlpha + (transparencyTransition.AlphaSpeed * transparencyTransition.CurrentTransitionTime); } else { targetAlpha = transparencyTransition.TargetAlpha; if (transparencyTransition.TargetAlpha >= ClientGraphicsConstants.OPAQUE_ALPHA) { base.ScheduleEvent <TransparencyFinalizeEvent>(renderer.Entity); } else if (transparencyTransition.TargetAlpha <= ClientGraphicsConstants.TRANSPARENT_ALPHA) { renderer.baseRenderer.Renderer.enabled = false; } } renderer.transparencyTransition.CurrentAlpha = targetAlpha; TankMaterialsUtil.SetAlpha(renderer.baseRenderer.Renderer, targetAlpha); } }
public void PlayLowEnergyForVulcanIdleWeapon(TimeUpdateEvent e, VulcanWeaponIdleNode weapon, [JoinByTank] TankNode tank, [JoinAll] SoundListenerNode listener) { if (InputManager.GetActionKeyDown(ShotActions.SHOT) && !weapon.Entity.HasComponent <ShootableComponent>()) { this.PlayLowEnergyFeedback(tank); } }
public void LinearFlight(TimeUpdateEvent e, HangarCameraLinearFlightNode hangar) { HangarCameraFlightDataComponent hangarCameraFlightData = hangar.hangarCameraFlightData; float t = Mathf.Pow(Mathf.Clamp01(((UnityTime.time - hangar.hangarCameraFlightData.StartFlightTime) - hangarCameraFlightData.ArcFlightTime) / hangarCameraFlightData.LinearFlightTime), 0.3333333f); hangar.cameraRootTransform.Root.position = Vector3.Lerp(hangarCameraFlightData.ArcToLinearPoint, hangarCameraFlightData.DestinationCameraPosition, t); }
public void UpdateCharging(TimeUpdateEvent e, RailgunChargingEnergyAnimatedNode weapon, [JoinByTank] HUDNodes.ActiveSelfTankNode tank, [JoinAll] SingleNode <MainHUDComponent> hud) { float chargingTime = weapon.railgunChargingWeapon.ChargingTime; hud.component.CurrentEnergyValue = this.EaseInQuad(weapon.chargeAnimationData.CurrentDuration / chargingTime, 1f, -1f); weapon.chargeAnimationData.CurrentDuration += e.DeltaTime; }
public void UpdateRegionOpacityByDistance(TimeUpdateEvent e, TankNode tank, [JoinAll, Combine] VisibleBonusRegionNode region, [JoinAll] SingleNode <BonusRegionClientConfigComponent> configNode, [JoinAll] SingleNode <RoundActiveStateComponent> round) { BonusRegionClientConfigComponent component = configNode.component; float num = Vector3.Distance(tank.tankColliders.BoundsCollider.transform.position, region.spatialGeometry.Position); region.opacityBonusRegion.Opacity = Mathf.Clamp01(1f - ((num - component.maxOpacityRadius) / (component.minOpacityRadius - component.maxOpacityRadius))); }
public void ToConcealmentState(TimeUpdateEvent e, NameplateAppearanceNode nameplate) { if (!nameplate.nameplate.alwaysVisible && (nameplate.nameplatePosition.sqrDistance > nameplate.nameplateOpacity.sqrConcealmentDistance)) { nameplate.nameplateEsm.esm.ChangeState <NameplateStates.NameplateConcealmentState>(); } }
public void UpdateCamera(TimeUpdateEvent e, SpectatorTransitionCameraNode transitionCameraNode, [JoinAll] Optional <SingleNode <CameraTargetComponent> > target) { CameraSaveData cameraSaveData = transitionCameraNode.transitionCamera.CameraSaveData; if ((cameraSaveData.Type == CameraType.Free) || target.IsPresent()) { UpdateCamera(e.DeltaTime, transitionCameraNode); ApplyCameraTransformEvent eventInstance = ApplyCameraTransformEvent.ResetApplyCameraTransformEvent(); eventInstance.PositionSmoothingRatio = SPECTATOR_TRANSITION_CAMERA_POSITION_SMOOTHING_RATIO; eventInstance.RotationSmoothingRatio = SPECTATOR_TRANSITION_CAMERA_ROTATION_SMOOTHING_RATIO; eventInstance.DeltaTime = e.DeltaTime; base.ScheduleEvent(eventInstance, transitionCameraNode); if (transitionCameraNode.transitionCamera.TransitionComplete) { CameraType type = cameraSaveData.Type; if (type == CameraType.Follow) { transitionCameraNode.bezierPosition.BezierPosition.SetBaseRatio(cameraSaveData.FollowCameraBezierPositionRatio); transitionCameraNode.bezierPosition.BezierPosition.SetRatioOffset(cameraSaveData.FollowCameraBezierPositionRatioOffset); transitionCameraNode.cameraESM.Esm.ChangeState <CameraStates.CameraFollowState>(); } else if (type == CameraType.MouseOrbit) { MouseOrbitCameraComponent mouseOrbitCamera = transitionCameraNode.cameraESM.Esm.ChangeState <CameraStates.CameraOrbitState>().mouseOrbitCamera; mouseOrbitCamera.distance = cameraSaveData.MouseOrbitDistance; mouseOrbitCamera.targetRotation = cameraSaveData.MouseOrbitTargetRotation; } else if (type == CameraType.Free) { transitionCameraNode.cameraESM.Esm.ChangeState <CameraStates.CameraFreeState>(); } } } }
public void UpdateIdleStateOnSelfTank(TimeUpdateEvent evt, VulcanWeaponIdleControllerNode vulcanIdle, [JoinSelf] SingleNode <ShootableComponent> node, [JoinByTank] SelfActiveTankNode tank) { if (InputManager.CheckAction(ShotActions.SHOT)) { this.SwitchVulcanFromIdleToSpeedUp(vulcanIdle.Entity); } }
public void UpdateSlowDownStateOnAnyTank(TimeUpdateEvent evt, VulcanWeaponSlowDownNode vulcanSlowDown) { VulcanWeaponStateComponent component; float num = 1f / vulcanSlowDown.vulcanWeapon.SlowDownTime; vulcanSlowDown.vulcanWeaponState.State = component.State - (num * evt.DeltaTime); }
public void UpdateEnergy(TimeUpdateEvent e, ShaftEnergyNode weapon, [JoinByTank] HUDNodes.ActiveSelfTankNode tank, [JoinAll] SingleNode <MainHUDComponent> hud) { CooldownTimerComponent cooldownTimer = weapon.cooldownTimer; if ((weapon.weaponEnergy.Energy >= weapon.shaftEnergy.UnloadEnergyPerQuickShot) && ((cooldownTimer.CooldownTimerSec <= 0f) && weapon.Entity.HasComponent <ShootableComponent>())) { if (!weapon.Entity.HasComponent <BlinkMarkerComponent>()) { weapon.Entity.AddComponent <BlinkMarkerComponent>(); hud.component.EnergyBlink(true); } } else { if (weapon.Entity.HasComponent <BlinkMarkerComponent>()) { weapon.Entity.RemoveComponent <BlinkMarkerComponent>(); } if (InputManager.GetActionKeyDown(ShotActions.SHOT)) { hud.component.EnergyBlink(false); } } hud.component.CurrentEnergyValue = weapon.weaponEnergy.Energy; }
public void PlayLowEnergyForVulcanSlowDownWeapon(TimeUpdateEvent e, VulcanWeaponSlowDownNode weapon, [JoinByTank] TankNode tank, [JoinAll] SoundListenerNode listener) { if (InputManager.GetActionKeyDown(ShotActions.SHOT)) { this.PlayLowEnergyFeedback(tank); } }
public void PlayLowEnergyForHammerWeapon(TimeUpdateEvent e, HammerEnergyNode weapon, [JoinByTank] TankNode tank, [JoinAll] SoundListenerNode listener) { if (InputManager.GetActionKeyDown(ShotActions.SHOT) && ((weapon.cooldownTimer.CooldownTimerSec > 0f) || (weapon.Entity.HasComponent <MagazineReloadStateComponent>() || !weapon.Entity.HasComponent <ShootableComponent>()))) { this.PlayLowEnergyFeedback(tank); } }
public void UpdateSpeedUpStateOnAnyTank(TimeUpdateEvent e, VulcanWeaponSpeedUpNode vulcanSpeedUp) { VulcanWeaponStateComponent component; float num = 1f / vulcanSpeedUp.vulcanWeapon.SpeedUpTime; vulcanSpeedUp.vulcanWeaponState.State = component.State + (e.DeltaTime * num); }
public void Reload(TimeUpdateEvent e, HammerEnergyNode weapon, [JoinByTank] HUDNodes.ActiveSelfTankNode tank, [JoinAll] SingleNode <MainHUDComponent> hud) { if (((weapon.cooldownTimer.CooldownTimerSec > 0f) || (weapon.Entity.HasComponent <MagazineReloadStateComponent>() || !weapon.Entity.HasComponent <ShootableComponent>())) && InputManager.GetActionKeyDown(ShotActions.SHOT)) { hud.component.EnergyBlink(false); } }
public void UpdateBrokenBonusBoxAlpha(TimeUpdateEvent e, TakenBrokenBonusBoxNode node) { float progress = Date.Now.GetProgress(node.localDuration.StartedTime, node.localDuration.Duration); float alpha = 1f - ((progress >= 0.9f) ? ((progress - 0.9f) / 0.1f) : 0f); node.materialArray.Materials.SetAlpha(alpha); }
public void CheckSpraySelf(TimeUpdateEvent e, GraffitiSimpleNode graffiti, [JoinByUser] SingleNode <SelfBattleUserComponent> self, [JoinByUser] SingleNode <TankActiveStateComponent> tank, [JoinByBattle] SingleNode <RoundActiveStateComponent> round) { if (InputManager.GetActionKeyDown(BattleActions.GRAFFITI) && (graffiti.graffitiAntiSpamTimer.SprayDelay < Time.realtimeSinceStartup)) { base.ScheduleEvent <SprayEvent>(graffiti); graffiti.graffitiAntiSpamTimer.SprayDelay = Time.realtimeSinceStartup + 5.1f; } }
public void OnUpdate(TimeUpdateEvent evt, SelfDestructionServiceMessageNode selfDestruction, [JoinAll] SelfBattleUserNode selfBattleUser, [JoinAll] SingleNode <BattleScreenComponent> battleScreen) { if ((selfDestruction.timer.Timer != null) && ((selfDestruction.timer.Timer.SecondsLeft - evt.DeltaTime) >= 1f)) { TimerUIComponent timer = selfDestruction.timer.Timer; timer.SecondsLeft -= evt.DeltaTime; } }
public void Energy(TimeUpdateEvent e, StreamEnergyNode weapon, [JoinByTank] HUDNodes.ActiveSelfTankNode tank, [JoinAll] SingleNode <MainHUDComponent> hud) { hud.component.CurrentEnergyValue = weapon.weaponEnergy.Energy; if (InputManager.GetActionKeyDown(ShotActions.SHOT) && !weapon.Entity.HasComponent <ShootableComponent>()) { hud.component.EnergyBlink(false); } }
public void SlowDown(TimeUpdateEvent e, VulcanWeaponSlowDownNode vulcan, [JoinByTank] SingleNode <AnimationDataComponent> animData, [JoinByTank] HUDNodes.ActiveSelfTankNode tank, [JoinAll] SingleNode <MainHUDComponent> hud) { hud.component.CurrentEnergyValue = vulcan.vulcanWeaponState.State * animData.component.CooldownScale; if (InputManager.GetActionKeyDown(ShotActions.SHOT)) { hud.component.EnergyBlink(false); } }
public void UpdateRegionOpacity(TimeUpdateEvent e, BonusRegionNode node, [JoinAll] SingleNode <BonusRegionClientConfigComponent> configNode) { Material material = node.material.Material; float alpha = material.GetAlpha(); float num2 = e.DeltaTime * configNode.component.opacityChangingSpeed; material.SetAlpha(Mathf.Clamp(node.opacityBonusRegion.Opacity, alpha - num2, alpha + num2)); }
public void Reload(TimeUpdateEvent e, HammerReloadingEnergyNode weapon, [JoinByTank] HUDNodes.ActiveSelfTankNode tank, [JoinAll] SingleNode <MainHUDComponent> hud) { float num3 = weapon.magazineWeapon.ReloadMagazineTimePerSec / ((float)weapon.magazineWeapon.MaxCartridgeCount); float currentDuration = weapon.reloadAnimationData.CurrentDuration; int num5 = (int)(currentDuration / num3); hud.component.CurrentEnergyValue = this.EaseInQuad((currentDuration - (num5 * num3)) / num3, (float)num5, 1f); weapon.reloadAnimationData.CurrentDuration += e.DeltaTime; }
public void HideNameplate(TimeUpdateEvent e, NameplateConclealmentNode nameplate) { NameplateComponent nameplateComponent = nameplate.nameplate; if (!nameplate.nameplate.alwaysVisible && (nameplateComponent.Alpha > 0f)) { this.DecreaseAlpha(nameplateComponent, e.DeltaTime); } }
public void UpdateCamera(TimeUpdateEvent e, TransitionCameraNode transitionCameraNode, [JoinAll] SingleNode <SelfTankComponent> selfTank) { UpdateCamera(e.DeltaTime, transitionCameraNode); base.ScheduleEvent(ApplyCameraTransformEvent.ResetApplyCameraTransformEvent(), transitionCameraNode); if (transitionCameraNode.transitionCamera.TransitionComplete) { transitionCameraNode.cameraESM.Esm.ChangeState <CameraStates.CameraFollowState>(); } }
public void AlphaBlendByDistance(TimeUpdateEvent e, MineNode mine, [JoinByTank] EnemyTankNode tank, [JoinByBattle] SelfTankNode selfTank) { if (!mine.Entity.HasComponent <MineActivationGraphicsComponent>()) { Vector4 vector = MINE_ACTIVATION_COLOR; vector.w = MineCommonGraphicsSystem.BlendMine(mine.mineConfig, mine.effectInstance, mine.effectRendererGraphics, selfTank.hullInstance); mine.effectRendererGraphics.Renderer.material.SetColor("_Color", vector); } }
public void Update(TimeUpdateEvent e, BattleUserNode selfBattleUser, [JoinByUser] SingleNode <RoundUserComponent> selfRoundUser, [JoinByBattle] ICollection <SingleNode <RoundUserComponent> > allRoundUsers, [JoinAll] StatisticsNode statistics) { if (!RoundTimeTooShortForMeasuring(statistics)) { PerformanceStatisticsHelperComponent performanceStatisticsHelper = statistics.performanceStatisticsHelper; int durationInMs = (int)(e.DeltaTime * 1000f); performanceStatisticsHelper.frames.AddFrame(durationInMs); performanceStatisticsHelper.tankCount.Add(allRoundUsers.Count, durationInMs); } }
public void DeleteNameplate(TimeUpdateEvent e, NameplateDeletionNode nameplate) { NameplateComponent nameplateComponent = nameplate.nameplate; this.DecreaseAlpha(nameplateComponent, e.DeltaTime); if (nameplateComponent.Alpha <= 0f) { Object.Destroy(nameplateComponent.gameObject); } }
public void Update(TimeUpdateEvent e, RailgunReadyEnergyNode weapon, [JoinByTank] HUDNodes.ActiveSelfTankNode tank, [JoinAll] SingleNode <MainHUDComponent> hud) { float currentEnergyValue = hud.component.CurrentEnergyValue; hud.component.CurrentEnergyValue = weapon.weaponEnergy.Energy; if ((hud.component.CurrentEnergyValue == hud.component.MaxEnergyValue) && (currentEnergyValue < hud.component.MaxEnergyValue)) { hud.component.EnergyBlink(true); } }
public void CheckWorkFinishState(TimeUpdateEvent evt, ShaftAimingWorkFinishWeaponControllerNode weapon) { if (weapon.shaftAimingWorkFinishState.FinishTimer < weapon.shaftStateConfig.FinishToIdleTransitionTimeSec) { weapon.shaftAimingWorkFinishState.FinishTimer += evt.DeltaTime; } else { StateUtils.SwitchEntityState <ShaftIdleStateComponent>(weapon.Entity, this.weaponStates); } }