public void TankGetHit(HealthChangedEvent e, SelfTankNode selfTank, [JoinAll] SingleNode <TutorialFirstDamageTriggerComponent> firstDamageTrigger)
{
if (selfTank.health.CurrentHealth < selfTank.lastHealth.LastHealth)
{
firstDamageTrigger.component.GetComponent <TutorialShowTriggerComponent>().Triggered();
}
}
public void InitIsisFeedbackSounds(NodeAddedEvent e, IsisWeaponNode isis, [Context, JoinByTank] SelfTankNode tank)
{
Transform soundRootTransform = tank.tankSoundRoot.SoundRootTransform;
SoundController isisAttackFeedbackController = tank.hitFeedbackSounds.IsisAttackFeedbackController;
SoundController isisHealingFeedbackController = tank.hitFeedbackSounds.IsisHealingFeedbackController;
isis.Entity.AddComponent(new IsisHitFeedbackReadyComponent(this.AttachStreamSoundController(isisHealingFeedbackController, soundRootTransform), this.AttachStreamSoundController(isisAttackFeedbackController, soundRootTransform)));
}
public void StartShotIfPossible(EarlyUpdateEvent evt, SelfTankNode selfTank, [JoinByTank] DiscreteWeaponMagazineControllerNode discreteWeaponMagazineController)
{
if ((discreteWeaponMagazineController.cooldownTimer.CooldownTimerSec <= 0f) && InputManager.CheckAction(ShotActions.SHOT))
{
base.ScheduleEvent <BeforeShotEvent>(discreteWeaponMagazineController);
base.ScheduleEvent <ShotPrepareEvent>(discreteWeaponMagazineController);
}
}
private void UpdateSelfTargetHitEffect(EffectInstanceFullNode effect, SelfTankNode selfTank, BattleCameraNode camera, SingleNode <ScreensLayerComponent> canvasNode, bool isShaftAiming)
{
SelfTargetHitEffectHUDData?nullable = this.GetDataForSelfTargetHitEffect(effect.selfTargetHitFeedbackHUDInstance.InitialData.EnemyWeaponWorldSpace, selfTank, camera, canvasNode, isShaftAiming);
if (nullable != null)
{
effect.selfTargetHitFeedbackHUDInstance.UpdateTransform(nullable.Value);
}
}
public void FlagDropRequest(UpdateEvent e, CarriedFlagNode flag, [JoinByTank] SelfTankNode tank, [JoinByBattle] SingleNode <RoundActiveStateComponent> round, [JoinByBattle] SingleNode <CTFConfigComponent> ctfConfig)
{
if (InputManager.GetActionKeyDown(CTFActions.DROP_FLAG))
{
base.ScheduleEvent <SendTankMovementEvent>(tank);
base.NewEvent <FlagDropRequestEvent>().Attach(flag).Attach(tank).Schedule();
base.NewEvent <TankFlagCollisionEvent>().Attach(flag).Attach(tank).ScheduleDelayed(ctfConfig.component.enemyFlagActionMinIntervalSec);
}
}
public void MarkTankAsUpsideDown(CheckUpsideDownStateEvent e, SelfTankNode tank, [JoinByUser] SingleNode <UpsideDownConfigComponent> config)
{
if (tank.rigidbody.RigidbodyTransform.up.y < config.component.GetUpsideDownCosToCheck())
{
UpsideDownTankComponent component = new UpsideDownTankComponent {
TimeTankBecomesUpsideDown = Date.Now
};
tank.Entity.AddComponent(component);
}
}
public void UpdateSelfShaftWeapon(TimeUpdateEvent e, ShaftWeaponNode 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);
base.ScheduleEvent(BaseWeaponRotationUpdateDeltaTimeEvent <WeaponRotationUpdateVerticalEvent> .GetInstance(deltaTime), weapon);
base.ScheduleEvent(BaseWeaponRotationUpdateDeltaTimeEvent <WeaponRotationUpdateShaftAimingCameraEvent> .GetInstance(deltaTime), weapon);
base.ScheduleEvent <WeaponRotationUpdateAimEvent>(weapon);
}
public void PlaySelfUserRankSoundEffect(UpdateUserRankEffectEvent evt, SelfTankNode tank, [JoinAll] SingleNode <MapInstanceComponent> map)
{
AudioSource source = Object.Instantiate <AudioSource>(tank.updateUserRankSoundEffectAsset.SelfUserRankSource);
Entity entity = base.CreateEntity("UpdateUserRankSoundEffect");
entity.AddComponent(new SelfUserRankSoundEffectInstanceComponent(source));
source.transform.SetParent(map.component.SceneRoot.transform, true);
source.Play();
base.NewEvent <RemoveSelfUserRankSoundEffectEvent>().Attach(entity).ScheduleDelayed(source.clip.length);
}
public void StartShotIfPossible(EarlyUpdateEvent evt, SelfTankNode selfTank, [JoinByTank] DiscreteWeaponControllerNode discreteWeaponEnergyController)
{
CooldownTimerComponent cooldownTimer = discreteWeaponEnergyController.cooldownTimer;
if (((discreteWeaponEnergyController.weaponEnergy.Energy >= discreteWeaponEnergyController.discreteWeaponEnergy.UnloadEnergyPerShot) && (cooldownTimer.CooldownTimerSec <= 0f)) && (InputManager.GetAxisOrKey(ShotActions.SHOT) != 0f))
{
base.ScheduleEvent <BeforeShotEvent>(discreteWeaponEnergyController);
base.ScheduleEvent <ShotPrepareEvent>(discreteWeaponEnergyController);
base.ScheduleEvent <PostShotEvent>(discreteWeaponEnergyController);
}
}
public void OnTankInactive(NodeRemoveEvent e, SelfTankNode selfTank, [JoinByTank] WeaponNode weapon)
{
WeaponRotationControlComponent weaponRotationControl = weapon.weaponRotationControl;
if (weaponRotationControl.EffectiveControl != 0f)
{
weaponRotationControl.PrevEffectiveControl = 0f;
weaponRotationControl.EffectiveControl = 0f;
base.ScheduleEvent <WeaponRotationControlChangedEvent>(weapon);
}
}
public void BuildSelf(NodeAddedEvent evt, SelfTankNode selfTank, [Context, JoinByUser] WeaponNode weaponNode, [Context, JoinByUser] UserNode user)
{
Entity entity = weaponNode.Entity;
entity.AddComponent <CooldownTimerComponent>();
entity.AddComponent <ShaftStateControllerComponent>();
entity.AddComponent <VerticalSectorsTargetingComponent>();
entity.AddComponent <DirectionEvaluatorComponent>();
entity.AddComponent <WeaponShotComponent>();
entity.AddComponent <DistanceAndAngleTargetEvaluatorComponent>();
}
public void AddTargetFocusComponent(NodeAddedEvent e, SelfTankNode tank, SingleNode <TargetFocusSettingsComponent> settings)
{
if (settings.component.Enabled)
{
tank.Entity.AddComponent <TargetFocusEffectComponent>();
tank.Entity.AddComponent <TargetFocusVerticalTargetingComponent>();
tank.Entity.AddComponent <TargetFocusVerticalSectorTargetingComponent>();
tank.Entity.AddComponent <TargetFocusConicTargetingComponent>();
tank.Entity.AddComponent <TargetFocusPelletConeComponent>();
}
}
public void ApplyTargetFocusEffect(NodeAddedEvent e, SelfTankNode tank, [JoinByTank, Context] ConicTargetingNode weapon, [JoinByTank, Context] TargetFocusEffectNode effect)
{
if (!weapon.Entity.HasComponent <WeaponPreparedByTargetFocusEffectComponent>())
{
float halfConeAngle = weapon.conicTargeting.HalfConeAngle;
float num2 = ((float)weapon.conicTargeting.HalfConeNumRays) / halfConeAngle;
weapon.conicTargeting.HalfConeAngle += effect.targetFocusConicTargeting.AdditionalHalfConeAngle;
weapon.conicTargeting.HalfConeNumRays = Mathf.RoundToInt(num2 * weapon.conicTargeting.HalfConeAngle);
weapon.Entity.AddComponent <WeaponPreparedByTargetFocusEffectComponent>();
}
}
public void BuildSelf(NodeAddedEvent evt, SelfTankNode selfTank, [Context, JoinByUser] WeaponNode weaponNode, [Context, JoinByUser] UserNode user)
{
Entity entity = weaponNode.Entity;
entity.AddComponent <CooldownTimerComponent>();
entity.AddComponent <StreamWeaponControllerComponent>();
entity.AddComponent <ConicTargetingComponent>();
entity.AddComponent(new WeaponHitComponent(false, true));
entity.AddComponent(new StreamWeaponSimpleFeedbackControllerComponent());
entity.AddComponent(new TargetCollectorComponent(new TargetCollector(selfTank.Entity), new PenetrationTargetValidator(selfTank.Entity)));
}
private bool ValidateTargets(List <HitTarget> targets, SelfTankNode tank, BattleNode battle)
{
for (int i = 0; i < targets.Count; i++)
{
HitTarget target = targets[i];
if (this.ValidateTarget(target.Entity, tank, battle))
{
return(true);
}
}
return(false);
}
public void BuildSelf(NodeAddedEvent e, SelfTankNode tank, [Context, JoinByUser] WeaponNode weapon)
{
weapon.Entity.AddComponent <CooldownTimerComponent>();
weapon.Entity.AddComponent <StreamWeaponControllerComponent>();
weapon.Entity.AddComponent <ConicTargetingComponent>();
weapon.Entity.AddComponent(new WeaponHitComponent(false, false));
weapon.Entity.AddComponent <DirectionEvaluatorComponent>();
weapon.Entity.AddComponent <DistanceAndAngleTargetEvaluatorComponent>();
TargetCollectorComponent component = new TargetCollectorComponent(new TargetCollector(tank.Entity), new TargetValidator(tank.Entity));
weapon.Entity.AddComponent(component);
}
public void BuildSelf(NodeAddedEvent evt, SelfTankNode selfTank, [Context, JoinByUser] WeaponNode weaponNode, [Context, JoinByUser] UserNode user)
{
Entity entity = weaponNode.Entity;
entity.AddComponent <CooldownTimerComponent>();
entity.AddComponent <VerticalSectorsTargetingComponent>();
entity.AddComponent(new WeaponHitComponent(false, false));
entity.AddComponent <DirectionEvaluatorComponent>();
entity.AddComponent <WeaponShotComponent>();
entity.AddComponent <DistanceAndAngleTargetEvaluatorComponent>();
entity.AddComponent(new TargetCollectorComponent(new TargetCollector(selfTank.Entity), new TargetValidator(selfTank.Entity)));
}
public void ShakeOnFalling(TankFallEvent evt, SelfTankNode tank, [JoinAll] CameraShakerFallingNode cameraShaker, [JoinAll] SingleNode <GameCameraShakerSettingsComponent> settings, [JoinAll] SingleNode <MainHUDComponent> hud)
{
float fallingPower = evt.FallingPower;
float minFallingPower = cameraShaker.tankFallingCameraShakerConfig.MinFallingPower;
float maxFallingPower = cameraShaker.tankFallingCameraShakerConfig.MaxFallingPower;
float weakeningCoeff = Mathf.Clamp01((fallingPower - minFallingPower) / (maxFallingPower - minFallingPower));
cameraShaker.cameraShaker.ShakeByFalling(settings.component, cameraShaker.tankFallingCameraShakerConfig, weakeningCoeff);
if (fallingPower >= cameraShaker.tankFallingCameraShakerConfig.MinFallingPowerForHUD)
{
hud.component.battleHudRoot.ShakeHUDOnFalling(settings.component, cameraShaker.tankFallingCameraShakerConfig);
}
}
public void CTFActivation(UpdateEvent e, SelfTankNode tank, [JoinByTank, Combine] MineSlotNode slot, [JoinByModule] MineModuleNode module, [JoinAll] ICollection <SingleNode <FlagPedestalComponent> > flagPedestals, [JoinAll] CTFBattleNode battle)
{
Vector3 position = tank.hullInstance.HullInstance.transform.position;
if (this.HasActivationMine(position, flagPedestals, battle))
{
this.EnableActivation(slot.Entity);
}
else
{
this.DisableActivation(slot.Entity);
}
}
public void ChangeHealthVignette(UpdateEvent evt, SelfTankNode tank, [JoinAll] ReadyBattleCameraNode camera, [JoinAll] SingleNode <HealthFeedbackMapEffectMaterialComponent> mapEffect)
{
float damageIntensity = camera.healthFeedbackCameraPrepared.HealthFeedbackPostEffect.DamageIntensity;
float targetIntensity = camera.healthFeedbackCameraPrepared.TargetIntensity;
float f = targetIntensity - damageIntensity;
if (Mathf.Abs(f) > 0.0001f)
{
float num4 = Mathf.Sign(f) * mapEffect.component.IntensitySpeed;
float num5 = damageIntensity + (num4 * evt.DeltaTime);
num5 = (num4 <= 0f) ? Mathf.Clamp(num5, targetIntensity, damageIntensity) : Mathf.Clamp(num5, damageIntensity, targetIntensity);
camera.healthFeedbackCameraPrepared.HealthFeedbackPostEffect.DamageIntensity = num5;
}
}
public void DisableHealthFilter(NodeAddedEvent evt, SelfTankNode tank, SoundListenerNode listener)
{
listener.healthFeedbackSoundListener.ResetHealthFeedbackData();
}
private bool ValidateSelfHit(SelfHitEvent e, SelfTankNode tank, BattleNode battle) => (e.Targets != null) ? ((e.Targets.Count != 0) ? this.ValidateTargets(e.Targets, tank, battle) : false) : false;
public void ScheduleHitFeedbackOnSelfSplashHitEvent(SelfSplashHitEvent e, SplashWeaponNode weapon, [JoinByTank] SelfTankNode tank, [JoinByBattle] BattleNode battle)
{
if (this.ValidateSelfHit(e, tank, battle))
{
base.ScheduleEvent <HitFeedbackEvent>(tank);
}
else if (((e.SplashTargets != null) && (e.SplashTargets.Count != 0)) && this.ValidateTargets(e.SplashTargets, tank, battle))
{
base.ScheduleEvent <HitFeedbackEvent>(tank);
}
}
public void ScheduleHitFeedbackOnSelfHitEvent(SelfHitEvent e, DiscreteWeaponNode weapon, [JoinByTank] SelfTankNode tank, [JoinByBattle] BattleNode battle)
{
if (this.ValidateSelfHit(e, tank, battle))
{
base.ScheduleEvent <HitFeedbackEvent>(tank);
}
}
public void BeginStreamWeaponHitFeedback(NodeAddedEvent e, StreamHitNode weapon, [Context, JoinByTank] SelfTankNode tank, [Context, JoinByBattle] DMBattleNode battle)
{
weapon.Entity.AddComponentIfAbsent <StreamHitEnemyFeedbackComponent>();
}
public void AddStreamWeaponHitFeedback(SelfHitEvent e, StreamWeaponWorkingFeedbackControllerNode weapon, [JoinByTank] SelfTankNode tank, [JoinByBattle] BattleNode battle)
{
if (this.ValidateSelfHit(e, tank, battle))
{
weapon.Entity.AddComponentIfAbsent <StreamHitEnemyFeedbackComponent>();
}
else
{
weapon.Entity.RemoveComponentIfPresent <StreamHitEnemyFeedbackComponent>();
}
}
public void EnableEffect(SelfTankExplosionEvent e, SelfTankNode selfTank, [JoinByTank] KamikadzeEffectNode effectNode)
{
base.ScheduleEvent <StartSplashEffectEvent>(effectNode);
}
public void DisableHealthFilter(NodeRemoveEvent evt, SelfTankNode tank, [JoinAll] SoundListenerNode listener)
{
listener.healthFeedbackSoundListener.SwitchToNormalHealthMode();
}
public void PlayEnergyInjectionSoundEffect(ExecuteEnergyInjectionEvent e, SingleNode <EnergyInjectionEffectComponent> effect, [JoinByTank] SelfTankNode tank)
{
tank.energyInjectionSoundEffect.Sound.StopImmediately();
tank.energyInjectionSoundEffect.Sound.FadeIn();
}
private bool ValidateTarget(Entity targetEntity, SelfTankNode tank, BattleNode battle) => !targetEntity.Equals(tank.Entity) ? (targetEntity.HasComponent <TankActiveStateComponent>() ? (!battle.Entity.HasComponent <TeamBattleComponent>() || (targetEntity.GetComponent <TeamGroupComponent>().Key != tank.Entity.GetComponent <TeamGroupComponent>().Key)) : false) : false;
