From 66eb3b5b9599aba610ad1db5c561f8ac92d67630 Mon Sep 17 00:00:00 2001 From: FateJH Date: Fri, 7 Aug 2020 23:32:09 -0400 Subject: [PATCH] work on starfire damage profile; moved aura behavior into own folder and creates an aura container object; extended aura behavior to vehicles; applied target-control to aggravation effect --- .../objects/ballistics/AggravatedDamage.scala | 63 ++++++++----- .../aggravated}/Aura.scala | 3 +- .../aggravated/AuraContainer.scala | 21 +++++ .../aggravated}/AuraEffectBehavior.scala | 21 +++-- .../psforever/objects/GlobalDefinitions.scala | 91 +++++++++++-------- .../scala/net/psforever/objects/Player.scala | 21 +---- .../scala/net/psforever/objects/Vehicle.scala | 4 +- .../objects/avatar/PlayerControl.scala | 1 + .../objects/equipment/EffectTarget.scala | 20 +++- .../objects/vehicles/VehicleControl.scala | 29 +++++- .../vital/damage/DamageModifiers.scala | 71 ++++++++++++--- 11 files changed, 241 insertions(+), 104 deletions(-) rename common/src/main/scala/net/psforever/objects/{avatar => serverobject/aggravated}/Aura.scala (72%) create mode 100644 common/src/main/scala/net/psforever/objects/serverobject/aggravated/AuraContainer.scala rename common/src/main/scala/net/psforever/objects/{avatar => serverobject/aggravated}/AuraEffectBehavior.scala (93%) diff --git a/common/src/main/scala/net/psforever/objects/ballistics/AggravatedDamage.scala b/common/src/main/scala/net/psforever/objects/ballistics/AggravatedDamage.scala index e430bcda..a1b39ce3 100644 --- a/common/src/main/scala/net/psforever/objects/ballistics/AggravatedDamage.scala +++ b/common/src/main/scala/net/psforever/objects/ballistics/AggravatedDamage.scala @@ -1,33 +1,52 @@ // Copyright (c) 2017 PSForever package net.psforever.objects.ballistics - -import net.psforever.objects.avatar.Aura +import net.psforever.objects.equipment.TargetValidation +import net.psforever.objects.serverobject.aggravated.Aura import net.psforever.objects.vital.DamageType -final case class AggravatedInfo(damage_type : DamageType.Value, - degradation_percentage : Float, - infliction_rate : Long) { +final case class AggravatedInfo(damage_type: DamageType.Value, + degradation_percentage: Float, + infliction_rate: Long) { assert(damage_type == DamageType.Direct || damage_type == DamageType.Splash, s"aggravated damage is an unsupported type - $damage_type") } -final case class AggravatedDamage(info : List[AggravatedInfo], - effect_type : Aura.Value, - duration : Long, - max_factor : Float, - cumulative_damage_degrade : Boolean, - vanu_aggravated : Boolean) +final case class AggravatedDamage(info: List[AggravatedInfo], + effect_type: Aura.Value, + duration: Long, + max_factor: Float, + cumulative_damage_degrade: Boolean, + vanu_aggravated: Boolean, + targets: List[TargetValidation]) object AggravatedDamage { - def apply(info : AggravatedInfo, - effect_type : Aura.Value, - duration : Long, - max_factor : Float) : AggravatedDamage = - AggravatedDamage(List(info), effect_type, duration, max_factor, cumulative_damage_degrade = true, vanu_aggravated = false) + def apply(info: AggravatedInfo, + effect_type: Aura.Value, + duration: Long, + max_factor: Float, + targets: List[TargetValidation]): AggravatedDamage = + AggravatedDamage( + List(info), + effect_type, + duration, + max_factor, + cumulative_damage_degrade = true, + vanu_aggravated = false, + targets + ) - def apply(info : AggravatedInfo, - effect_type : Aura.Value, - duration : Long, - max_factor : Float, - vanu_aggravated : Boolean) : AggravatedDamage = - AggravatedDamage(List(info), effect_type, duration, max_factor, cumulative_damage_degrade = true, vanu_aggravated) + def apply(info: AggravatedInfo, + effect_type: Aura.Value, + duration: Long, + max_factor: Float, + vanu_aggravated: Boolean, + targets: List[TargetValidation]): AggravatedDamage = + AggravatedDamage( + List(info), + effect_type, + duration, + max_factor, + cumulative_damage_degrade = true, + vanu_aggravated, + targets + ) } diff --git a/common/src/main/scala/net/psforever/objects/avatar/Aura.scala b/common/src/main/scala/net/psforever/objects/serverobject/aggravated/Aura.scala similarity index 72% rename from common/src/main/scala/net/psforever/objects/avatar/Aura.scala rename to common/src/main/scala/net/psforever/objects/serverobject/aggravated/Aura.scala index 935dce50..c6883468 100644 --- a/common/src/main/scala/net/psforever/objects/avatar/Aura.scala +++ b/common/src/main/scala/net/psforever/objects/serverobject/aggravated/Aura.scala @@ -1,5 +1,4 @@ -// Copyright (c) 2020 PSForever -package net.psforever.objects.avatar +package net.psforever.objects.serverobject.aggravated object Aura extends Enumeration { final val None = Value(0) diff --git a/common/src/main/scala/net/psforever/objects/serverobject/aggravated/AuraContainer.scala b/common/src/main/scala/net/psforever/objects/serverobject/aggravated/AuraContainer.scala new file mode 100644 index 00000000..e2d617d6 --- /dev/null +++ b/common/src/main/scala/net/psforever/objects/serverobject/aggravated/AuraContainer.scala @@ -0,0 +1,21 @@ +package net.psforever.objects.serverobject.aggravated + +import net.psforever.objects.serverobject.aggravated.{Aura => AuraEffect} + +trait AuraContainer { + private var aura : Set[AuraEffect.Value] = Set.empty[AuraEffect.Value] + + def Aura : Set[AuraEffect.Value] = aura + + def AddEffectToAura(effect : AuraEffect.Value) : Set[AuraEffect.Value] = { + if(effect != AuraEffect.None) { + aura = aura + effect + } + Aura + } + + def RemoveEffectFromAura(effect : AuraEffect.Value) : Set[AuraEffect.Value] = { + aura = aura - effect + Aura + } +} diff --git a/common/src/main/scala/net/psforever/objects/avatar/AuraEffectBehavior.scala b/common/src/main/scala/net/psforever/objects/serverobject/aggravated/AuraEffectBehavior.scala similarity index 93% rename from common/src/main/scala/net/psforever/objects/avatar/AuraEffectBehavior.scala rename to common/src/main/scala/net/psforever/objects/serverobject/aggravated/AuraEffectBehavior.scala index 90da7f59..8bd09b18 100644 --- a/common/src/main/scala/net/psforever/objects/avatar/AuraEffectBehavior.scala +++ b/common/src/main/scala/net/psforever/objects/serverobject/aggravated/AuraEffectBehavior.scala @@ -1,16 +1,16 @@ // Copyright (c) 2020 PSForever -package net.psforever.objects.avatar +package net.psforever.objects.serverobject.aggravated import akka.actor.{Actor, Cancellable} -import net.psforever.objects.Player import net.psforever.objects.ballistics._ +import net.psforever.objects.serverobject.PlanetSideServerObject import net.psforever.objects.serverobject.damage.Damageable import net.psforever.objects.vital.{DamageType, Vitality} import net.psforever.types.Vector3 import scala.collection.mutable -import scala.concurrent.duration._ import scala.concurrent.ExecutionContext.Implicits.global +import scala.concurrent.duration._ trait AuraEffectBehavior { _ : Actor with Damageable => @@ -22,7 +22,7 @@ trait AuraEffectBehavior { private val entryIdToEntry: mutable.LongMap[AuraEffectBehavior.Entry] = mutable.LongMap.empty[AuraEffectBehavior.Entry] - def AuraTargetObject : Player + def AuraTargetObject : AuraEffectBehavior.Target val auraBehavior : Receive = { case AuraEffectBehavior.Aggravate(id, 0, 0) => @@ -93,7 +93,8 @@ trait AuraEffectBehavior { data.projectile.profile.Aggravated match { case Some(damage) if data.projectile.profile.ProjectileDamageTypes.contains(DamageType.Aggravated) && - damage.effect_type != Aura.None => + damage.effect_type != Aura.None && //TODO aphelion starfire + damage.targets.exists(validation => validation.test(AuraTargetObject)) => TryAggravationEffect(damage, data) case _ => ; } @@ -104,7 +105,7 @@ trait AuraEffectBehavior { val obj = AuraTargetObject if(CheckForUniqueUnqueuedProjectile(data.projectile)) { val auraEffects = obj.Aura - if(auraEffects.contains(effect) && aggravation.cumulative_damage_degrade) { //TODO cumulative? + if(auraEffects.contains(effect) && aggravation.cumulative_damage_degrade) { SetupAggravationEntry(aggravation, data) } else if(obj.AddEffectToAura(effect).diff(auraEffects).contains(effect)) { @@ -131,9 +132,9 @@ trait AuraEffectBehavior { case Some(list) => effectToEntryId -> (list :+ id) } //pair id with timer - val inflictionRate = info.infliction_rate + val inflictionRate = 1000 //info.infliction_rate val iterations = (aggravation.duration / inflictionRate).toInt - val leftoverTime = aggravation.duration % inflictionRate + val leftoverTime = aggravation.duration - (iterations * inflictionRate) entryIdToTimer += id -> context.system.scheduler.scheduleOnce(inflictionRate milliseconds, self, AuraEffectBehavior.Aggravate(id, iterations, leftoverTime)) //pair id with entry PairIdWithAggravationEntry(id, effect, inflictionRate, data, data.target, Vector3.Zero) @@ -212,7 +213,7 @@ trait AuraEffectBehavior { UpdateAggravatedEffect(AuraTargetObject) } - def UpdateAggravatedEffect(target: Player) : Unit = { + def UpdateAggravatedEffect(target: AuraEffectBehavior.Target) : Unit = { import services.avatar.{AvatarAction, AvatarServiceMessage} val zone = target.Zone val value = target.Aura.foldLeft(0)(_ + _.id) @@ -225,6 +226,8 @@ trait AuraEffectBehavior { } object AuraEffectBehavior { + type Target = PlanetSideServerObject with Vitality with AuraContainer + private case class Entry(id: Long, effect: Aura.Value, retime: Long, data: ResolvedProjectile) private case class Aggravate(id: Long, iterations: Int, leftover: Long) diff --git a/src/main/scala/net/psforever/objects/GlobalDefinitions.scala b/src/main/scala/net/psforever/objects/GlobalDefinitions.scala index e33c4dc3..462046fb 100644 --- a/src/main/scala/net/psforever/objects/GlobalDefinitions.scala +++ b/src/main/scala/net/psforever/objects/GlobalDefinitions.scala @@ -2,13 +2,13 @@ package net.psforever.objects import net.psforever.objects.avatar.Certification -import net.psforever.objects.avatar.Aura import net.psforever.objects.ballistics.{AggravatedDamage, AggravatedInfo, Projectiles} import net.psforever.objects.ce.{DeployableCategory, DeployedItem} import net.psforever.objects.definition._ import net.psforever.objects.definition.converter._ import net.psforever.objects.equipment._ import net.psforever.objects.inventory.InventoryTile +import net.psforever.objects.serverobject.aggravated.Aura import net.psforever.objects.serverobject.doors.DoorDefinition import net.psforever.objects.serverobject.generator.GeneratorDefinition import net.psforever.objects.serverobject.implantmech.ImplantTerminalMechDefinition @@ -2323,7 +2323,8 @@ object GlobalDefinitions { Aura.None, 0, 0f, - true + true, + List(TargetValidation(EffectTarget.Category.Aircraft, EffectTarget.Validation.Aircraft)) ) aphelion_starfire_projectile.ExistsOnRemoteClients = true aphelion_starfire_projectile.RemoteClientData = (39577, 249) //starfire_projectile data @@ -2454,7 +2455,11 @@ object GlobalDefinitions { AggravatedInfo(DamageType.Direct, 0.2f, 500), Aura.Comet, 0, - 10f + 10f, + List( + TargetValidation(EffectTarget.Category.Player, EffectTarget.Validation.Player), + TargetValidation(EffectTarget.Category.Vehicle, EffectTarget.Validation.Vehicle) + ) ) comet_projectile.InitialVelocity = 80 comet_projectile.Lifespan = 3.1f @@ -2609,16 +2614,17 @@ object GlobalDefinitions { 5000, 0.1f, false, - false + false, + List(TargetValidation(EffectTarget.Category.Player, EffectTarget.Validation.Player)) ) flamethrower_fireball.InitialVelocity = 15 flamethrower_fireball.Lifespan = 1.2f ProjectileDefinition.CalculateDerivedFields(flamethrower_fireball) flamethrower_fireball.Modifiers = List( - DamageModifiers.AggravatedDirect, - DamageModifiers.AggravatedDirectBurn, - DamageModifiers.AggravatedSplash, - DamageModifiers.AggravatedSplashBurn, + DamageModifiers.InfantryAggravatedDirect, + DamageModifiers.InfantryAggravatedDirectBurn, + DamageModifiers.InfantryAggravatedSplash, + DamageModifiers.InfantryAggravatedSplashBurn, DamageModifiers.RadialDegrade ) @@ -2638,7 +2644,8 @@ object GlobalDefinitions { 5000, 0.5f, false, - false + false, + List(TargetValidation(EffectTarget.Category.Player, EffectTarget.Validation.Player)) ) flamethrower_projectile.DegradeDelay = 1.0f flamethrower_projectile.DegradeMultiplier = 0.5f @@ -2646,8 +2653,8 @@ object GlobalDefinitions { flamethrower_projectile.Lifespan = 2.0f ProjectileDefinition.CalculateDerivedFields(flamethrower_projectile) flamethrower_projectile.Modifiers = List( - DamageModifiers.AggravatedDirect, - DamageModifiers.AggravatedDirectBurn, + DamageModifiers.InfantryAggravatedDirect, + DamageModifiers.InfantryAggravatedDirectBurn, DamageModifiers.MaxDistanceCutoff ) @@ -3500,19 +3507,20 @@ object GlobalDefinitions { plasma_cartridge_projectile.Aggravated = AggravatedDamage( List(AggravatedInfo(DamageType.Direct, 0.25f, 750), AggravatedInfo(DamageType.Splash, 0.25f, 1000)), Aura.Plasma, - 4000, //hard-coded default? + 3000, 1.5f, true, - false + false, + List(TargetValidation(EffectTarget.Category.Player, EffectTarget.Validation.Player)) ) plasma_cartridge_projectile.InitialVelocity = 30 plasma_cartridge_projectile.Lifespan = 15f ProjectileDefinition.CalculateDerivedFields(plasma_cartridge_projectile) plasma_cartridge_projectile.Modifiers = List( - DamageModifiers.AggravatedDirect, - DamageModifiers.AggravatedDirectBurn, - DamageModifiers.AggravatedSplash, - DamageModifiers.AggravatedSplashBurn, + DamageModifiers.InfantryAggravatedDirect, + DamageModifiers.InfantryAggravatedDirectBurn, + DamageModifiers.InfantryAggravatedSplash, + DamageModifiers.InfantryAggravatedSplashBurn, DamageModifiers.RadialDegrade ) @@ -3527,19 +3535,20 @@ object GlobalDefinitions { plasma_cartridge_projectile_b.Aggravated = AggravatedDamage( List(AggravatedInfo(DamageType.Direct, 0.25f, 750), AggravatedInfo(DamageType.Splash, 0.25f, 1000)), Aura.Plasma, - 4000, //hard-coded default? + 3000, 1.5f, true, - false + false, + List(TargetValidation(EffectTarget.Category.Player, EffectTarget.Validation.Player)) ) plasma_cartridge_projectile_b.InitialVelocity = 30 plasma_cartridge_projectile_b.Lifespan = 2f ProjectileDefinition.CalculateDerivedFields(plasma_cartridge_projectile_b) plasma_cartridge_projectile_b.Modifiers = List( - DamageModifiers.AggravatedDirect, - DamageModifiers.AggravatedDirectBurn, - DamageModifiers.AggravatedSplash, - DamageModifiers.AggravatedSplashBurn, + DamageModifiers.InfantryAggravatedDirect, + DamageModifiers.InfantryAggravatedDirectBurn, + DamageModifiers.InfantryAggravatedSplash, + DamageModifiers.InfantryAggravatedSplashBurn, DamageModifiers.RadialDegrade ) @@ -3553,19 +3562,20 @@ object GlobalDefinitions { plasma_grenade_projectile.Aggravated = AggravatedDamage( List(AggravatedInfo(DamageType.Direct, 0.25f, 750), AggravatedInfo(DamageType.Splash, 0.25f, 1000)), Aura.Plasma, - 4000, //hard-coded default? + 3000, 1.5f, true, - false + false, + List(TargetValidation(EffectTarget.Category.Player, EffectTarget.Validation.Player)) ) plasma_grenade_projectile.InitialVelocity = 30 plasma_grenade_projectile.Lifespan = 15f ProjectileDefinition.CalculateDerivedFields(plasma_grenade_projectile) plasma_grenade_projectile.Modifiers = List( - DamageModifiers.AggravatedDirect, - DamageModifiers.AggravatedDirectBurn, - DamageModifiers.AggravatedSplash, - DamageModifiers.AggravatedSplashBurn, + DamageModifiers.InfantryAggravatedDirect, + DamageModifiers.InfantryAggravatedDirectBurn, + DamageModifiers.InfantryAggravatedSplash, + DamageModifiers.InfantryAggravatedSplashBurn, DamageModifiers.RadialDegrade ) @@ -3580,19 +3590,20 @@ object GlobalDefinitions { plasma_grenade_projectile_B.Aggravated = AggravatedDamage( List(AggravatedInfo(DamageType.Direct, 0.25f, 750), AggravatedInfo(DamageType.Splash, 0.25f, 1000)), Aura.Plasma, - 4000, //hard-coded default? + 3000, 1.5f, true, - false + false, + List(TargetValidation(EffectTarget.Category.Player, EffectTarget.Validation.Player)) ) plasma_grenade_projectile_B.InitialVelocity = 30 plasma_grenade_projectile_B.Lifespan = 3f ProjectileDefinition.CalculateDerivedFields(plasma_grenade_projectile_B) plasma_grenade_projectile_B.Modifiers = List( - DamageModifiers.AggravatedDirect, - DamageModifiers.AggravatedDirectBurn, - DamageModifiers.AggravatedSplash, - DamageModifiers.AggravatedSplashBurn, + DamageModifiers.InfantryAggravatedDirect, + DamageModifiers.InfantryAggravatedDirectBurn, + DamageModifiers.InfantryAggravatedSplash, + DamageModifiers.InfantryAggravatedSplashBurn, DamageModifiers.RadialDegrade ) @@ -3899,9 +3910,10 @@ object GlobalDefinitions { starfire_projectile.Aggravated = AggravatedDamage( AggravatedInfo(DamageType.Direct, 0.25f, 250), Aura.Comet, - 0, + 3000, 0f, - true + true, + List(TargetValidation(EffectTarget.Category.Aircraft, EffectTarget.Validation.Aircraft)) ) starfire_projectile.InitialVelocity = 45 starfire_projectile.Lifespan = 7.8f @@ -3910,6 +3922,11 @@ object GlobalDefinitions { starfire_projectile.AutoLock = true starfire_projectile.Packet = projectileConverter ProjectileDefinition.CalculateDerivedFields(starfire_projectile) + starfire_projectile.Modifiers = List( + DamageModifiers.StarfireAggravated, + DamageModifiers.StarfireAggravatedBurn, + DamageModifiers.RadialDegrade + ) striker_missile_projectile.Name = "striker_missile_projectile" striker_missile_projectile.Damage0 = 35 diff --git a/src/main/scala/net/psforever/objects/Player.scala b/src/main/scala/net/psforever/objects/Player.scala index aec00096..23b329e1 100644 --- a/src/main/scala/net/psforever/objects/Player.scala +++ b/src/main/scala/net/psforever/objects/Player.scala @@ -3,7 +3,6 @@ package net.psforever.objects import net.psforever.objects.avatar.{ Avatar, - Aura => AuraEffect, LoadoutManager } import net.psforever.objects.definition.{ @@ -15,6 +14,7 @@ import net.psforever.objects.equipment.{Equipment, EquipmentSize, EquipmentSlot, import net.psforever.objects.inventory.{Container, GridInventory, InventoryItem} import net.psforever.objects.serverobject.PlanetSideServerObject import net.psforever.objects.serverobject.affinity.FactionAffinity +import net.psforever.objects.serverobject.aggravated.AuraContainer import net.psforever.objects.vital.resistance.ResistanceProfile import net.psforever.objects.vital.{DamageResistanceModel, Vitality} import net.psforever.objects.zones.ZoneAware @@ -30,7 +30,8 @@ class Player(var avatar: Avatar) with ResistanceProfile with Container with JammableUnit - with ZoneAware { + with ZoneAware + with AuraContainer { Health = 0 //player health is artificially managed as a part of their lifecycle; start entity as dead Destroyed = true //see isAlive private var backpack: Boolean = false @@ -57,8 +58,6 @@ class Player(var avatar: Avatar) private var vehicleSeated: Option[PlanetSideGUID] = None - private var aura : Set[AuraEffect.Value] = Set.empty[AuraEffect.Value] - Continent = "home2" //the zone id var spectator: Boolean = false @@ -356,20 +355,6 @@ class Player(var avatar: Avatar) AwayFromKeyboard } - def Aura : Set[AuraEffect.Value] = aura - - def AddEffectToAura(effect : AuraEffect.Value) : Set[AuraEffect.Value] = { - if(effect != AuraEffect.None) { - aura = aura + effect - } - Aura - } - - def RemoveEffectFromAura(effect : AuraEffect.Value) : Set[AuraEffect.Value] = { - aura = aura - effect - Aura - } - private var usingSpecial: SpecialExoSuitDefinition.Mode.Value => SpecialExoSuitDefinition.Mode.Value = DefaultUsingSpecial diff --git a/src/main/scala/net/psforever/objects/Vehicle.scala b/src/main/scala/net/psforever/objects/Vehicle.scala index d108fad3..b927791f 100644 --- a/src/main/scala/net/psforever/objects/Vehicle.scala +++ b/src/main/scala/net/psforever/objects/Vehicle.scala @@ -7,6 +7,7 @@ import net.psforever.objects.inventory.{Container, GridInventory, InventoryItem, import net.psforever.objects.serverobject.mount.Mountable import net.psforever.objects.serverobject.PlanetSideServerObject import net.psforever.objects.serverobject.affinity.FactionAffinity +import net.psforever.objects.serverobject.aggravated.AuraContainer import net.psforever.objects.serverobject.deploy.Deployment import net.psforever.objects.serverobject.hackable.Hackable import net.psforever.objects.serverobject.structures.AmenityOwner @@ -78,7 +79,8 @@ class Vehicle(private val vehicleDef: VehicleDefinition) with StandardResistanceProfile with JammableUnit with CommonNtuContainer - with Container { + with Container + with AuraContainer { private var faction: PlanetSideEmpire.Value = PlanetSideEmpire.NEUTRAL private var shields: Int = 0 private var decal: Int = 0 diff --git a/src/main/scala/net/psforever/objects/avatar/PlayerControl.scala b/src/main/scala/net/psforever/objects/avatar/PlayerControl.scala index 09d0550c..99b02a39 100644 --- a/src/main/scala/net/psforever/objects/avatar/PlayerControl.scala +++ b/src/main/scala/net/psforever/objects/avatar/PlayerControl.scala @@ -8,6 +8,7 @@ import net.psforever.objects.ballistics.{PlayerSource, ResolvedProjectile} import net.psforever.objects.equipment._ import net.psforever.objects.inventory.{GridInventory, InventoryItem} import net.psforever.objects.loadouts.Loadout +import net.psforever.objects.serverobject.aggravated.AuraEffectBehavior import net.psforever.objects.serverobject.containable.{Containable, ContainableBehavior} import net.psforever.objects.vital.{PlayerSuicide, Vitality} import net.psforever.objects.serverobject.{CommonMessages, PlanetSideServerObject} diff --git a/src/main/scala/net/psforever/objects/equipment/EffectTarget.scala b/src/main/scala/net/psforever/objects/equipment/EffectTarget.scala index d69ee638..7bfc8f28 100644 --- a/src/main/scala/net/psforever/objects/equipment/EffectTarget.scala +++ b/src/main/scala/net/psforever/objects/equipment/EffectTarget.scala @@ -89,10 +89,10 @@ object EffectTarget { false } - def AMS(target: PlanetSideGameObject): Boolean = + def Vehicle(target: PlanetSideGameObject): Boolean = target match { case v: Vehicle => - v.Health > 0 && v.Definition == GlobalDefinitions.ams + v.Health > 0 case _ => false } @@ -104,5 +104,21 @@ object EffectTarget { case _ => false } + + def AMS(target: PlanetSideGameObject): Boolean = + target match { + case v: Vehicle => + v.Health > 0 && v.Definition == GlobalDefinitions.ams + case _ => + false + } + + def Aircraft(target: PlanetSideGameObject): Boolean = + target match { + case v: Vehicle => + GlobalDefinitions.isFlightVehicle(v.Definition) && v.Health > 0 + case _ => + false + } } } diff --git a/src/main/scala/net/psforever/objects/vehicles/VehicleControl.scala b/src/main/scala/net/psforever/objects/vehicles/VehicleControl.scala index 1e8a4038..c92689bc 100644 --- a/src/main/scala/net/psforever/objects/vehicles/VehicleControl.scala +++ b/src/main/scala/net/psforever/objects/vehicles/VehicleControl.scala @@ -10,7 +10,9 @@ import net.psforever.objects.inventory.{GridInventory, InventoryItem} import net.psforever.objects.serverobject.CommonMessages import net.psforever.objects.serverobject.mount.{Mountable, MountableBehavior} import net.psforever.objects.serverobject.affinity.{FactionAffinity, FactionAffinityBehavior} +import net.psforever.objects.serverobject.aggravated.AuraEffectBehavior import net.psforever.objects.serverobject.containable.{Containable, ContainableBehavior} +import net.psforever.objects.serverobject.damage.Damageable.Target import net.psforever.objects.serverobject.damage.DamageableVehicle import net.psforever.objects.serverobject.deploy.Deployment.DeploymentObject import net.psforever.objects.serverobject.deploy.{Deployment, DeploymentBehavior} @@ -51,7 +53,8 @@ class VehicleControl(vehicle: Vehicle) with RepairableVehicle with JammableMountedWeapons with ContainableBehavior - with AntTransferBehavior { + with AntTransferBehavior + with AuraEffectBehavior { //make control actors belonging to utilities when making control actor belonging to vehicle vehicle.Utilities.foreach({ case (_, util) => util.Setup }) @@ -74,7 +77,9 @@ class VehicleControl(vehicle: Vehicle) def ChargeTransferObject = vehicle - if (vehicle.Definition == GlobalDefinitions.ant) { + def AuraTargetObject = vehicle + + if(vehicle.Definition == GlobalDefinitions.ant) { findChargeTargetFunc = Vehicles.FindANTChargingSource findDischargeTargetFunc = Vehicles.FindANTDischargingTarget } @@ -95,6 +100,7 @@ class VehicleControl(vehicle: Vehicle) context.stop(util().Actor) util().Actor = Default.Actor } + EndAllEffects() } def Enabled: Receive = @@ -103,6 +109,7 @@ class VehicleControl(vehicle: Vehicle) .orElse(cargoBehavior) .orElse(jammableBehavior) .orElse(takesDamage) + .orElse(auraBehavior) .orElse(canBeRepairedByNanoDispenser) .orElse(containerBehavior) .orElse(antBehavior) @@ -579,6 +586,24 @@ class VehicleControl(vehicle: Vehicle) } out } + + override def DamageAwareness( + target: Target, + cause: ResolvedProjectile, + amount: Int + ): Unit = { + TryAggravationEffect(cause) + super.DamageAwareness(target, cause, amount) + } + + override def DestructionAwareness( + target: Target, + cause: ResolvedProjectile + ): Unit = { + //aura effects cancel + EndAllEffects() + super.DestructionAwareness(target, cause) + } } object VehicleControl { diff --git a/src/main/scala/net/psforever/objects/vital/damage/DamageModifiers.scala b/src/main/scala/net/psforever/objects/vital/damage/DamageModifiers.scala index bb7aedc9..7b508fb8 100644 --- a/src/main/scala/net/psforever/objects/vital/damage/DamageModifiers.scala +++ b/src/main/scala/net/psforever/objects/vital/damage/DamageModifiers.scala @@ -1,7 +1,8 @@ // Copyright (c) 2020 PSForever package net.psforever.objects.vital.damage -import net.psforever.objects.ballistics.{PlayerSource, ProjectileResolution, ResolvedProjectile} +import net.psforever.objects.GlobalDefinitions +import net.psforever.objects.ballistics.{PlayerSource, ProjectileResolution, ResolvedProjectile, VehicleSource} import net.psforever.objects.vital.DamageType import net.psforever.types.{ExoSuitType, Vector3} @@ -134,22 +135,22 @@ object DamageModifiers { } } - case object AggravatedDirect extends Mod { + case object InfantryAggravatedDirect extends Mod { def Calculate: DamageModifiers.Format = BaseAggravatedFormula(ProjectileResolution.AggravatedDirect, DamageType.Direct) } - case object AggravatedSplash extends Mod { + case object InfantryAggravatedSplash extends Mod { def Calculate: DamageModifiers.Format = BaseAggravatedFormula(ProjectileResolution.AggravatedSplash, DamageType.Splash) } - case object AggravatedDirectBurn extends Mod { + case object InfantryAggravatedDirectBurn extends Mod { def Calculate: DamageModifiers.Format = BaseAggravatedBurnFormula(ProjectileResolution.AggravatedDirectBurn, DamageType.Direct) } - case object AggravatedSplashBurn extends Mod { + case object InfantryAggravatedSplashBurn extends Mod { def Calculate: DamageModifiers.Format = BaseAggravatedBurnFormula(ProjectileResolution.AggravatedSplashBurn, DamageType.Splash) } @@ -164,14 +165,18 @@ object DamageModifiers { ): Int = { if (data.resolution == resolution) { (data.projectile.profile.Aggravated, data.target) match { - case (Some(aggravation), p: PlayerSource) if p.ExoSuit == ExoSuitType.MAX => - val aggravatedDirectDamage = (aggravation.info.find(_.damage_type == damageType) match { + case (Some(aggravation), p: PlayerSource) => + val aggravatedDamage = aggravation.info.find(_.damage_type == damageType) match { case Some(infos) => - damage * infos.degradation_percentage + damage * infos.degradation_percentage + damage case _ => damage toFloat - }) * aggravation.max_factor - damage + aggravatedDirectDamage toInt + } + if(p.ExoSuit == ExoSuitType.MAX) { + (aggravatedDamage * aggravation.max_factor) toInt + } else { + aggravatedDamage toInt + } case _ => damage } @@ -214,10 +219,54 @@ object DamageModifiers { } } case _ => - damage + 0 } } else { damage } } + + case object StarfireAggravated extends Mod { + def Calculate: DamageModifiers.Format = formula + + private def formula(damage: Int, data: ResolvedProjectile): Int = { + if (data.resolution == ProjectileResolution.AggravatedDirect) { + (data.projectile.profile.Aggravated, data.target) match { + case (Some(aggravation), v : VehicleSource) if GlobalDefinitions.isFlightVehicle(v.Definition) => + aggravation.info.find(_.damage_type == DamageType.Direct) match { + case Some(infos) => + (damage * infos.degradation_percentage + damage) toInt + case _ => + damage + } + case _ => + damage + } + } else { + damage + } + } + } + + case object StarfireAggravatedBurn extends Mod { + def Calculate: DamageModifiers.Format = formula + + private def formula(damage: Int, data: ResolvedProjectile): Int = { + if (data.resolution == ProjectileResolution.AggravatedDirectBurn) { + (data.projectile.profile.Aggravated, data.target) match { + case (Some(aggravation), v : VehicleSource) if GlobalDefinitions.isFlightVehicle(v.Definition) => + aggravation.info.find(_.damage_type == DamageType.Direct) match { + case Some(infos) => + (damage * infos.degradation_percentage) toInt + case _ => + damage + } + case _ => + 0 + } + } else { + damage + } + } + } }