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);
}
}
