public void InitLaser(NodeAddedEvent e, SelfActiveTankNode activeTank, [JoinByTank] WeaponWithLaser weapon, [JoinAll] SingleNode <LaserSightSettingsComponent> settings)
{
if (settings.component.Enabled)
{
GameObject asset = weapon.shaftAimingLaser.Asset;
for (int i = 0; i < weapon.muzzlePoint.Points.Length; i++)
{
GetInstanceFromPoolEvent eventInstance = new GetInstanceFromPoolEvent {
Prefab = asset
};
base.ScheduleEvent(eventInstance, activeTank);
Transform instance = eventInstance.Instance;
GameObject gameObject = instance.gameObject;
ShaftAimingLaserBehaviour component = gameObject.GetComponent <ShaftAimingLaserBehaviour>();
weapon.shaftAimingLaser.EffectInstance = component;
CustomRenderQueue.SetQueue(gameObject, 0xc4e);
Transform transform = weapon.weaponInstance.WeaponInstance.transform;
instance.position = transform.position;
instance.rotation = transform.rotation;
gameObject.SetActive(true);
component.Init();
component.SetColor(Color.red);
component.Show();
}
weapon.Entity.AddComponent <ShaftAimingLaserReadyComponent>();
}
}
public void SwitchFromSpeedUpToIdleWhenSelfTankInactive(NodeRemoveEvent evt, SelfActiveTankNode selfActiveTank, [JoinByTank] VulcanWeaponSpeedUpControllerNode vulcanSpeedUp)
{
Entity entity = vulcanSpeedUp.Entity;
entity.RemoveComponent <VulcanSpeedUpComponent>();
entity.AddComponent <VulcanIdleComponent>();
}
public void SwitchToLowHealthMode(HealthChangedEvent evt, SelfActiveTankNode tank, [JoinAll] SoundListenerNode listener)
{
if ((tank.health.CurrentHealth / tank.health.MaxHealth) > listener.healthFeedbackSoundListener.MaxHealthPercentForSound)
{
listener.healthFeedbackSoundListener.SwitchToNormalHealthMode();
}
else
{
listener.healthFeedbackSoundListener.SwitchToLowHealthMode();
}
}
public void DeinitLaser(NodeRemoveEvent e, SelfActiveTankNode activeTank, [JoinByTank] WeaponWithLaser weapon)
{
foreach (ShaftAimingLaserBehaviour behaviour in weapon.shaftAimingLaser.EffectInstances)
{
if (behaviour != null)
{
behaviour.Kill();
}
}
weapon.Entity.RemoveComponentIfPresent <ShaftAimingLaserReadyComponent>();
}
public void InitializeIdleState(NodeAddedEvent evt, SelfActiveTankNode selfActiveTank, [Context, JoinByUser] StreamWeaponShootableNode streamWeapon, [JoinByUser] ICollection <SelfUserNode> user)
{
Entity weapon = streamWeapon.Entity;
if (streamWeapon.weaponEnergy.Energy <= 0f)
{
SwitchWorkingModeToIdleMode(weapon);
}
else if (InputManager.CheckAction(ShotActions.SHOT))
{
SwitchIdleModeToWorkingMode(weapon);
}
else
{
SwitchWorkingModeToIdleMode(weapon);
}
}
public void SwitchFromShootingToIdleWhenSelfTankInactive(NodeRemoveEvent evt, SelfActiveTankNode selfActiveTank, [JoinByTank] VulcanWeaponShootingControllerNode vulcanShooting)
{
Entity entity = vulcanShooting.Entity;
entity.RemoveComponent <WeaponStreamShootingComponent>();
entity.AddComponent <VulcanIdleComponent>();
}
public void DefineFirstStateOnSelfTank(NodeAddedEvent evt, SelfActiveTankNode selfActiveTank, [Context, JoinByTank] VulcanWeaponNode vulcan)
{
vulcan.Entity.AddComponentIfAbsent <VulcanIdleComponent>();
}
public void UpdateVulcanShootingOnSelfTank(ApplicationFocusEvent evt, VulcanWeaponShootingControllerNode vulcanShooting, [JoinByTank] SelfActiveTankNode tank)
{
if (!evt.IsFocused)
{
this.SwitchVulcanFromShootingToSlowDown(vulcanShooting.Entity);
}
}
public void StartStreamWorkingIfPossible(EarlyUpdateEvent evt, StreamWeaponIdleControllerNode idleWeapon, [JoinSelf] SingleNode <ShootableComponent> shootable, [JoinByTank] SelfActiveTankNode selfActiveTank)
{
Entity weapon = idleWeapon.Entity;
if ((idleWeapon.weaponEnergy.Energy > 0f) && InputManager.GetActionKeyDown(ShotActions.SHOT))
{
SwitchIdleModeToWorkingMode(weapon);
}
}
public void UpdateSpeedStateUpOnSelfTank(ApplicationFocusEvent evt, VulcanWeaponSpeedUpControllerNode vulcanSpeedUp, [JoinByTank] SelfActiveTankNode tank)
{
Entity weapon = vulcanSpeedUp.Entity;
if (!evt.IsFocused)
{
this.SwitchVulcanFromSpeedUpToSlowDown(weapon);
}
}
public void UpdateSpeedStateUpOnSelfTank(EarlyUpdateEvent evt, VulcanWeaponSpeedUpControllerNode vulcanSpeedUp, [JoinByTank] SelfActiveTankNode tank)
{
Entity weapon = vulcanSpeedUp.Entity;
if (!InputManager.CheckAction(ShotActions.SHOT))
{
this.SwitchVulcanFromSpeedUpToSlowDown(weapon);
}
else if (vulcanSpeedUp.vulcanWeaponState.State >= 1f)
{
this.SwitchVulcanFroomSpeedUpToShooting(weapon);
}
}
public void UpdateSlowDownStateOnSelfTank(EarlyUpdateEvent evt, VulcanWeaponSlowDownControllerNode vulcanSlowDown, [JoinByTank] SelfActiveTankNode tank)
{
Entity weapon = vulcanSlowDown.Entity;
if (vulcanSlowDown.vulcanWeaponState.State <= 0f)
{
this.SwitchVulcanFromSlowDownToIdle(weapon);
}
}
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 CheckWeaponStateOnInactiveTank(NodeRemoveEvent evt, SelfActiveTankNode tank, [JoinByTank] ShaftWeaponNode weapon)
{
StateUtils.SwitchEntityState <ShaftIdleStateComponent>(weapon.Entity, this.weaponStates);
}
public void InitWaitingStateOnInput(TimeUpdateEvent evt, ShaftIdleWeaponControllerNode weapon, [JoinByTank] SelfActiveTankNode activeTank)
{
this.StartWaitingStateIfPossible(weapon.Entity);
}
public void ChangeHealthVignette(HealthChangedEvent evt, SelfActiveTankNode tank, [JoinAll] ReadyBattleCameraNode camera)
{
float num3 = tank.health.CurrentHealth / tank.health.MaxHealth;
camera.healthFeedbackCameraPrepared.TargetIntensity = 1f - Mathf.Clamp01(num3);
}
public void RunWorkingStream(EarlyUpdateEvent evt, StreamWeaponWorkingControllerNode workingWeapon, [JoinByTank] SelfActiveTankNode selfActiveTank)
{
Entity weapon = workingWeapon.Entity;
CooldownTimerComponent cooldownTimer = workingWeapon.cooldownTimer;
if (workingWeapon.weaponEnergy.Energy <= 0f)
{
SwitchWorkingModeToIdleMode(weapon);
}
else if (InputManager.GetActionKeyUp(ShotActions.SHOT))
{
SwitchWorkingModeToIdleMode(weapon);
}
else if ((cooldownTimer.CooldownTimerSec <= 0f) && workingWeapon.Entity.HasComponent <ShootableComponent>())
{
base.ScheduleEvent <BeforeShotEvent>(workingWeapon);
base.ScheduleEvent <ShotPrepareEvent>(workingWeapon);
}
}
public void UpdateVulcanShootingOnSelfTank(EarlyUpdateEvent evt, VulcanWeaponShootingControllerNode vulcanShooting, [JoinByTank] SelfActiveTankNode tank)
{
if (!InputManager.CheckAction(ShotActions.SHOT))
{
this.SwitchVulcanFromShootingToSlowDown(vulcanShooting.Entity);
}
}
public void SwitchToIdleWhenTankInactive(NodeRemoveEvent evt, SelfActiveTankNode selfActiveTank, [JoinByTank] StreamWeaponWorkingControllerNode workingWeapon)
{
SwitchWorkingModeToIdleMode(workingWeapon.Entity);
}
public void UpdateVulcanShootingOnSelfTank(EarlyUpdateEvent evt, VulcanWeaponStreamHitShootingControllerNode vulcanShooting, [JoinByTank] SelfActiveTankNode tank)
{
if (vulcanShooting.cooldownTimer.CooldownTimerSec <= 0f)
{
base.ScheduleEvent <BeforeShotEvent>(vulcanShooting);
base.ScheduleEvent <ShotPrepareEvent>(vulcanShooting);
}
}
