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;