private async void RocketDelayedAttack(EntityControllerBase target, RocketAmmunition rocket) { await Task.Delay(500); try { if (target == null || PlayerController.Locked == null || PlayerController.Locked.ID != target.ID) { return; } double damage = Noise(rocket.Damage * PlayerController.BoosterAssembly.Get(BoosterType.DAMAGE_ROCKETS)); if (damage > 0) { double shieldAbsorption = Math.Max(0, Math.Min(1, target.BoosterAssembly.Get(BoosterType.SHIELD_ABSORBATION))); int damageShield = Math.Abs(target.HangarAssembly.ChangeShield(-(int)(damage * shieldAbsorption), false)); int damageHitpoints = Math.Abs(target.HangarAssembly.ChangeHitpoints(-(int)(damage - damageShield), false)); // set stats target.AttackTraceAssembly.LogAttack(PlayerController, damageShield, damageHitpoints); target.HangarAssembly.CheckDeath(); if (target != null) { ICommand damageCommand = PacketBuilder.AttackCommand(PlayerController, target, AttackTypeModule.ROCKET, (int)damage); target.Send(damageCommand); // send to player target.EntitiesLocked(y => y.Send(damageCommand)); // send to all who have him in lock } } ActivateRocketSpecialAttack(target, rocket); // initialize special attack } catch (Exception e) { GameContext.Logger.LogError(e); } }
private async void RocketLauncherDelayedAttack(EntityControllerBase target, RocketLauncherAmmunition rlAmmo, int hitCount) { await Task.Delay(750); try { if (target == null || PlayerController.Locked == null || PlayerController.Locked.ID != target.ID) { return; } CalculateHellstormDamage(rlAmmo, hitCount, out double damage, out double shieldDamage); if (shieldDamage > 0) { shieldDamage = Math.Abs(target.HangarAssembly.ChangeShield(-(int)shieldDamage, false)); PlayerController.HangarAssembly.ChangeShield((int)shieldDamage); } double shieldDamageDealt = shieldDamage; double hitpointsDamageDealt = 0; if (damage > 0) { double shieldAbsorption = Math.Max(0, Math.Min(1, target.BoosterAssembly.Get(BoosterType.SHIELD_ABSORBATION))); int damageShield = Math.Abs(target.HangarAssembly.ChangeShield(-(int)(damage * shieldAbsorption), false)); int damageHitpoints = Math.Abs(target.HangarAssembly.ChangeHitpoints(-(int)(damage - damageShield), false)); shieldDamageDealt += damageShield; hitpointsDamageDealt += damageHitpoints; } // set stats target.AttackTraceAssembly.LogAttack(PlayerController, (int)shieldDamageDealt, (int)hitpointsDamageDealt); target.HangarAssembly.CheckDeath(); if (target != null) { ICommand damageCommand = PacketBuilder.AttackCommand(PlayerController, target, AttackTypeModule.ROCKET, (int)(shieldDamage + damage)); target.Send(damageCommand); // send to player target.EntitiesLocked(y => y.Send(damageCommand)); // send to all who have him in lock } } catch (Exception e) { GameContext.Logger.LogError(e); } }
public void CheckOrStopSingularity(bool force = false) { try { ShipAbility ability = ShipAbility.SINGULARITY; PlayerController.Account.Cooldown.AbilityCooldown.TryGetValue(ability.ID, out DateTime lastAbilityTime); if (_singularityActive && (_singularityCounter == (int)ability.Duration.TotalSeconds * 2 || force)) { _singularityActive = false; PlayerController.Account.Cooldown.AbilityCooldown[ability.ID] = DateTime.Now - ability.Duration; PlayerController.EffectsAssembly.DeactivateSingularity(); PlayerController.Locked.EffectsAssembly.DeactivateSingularity(); PlayerController.Send(PacketBuilder.Slotbar.ItemCooldownCommand(ability.Name, ability.Cooldown.TotalMilliseconds)); } else if (_singularityActive) { if (++_singularityCounter % 2 == 0) { if (PlayerController.Locked.EffectsAssembly.HasProtection || (PlayerController.Locked is PlayerController lockedPlayerController && lockedPlayerController.SpecialItemsAssembly.IsInvicible)) { PlayerController.Locked.AttackTraceAssembly.LogAttack(PlayerController, 0, 0, false); ICommand missCommand = new AttackMissedCommand(new AttackTypeModule(AttackTypeModule.SINGULARITY), PlayerController.Locked.ID, 0); PlayerController.Locked.Send(new AttackMissedCommand(new AttackTypeModule(AttackTypeModule.SINGULARITY), PlayerController.Locked.ID, 1)); PlayerController.Locked.EntitiesLocked(x => x.Send(missCommand)); } else { PlayerController.Locked.HangarAssembly.ChangeHitpoints(-_singularityLastDamage, false); PlayerController.Locked.AttackTraceAssembly.LogAttack(PlayerController, 0, _singularityLastDamage, false); PlayerController.Locked.HangarAssembly.CheckDeath(); ICommand damageCommand = PacketBuilder.AttackCommand(PlayerController, PlayerController.Locked, AttackTypeModule.SINGULARITY, _singularityLastDamage); PlayerController.Locked.Send(damageCommand); // send to player PlayerController.Locked.EntitiesLocked(y => y.Send(damageCommand)); // send to all who have him in lock } _singularityLastDamage += _singularityDamageIncrease; } } } catch { }
public void TriggerSMB() { SpecialItem item = SpecialItem.SMB_01; if (!PlayerController.Account.Vault.SpecialItems.TryGetValue(item.ID, out int currentCount) || currentCount <= 0) { return; } PlayerController.Account.Vault.SpecialItems[item.ID] = --currentCount; PlayerController.Account.Cooldown.SpecialItemCooldown.TryGetValue(item.ID, out DateTime lastTrigger); if (lastTrigger.FromNow() < item.Cooldown) { return; } PlayerController.Account.Cooldown.SpecialItemCooldown[item.ID] = DateTime.Now; ICommand smbCommand = PacketBuilder.SpecialItems.Smartbomb(PlayerController); PlayerController.Send( PacketBuilder.Slotbar.ExplosiveItemStatus(item.Name, currentCount, false), PacketBuilder.Slotbar.ItemCooldownCommand(item.Name, item.Cooldown.TotalMilliseconds, currentCount > 0), smbCommand ); PlayerController.EntitiesInRangeSafe(x => { // if performance does not meet demand, add async here if (x is PlayerController playerController && !playerController.SpecialItemsAssembly.IsInvicible && !x.EffectsAssembly.HasProtection && !x.ZoneAssembly.IsInDMZ && x.MovementAssembly.ActualPosition().DistanceTo(PlayerController.MovementAssembly.ActualPosition()) < 550) { double damage = x.HangarAssembly.Hitpoints * .2; int shieldDamage = Math.Abs(x.HangarAssembly.ChangeShield(-(int)(damage * x.BoosterAssembly.Get(BoosterType.SHIELD_ABSORBATION)), false)); int hitpointsDamage = Math.Abs(x.HangarAssembly.ChangeHitpoints(-(int)(damage - shieldDamage), false)); x.AttackTraceAssembly.LogAttack(PlayerController, shieldDamage, hitpointsDamage, false); x.HangarAssembly.CheckDeath(); ICommand attackCommand = PacketBuilder.AttackCommand(PlayerController, x, AttackTypeModule.SMARTBOMB, shieldDamage + hitpointsDamage); x.Send(smbCommand, attackCommand); // send to player x.EntitiesLocked(y => y.Send(attackCommand)); // send to all who have him in lock }
public void StartChainImpulse() { TechFactory tech = TechFactory.CHAIN_IMPULSE; if (_lastCI.FromNow() > tech.Cooldown) { if (!PlayerController.Account.Vault.Techs.TryGetValue(tech.ID, out int currentCount) || currentCount <= 0) { return; } PlayerController.Account.Vault.Techs[tech.ID] = --currentCount; bool working = false; double toDeal = Noise(10000); StringBuilder chainCommand = new StringBuilder($"0|TX|ECI||{PlayerController.ID}"); foreach (EntityControllerBase entity in PlayerController.Spacemap.InRange(PlayerController, 1000) .OrderBy(x => x.MovementAssembly.ActualPosition().DistanceTo(PlayerController.MovementAssembly.ActualPosition())) .Take(7)) { working = true; chainCommand.Append($"|{entity.ID}"); int damage = Math.Abs(entity.HangarAssembly.ChangeHitpoints(-(int)toDeal, false)); toDeal = Noise(toDeal); entity.AttackTraceAssembly.LogAttack(PlayerController, 0, damage, false); entity.HangarAssembly.CheckDeath(); ICommand damageCommand = PacketBuilder.AttackCommand(PlayerController, entity, AttackTypeModule.LASER, damage); entity.Send(damageCommand); // send to player PlayerController.Send(damageCommand); // send to player entity.EntitiesLocked(y => { if (y.ID == PlayerController.ID) { return; } y.Send(damageCommand); }); // send to all who have him in lock } if (!working) { return; } else { _lastCI = DateTime.Now; PlayerController.Account.Cooldown.TechCooldown[tech.ID] = _lastCI; } ICommand showEffectCommand = PacketBuilder.Legacy(chainCommand.ToString()); PlayerController.Send( showEffectCommand, PacketBuilder.Slotbar.TechItemStatus(tech.Name, currentCount, false), PacketBuilder.Slotbar.ItemCooldownCommand(tech.Name, tech.Cooldown.TotalMilliseconds) ); PlayerController.EntitesInRange(x => x.Send(showEffectCommand)); } }
public void LaserAttack(ref int lapCount, Ammuninition ammo) { lock (_laserLock) { #region {[ CHECKING ]} if (PlayerController.Locked == null || PlayerController.Locked.MovementAssembly.ActualPosition() .DistanceTo(PlayerController.MovementAssembly.ActualPosition()) > 600 || !_attackRunning) { return; } bool stopLoop = true; bool stopAttack = false; if (PlayerController.Locked.ZoneAssembly.IsInDMZ) { PlayerController.Send(PacketBuilder.Messages.PeaceArea()); stopAttack = true; } if (!PlayerController.Account.CurrentHangar.LaserEquipped) { PlayerController.Send(PacketBuilder.Messages.NoLasersOnBoard()); stopAttack = true; } if (!stopAttack && !CheckLaserCount(ammo, false, out int currentCount)) { PlayerController.Send(PacketBuilder.Messages.NoLaserAmmo()); stopAttack = true; } if (!stopAttack && !LaserCooldown(ref lapCount, ammo)) { stopAttack = true; stopLoop = false; } if (stopAttack) { if (stopLoop) { Stop(); } return; } #endregion CheckLaserCount(ammo, true, out currentCount); // deduct LastAttack = PlayerController.CurrentClock.ElapsedMilliseconds; ICommand attackCommand = PacketBuilder.AttackLaserCommand(PlayerController, PlayerController.Locked, ammo.ID); PlayerController.Send(attackCommand, PacketBuilder.Slotbar.LaserItemStatus(ammo.Name, currentCount, true)); PlayerController.EntitesInRange(x => x.Send(attackCommand)); if (PlayerController.Locked.EffectsAssembly.HasProtection || (PlayerController.Locked is PlayerController lockedPlayerController && lockedPlayerController.SpecialItemsAssembly.IsInvicible) || Miss()) { PlayerController.Locked.AttackTraceAssembly.LogAttack(PlayerController, 0, 0); ICommand missCommand = new AttackMissedCommand(new AttackTypeModule(AttackTypeModule.LASER), PlayerController.Locked.ID, 0); PlayerController.Locked.Send(new AttackMissedCommand(new AttackTypeModule(AttackTypeModule.LASER), PlayerController.Locked.ID, 1)); PlayerController.Locked.EntitiesLocked(x => x.Send(missCommand)); return; } CalculateLaserDamage(ammo, PlayerController.Locked, out double damage, out double shieldDamage); if (shieldDamage > 0) { shieldDamage = Math.Abs(PlayerController.Locked.HangarAssembly.ChangeShield(-(int)shieldDamage, false)); PlayerController.HangarAssembly.ChangeShield((int)shieldDamage); } double shieldDamageDealt = shieldDamage; double hitpointsDamageDealt = 0; if (damage > 0) { double shieldAbsorption = Math.Max(0, Math.Min(1, PlayerController.Locked.BoosterAssembly.Get(BoosterType.SHIELD_ABSORBATION) - (PlayerController.BoosterAssembly.Get(BoosterType.LASER_SHIELD_PENETRATION) - 1))); double damageShield = damage * shieldAbsorption; if (PlayerController.PlayerAbilityAssembly.WeakenShieldsActive && PlayerController.PlayerAbilityAssembly.WeakenShieldsVictim.ID == PlayerController.Locked.ID) { damageShield *= 1.6; } damageShield = Math.Abs(PlayerController.Locked.HangarAssembly.ChangeShield(-(int)damageShield, false)); int damageHitpoints = Math.Abs(PlayerController.Locked.HangarAssembly.ChangeHitpoints(-(int)(damage - Math.Min(damage * shieldAbsorption, damageShield)), false)); shieldDamageDealt += damageShield; hitpointsDamageDealt += damageHitpoints; // energy transfer double hitpointsRegain = PlayerController.BoosterAssembly.Get(BoosterType.DAMAGE_LASER_TO_HITPOINTS_TRANSFORMER) - 1.0; if (hitpointsRegain > 0 && ammo.ID == Ammuninition.UCB_100.ID) { int regain = PlayerController.HangarAssembly.ChangeHitpoints(Math.Max(0, (int)((damageShield + damageHitpoints) * hitpointsRegain))); if (regain > 0 && !PlayerController.PlayerTechAssembly.EnergyTransferActive && ++_healCounter % 2 == 0) { _healCounter = 0; ICommand energyTransferCommand = PacketBuilder.AttackLaserCommand(PlayerController.Locked, PlayerController, 7); PlayerController.Locked.Send(energyTransferCommand); // send to player PlayerController.Locked.EntitesInRange(y => y.Send(energyTransferCommand)); // send to all who have him in lock } } } // set stats PlayerController.Locked.AttackTraceAssembly.LogAttack(PlayerController, (int)shieldDamageDealt, (int)hitpointsDamageDealt); PlayerController.Locked.HangarAssembly.CheckDeath(); ActivateLaserSpecialAttack(ammo); // initialize special attack if (PlayerController.Locked != null) // Locked kann nach der CheckDeath-Methode tot sein (wahrscheinlichkeit: hoch) { ICommand damageCommand = PacketBuilder.AttackCommand(PlayerController, PlayerController.Locked, AttackTypeModule.LASER, (int)(shieldDamageDealt + hitpointsDamageDealt)); PlayerController.Locked.Send(damageCommand); // send to player PlayerController.Locked.EntitiesLocked(y => y.Send(damageCommand)); // send to all who have him in lock } } }
public void Handle() { if (Activated && !_detonated) { _detonated = true; foreach (var entity in Spacemap.InRange(Position, 1000).ToList()) { if (!(entity is PlayerController playerController)) { continue; } if (playerController.TryRemoveMine(this)) { playerController.Send(Explode()); } else { playerController.Send(Render(), Explode()); } if (playerController.MovementAssembly.ActualPosition().DistanceTo(Position) <= 300 * RadiusBoost) { if (!playerController.EffectsAssembly.HasProtection && !playerController.SpecialItemsAssembly.IsInvicible) { if (Item.ID == Mine.ACM_01.ID) { double damage = playerController.HangarAssembly.Hitpoints * 0.2 * DamageBoost; int shieldDamage = Math.Abs(playerController.HangarAssembly.ChangeShield(-(int)(damage * playerController.BoosterAssembly.Get(BoosterType.SHIELD_ABSORBATION)), false)); int hitpointsDamage = Math.Abs(playerController.HangarAssembly.ChangeHitpoints(-(int)(damage - shieldDamage), false)); playerController.AttackTraceAssembly.LogAttack(Owner, shieldDamage, hitpointsDamage, false); playerController.HangarAssembly.CheckDeath(); ICommand damageCommand = PacketBuilder.AttackCommand(Owner, playerController, AttackTypeModule.MINE, shieldDamage + hitpointsDamage); playerController.Send(damageCommand); playerController.EntitiesLocked(x => x.Send(damageCommand)); } else if (Item.ID == Mine.DDM_01.ID) { int damage = Math.Abs(playerController.HangarAssembly.ChangeHitpoints(-(int)(playerController.HangarAssembly.MaxHitpoints * 0.2 * DamageBoost), false)); playerController.AttackTraceAssembly.LogAttack(Owner, 0, damage, false); playerController.HangarAssembly.CheckDeath(); ICommand damageCommand = PacketBuilder.AttackCommand(Owner, playerController, AttackTypeModule.MINE, damage); playerController.Send(damageCommand); playerController.EntitiesLocked(x => x.Send(damageCommand)); } else if (Item.ID == Mine.IM_01.ID) { playerController.PlayerEffectsAssembly.Infect(15 * 60000); double damage = playerController.HangarAssembly.Hitpoints * 0.2 * DamageBoost; int shieldDamage = Math.Abs(playerController.HangarAssembly.ChangeShield(-(int)(damage * playerController.BoosterAssembly.Get(BoosterType.SHIELD_ABSORBATION)), false)); int hitpointsDamage = Math.Abs(playerController.HangarAssembly.ChangeHitpoints(-(int)(damage - shieldDamage), false)); playerController.AttackTraceAssembly.LogAttack(Owner, shieldDamage, hitpointsDamage, false); playerController.HangarAssembly.CheckDeath(); ICommand damageCommand = PacketBuilder.AttackCommand(Owner, playerController, AttackTypeModule.MINE, shieldDamage + hitpointsDamage); playerController.Send(damageCommand); playerController.EntitiesLocked(x => x.Send(damageCommand)); } else if (Item.ID == Mine.SABM_01.ID) { int damage = Math.Abs(playerController.HangarAssembly.ChangeShield(-(int)(playerController.HangarAssembly.Shield * 0.5 * DamageBoost), false)); playerController.AttackTraceAssembly.LogAttack(Owner, damage, 0, false); ICommand damageCommand = PacketBuilder.AttackCommand(Owner, playerController, AttackTypeModule.MINE, damage); playerController.Send(damageCommand); playerController.EntitiesLocked(x => x.Send(damageCommand)); } else if (Item.ID == Mine.SLM_01.ID) { playerController.EffectsAssembly.SlowMine(3000); } } if (Item.ID == Mine.EMPM_01.ID) { playerController.EffectsAssembly.UnCloak(); } } } Spacemap.Remove(this); } }