public void AttackMissed(Attackable target, DamageType damageType)
{
var attackMissedCommand = AttackMissedCommand.write(new AttackTypeModule((short)damageType), target.Id, 0);
var attackMissedCommandToInRange = AttackMissedCommand.write(new AttackTypeModule((short)damageType), target.Id, 1);
Player.SendCommand(attackMissedCommand);
Player.SendCommandToInRangePlayers(attackMissedCommandToInRange);
}
public void RocketAttack(ref int lapCount, RocketAmmunition rocket, bool force = false)
{
lock (_rocketLock) {
#region {[ CHECKING ]}
if (PlayerController.Locked == null ||
(rocket.ID != RocketAmmunition.R_IC3.ID && PlayerController.Locked.MovementAssembly.ActualPosition()
.DistanceTo(PlayerController.MovementAssembly.ActualPosition()) > 650) ||
PlayerController.Locked.MovementAssembly.ActualPosition()
.DistanceTo(PlayerController.MovementAssembly.ActualPosition()) > 550 ||
(!force && !_attackRunning))
{
return;
}
if (PlayerController.Locked.ZoneAssembly.IsInDMZ)
{
PlayerController.Send(PacketBuilder.Messages.PeaceArea());
return;
}
if (!CheckRocketCount(rocket, false, out int currentCount))
{
PlayerController.Send(PacketBuilder.Messages.NoRocketAmmo());
return;
}
if (!RocketCooldown(ref lapCount, rocket))
{
return;
}
#endregion
CheckRocketCount(rocket, true, out currentCount); // deduct count
LastAttack = PlayerController.CurrentClock.ElapsedMilliseconds;
ICommand attackCommand = PacketBuilder.AttackRocketCommand(PlayerController, PlayerController.Locked, rocket.ID);
PlayerController.Send(attackCommand, PacketBuilder.Slotbar.RocketItemStatus(rocket.Name, currentCount, true));
PlayerController.EntitesInRange(x => x.Send(attackCommand));
if (PlayerController.Locked.EffectsAssembly.HasProtection ||
(PlayerController.Locked is PlayerController lockedPlayerController && lockedPlayerController.SpecialItemsAssembly.IsInvicible) ||
(!PlayerController.PlayerTechAssembly.PrecisionTargeterActive && 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;
}
RocketDelayedAttack(PlayerController.Locked, rocket);
}
}
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 static void Damage(Player attacker, Attackable target, DamageType damageType, int damage, bool toDestroy, bool toHp, bool toShd, bool missedEffect = true)
{
if (damageType == DamageType.MINE && target.Invincible)
{
return;
}
if (attacker.Invincible && damageType != DamageType.RADIATION)
{
attacker.Storage.DeactiveInvincibilityEffect();
}
if (target is Player && !(target as Player).Attackable())
{
if (missedEffect)
{
var attackMissedCommandToInRange = AttackMissedCommand.write(new AttackTypeModule((short)damageType), target.Id, 0);
var attackMissedCommand = AttackMissedCommand.write(new AttackTypeModule((short)damageType), target.Id, 0);
attacker.SendCommand(attackMissedCommand);
attacker.SendCommandToInRangePlayers(attackMissedCommandToInRange);
}
damage = 0;
return;
}
target.LastCombatTime = DateTime.Now;
if (toHp && toDestroy && (damage >= target.CurrentHitPoints || target.CurrentHitPoints <= 0))
{
if (damageType == DamageType.RADIATION)
{
target.Destroy(null, DestructionType.RADIATION);
}
else if (damageType == DamageType.MINE && attacker.Attackers.Count <= 0)
{
target.Destroy(null, DestructionType.MINE);
}
else
{
target.Destroy(attacker, DestructionType.PLAYER);
}
}
else if (toHp)
{
if (target.CurrentNanoHull > 0)
{
if (target.CurrentNanoHull - damage < 0)
{
var nanoDamage = damage - target.CurrentNanoHull;
target.CurrentNanoHull = 0;
target.CurrentHitPoints -= nanoDamage;
}
else
{
target.CurrentNanoHull -= damage;
}
}
else
{
target.CurrentHitPoints -= damage;
}
}
if (toShd)
{
target.CurrentShieldPoints -= damage;
}
var attackHitCommand =
AttackHitCommand.write(new AttackTypeModule((short)damageType), attacker.Id,
target.Id, target.CurrentHitPoints,
target.CurrentShieldPoints, target.CurrentNanoHull,
damage, false);
attacker.SendCommand(attackHitCommand);
attacker.SendCommandToInRangePlayers(attackHitCommand);
target.UpdateStatus();
}
public void Attack(Attackable target, double shieldPenetration = 0)
{
var missProbability = Type == StationModuleModule.LASER_LOW_RANGE ? 0.1 : Type == StationModuleModule.LASER_MID_RANGE ? 0.3 : Type == StationModuleModule.LASER_HIGH_RANGE ? 0.4 : Type == StationModuleModule.ROCKET_LOW_ACCURACY ? 0.5 : Type == StationModuleModule.ROCKET_MID_ACCURACY ? 0.3 : 1.00;
var damage = AttackManager.RandomizeDamage((Type == StationModuleModule.LASER_LOW_RANGE ? 59850 : Type == StationModuleModule.LASER_MID_RANGE ? 48450 : Type == StationModuleModule.LASER_HIGH_RANGE ? 28500 : Type == StationModuleModule.ROCKET_LOW_ACCURACY ? 85500 : Type == StationModuleModule.ROCKET_MID_ACCURACY ? 71250 : 0), missProbability);
damage = 1000; //for test
var damageType = (Type == StationModuleModule.LASER_LOW_RANGE || Type == StationModuleModule.LASER_MID_RANGE || Type == StationModuleModule.LASER_HIGH_RANGE) ? DamageType.LASER : (Type == StationModuleModule.ROCKET_LOW_ACCURACY || Type == StationModuleModule.ROCKET_MID_ACCURACY) ? DamageType.ROCKET : DamageType.LASER;
var cooldown = (Type == StationModuleModule.ROCKET_LOW_ACCURACY || Type == StationModuleModule.ROCKET_MID_ACCURACY) ? 2 : 1;
if (target.Position.DistanceTo(Position) < GetRange())
{
if (!TargetDefinition(target))
{
return;
}
if (lastAttackTime.AddSeconds(cooldown) < DateTime.Now)
{
int damageShd = 0, damageHp = 0;
double shieldAbsorb = System.Math.Abs(target.ShieldAbsorption - shieldPenetration);
if (shieldAbsorb > 1)
{
shieldAbsorb = 1;
}
if ((target.CurrentShieldPoints - damage) >= 0)
{
damageShd = (int)(damage * shieldAbsorb);
damageHp = damage - damageShd;
}
else
{
int newDamage = damage - target.CurrentShieldPoints;
damageShd = target.CurrentShieldPoints;
damageHp = (int)(newDamage + (damageShd * shieldAbsorb));
}
if ((target.CurrentHitPoints - damageHp) < 0)
{
damageHp = target.CurrentHitPoints;
}
if (target is Player && !(target as Player).Attackable())
{
damage = 0;
damageShd = 0;
damageHp = 0;
}
if (damageType == DamageType.LASER)
{
if (target is Player && (target as Player).Storage.Sentinel)
{
damageShd -= Maths.GetPercentage(damageShd, 30);
}
if (target is Player && (target as Player).Storage.Diminisher)
{
if ((target as Player).Storage.UnderDiminisherEntity == this)
{
damageShd += Maths.GetPercentage(damage, 30);
}
}
var laserRunCommand = AttackLaserRunCommand.write(Id, target.Id, 0, false, false);
SendCommandToInRangeCharacters(laserRunCommand);
}
else if (damageType == DamageType.ROCKET)
{
var rocketRunPacket = $"0|v|{Id}|{target.Id}|H|" + 1 + "|0|1";
SendPacketToInRangeCharacters(rocketRunPacket);
}
if (damage == 0)
{
SendCommandToInRangeCharacters(AttackMissedCommand.write(new AttackTypeModule((short)damageType), target.Id, 1), target);
if (target is Player)
{
(target as Player).SendCommand(AttackMissedCommand.write(new AttackTypeModule((short)damageType), target.Id, 0));
}
}
else
{
var attackHitCommand =
AttackHitCommand.write(new AttackTypeModule((short)damageType), Id,
target.Id, target.CurrentHitPoints,
target.CurrentShieldPoints, target.CurrentNanoHull,
damage > damageShd ? damage : damageShd, false);
SendCommandToInRangeCharacters(attackHitCommand);
}
if (damageHp >= target.CurrentHitPoints || target.CurrentHitPoints <= 0)
{
target.Destroy(this, DestructionType.MISC);
}
else
{
if (target.CurrentNanoHull > 0)
{
if (target.CurrentNanoHull - damageHp < 0)
{
var nanoDamage = damageHp - target.CurrentNanoHull;
target.CurrentNanoHull = 0;
target.CurrentHitPoints -= nanoDamage;
}
else
{
target.CurrentNanoHull -= damageHp;
}
}
else
{
target.CurrentHitPoints -= damageHp;
}
}
target.CurrentShieldPoints -= damageShd;
target.LastCombatTime = DateTime.Now;
target.UpdateStatus();
lastAttackTime = DateTime.Now;
}
}
}
public void RocketLauncherAttack(int count, RocketLauncherAmmunition rlAmmo)
{
lock (_rocketLauncherLock) {
#region {[ CHECKING ]}
if (PlayerController.Locked == null ||
PlayerController.Locked.MovementAssembly.ActualPosition()
.DistanceTo(PlayerController.MovementAssembly.ActualPosition()) > 650 ||
count <= 0)
{
return;
}
if (PlayerController.Locked.ZoneAssembly.IsInDMZ)
{
PlayerController.Send(PacketBuilder.Messages.PeaceArea());
return;
}
if (!RocketLauncherCooldown())
{
return;
}
CheckRocketLauncherCount(rlAmmo, count, out int currentCount);
#endregion
LastAttack = PlayerController.CurrentClock.ElapsedMilliseconds;
_lastRocketLauncherAttack = PlayerController.CurrentClock.ElapsedMilliseconds;
PlayerController.Account.CurrentHangar.Selection.RocketLauncherLoadedCount = 0;
ICommand attackCommand = PacketBuilder.AttackHellstormCommand(PlayerController, PlayerController.Locked, count, (short)rlAmmo.ID);
PlayerController.Send(
attackCommand,
PacketBuilder.Slotbar.RocketLauncherStateCommand(PlayerController),
PacketBuilder.Slotbar.ItemCooldownCommand("equipment_weapon_rocketlauncher_hst", (int)(3000 * PlayerController.BoosterAssembly.Get(BoosterType.ROCKET_LAUNCHER_COOLDOWN))),
PacketBuilder.Slotbar.RocketItemStatus(rlAmmo.Name, currentCount, false)
);
PlayerController.EntitesInRange(x => x.Send(attackCommand));
int hitCount = 0;
for (int i = 0; i < count; i++)
{
if (!Miss())
{
hitCount++;
}
}
if (PlayerController.Locked.EffectsAssembly.HasProtection ||
(rlAmmo.ID != RocketLauncherAmmunition.HSTRM_01.ID &&
PlayerController.Locked is PlayerController lockedPlayerController &&
lockedPlayerController.SpecialItemsAssembly.IsInvicible) ||
hitCount == 0)
{
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;
}
RocketLauncherDelayedAttack(PlayerController.Locked, rlAmmo, hitCount);
}
}
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 Attack()
{
var damage = AttackManager.RandomizeDamage(Damage, (Storage.underPLD8 ? 0.5 : 0.1));
var target = SelectedCharacter;
if (!TargetDefinition(target, false))
{
return;
}
if (target is Player player && player.AttackManager.EmpCooldown.AddMilliseconds(TimeManager.EMP_DURATION) > DateTime.Now)
{
return;
}
if (lastAttackTime.AddSeconds(1) < DateTime.Now)
{
if (target is Player && (target as Player).Storage.Spectrum)
{
damage -= Maths.GetPercentage(damage, 50);
}
int damageShd = 0, damageHp = 0;
double shieldAbsorb = System.Math.Abs(target.ShieldAbsorption - 0);
if (shieldAbsorb > 1)
{
shieldAbsorb = 1;
}
if ((target.CurrentShieldPoints - damage) >= 0)
{
damageShd = (int)(damage * shieldAbsorb);
damageHp = damage - damageShd;
}
else
{
int newDamage = damage - target.CurrentShieldPoints;
damageShd = target.CurrentShieldPoints;
damageHp = (int)(newDamage + (damageShd * shieldAbsorb));
}
if ((target.CurrentHitPoints - damageHp) < 0)
{
damageHp = target.CurrentHitPoints;
}
if (target is Player && !(target as Player).Attackable())
{
damage = 0;
damageShd = 0;
damageHp = 0;
}
if (target is Player && (target as Player).Storage.Sentinel)
{
damageShd -= Maths.GetPercentage(damageShd, 30);
}
var laserRunCommand = AttackLaserRunCommand.write(Id, target.Id, 0, false, false);
SendCommandToInRangePlayers(laserRunCommand);
if (damage == 0)
{
var attackMissedCommandToInRange = AttackMissedCommand.write(new AttackTypeModule(AttackTypeModule.LASER), target.Id, 1);
SendCommandToInRangePlayers(attackMissedCommandToInRange);
}
else
{
var attackHitCommand =
AttackHitCommand.write(new AttackTypeModule(AttackTypeModule.LASER), Id,
target.Id, target.CurrentHitPoints,
target.CurrentShieldPoints, target.CurrentNanoHull,
damage > damageShd ? damage : damageShd, false);
SendCommandToInRangePlayers(attackHitCommand);
}
if (damageHp >= target.CurrentHitPoints || target.CurrentHitPoints <= 0)
{
target.Destroy(this, DestructionType.NPC);
}
else
{
target.CurrentHitPoints -= damageHp;
}
target.CurrentShieldPoints -= damageShd;
target.LastCombatTime = DateTime.Now;
lastAttackTime = DateTime.Now;
target.UpdateStatus();
}
}
