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

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.equipment.TargetValidation
-import net.psforever.objects.avatar.Aura
+import net.psforever.objects.serverobject.aggravated.Aura
 import net.psforever.objects.vital.DamageType
 
-final case class AggravatedInfo(damage_type : DamageType.Value,
+final case class AggravatedInfo(damage_type: DamageType.Value,
-                                degradation_percentage : Float,
+                                degradation_percentage: Float,
-                                infliction_rate : Long) {
+                                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],
+final case class AggravatedDamage(info: List[AggravatedInfo],
-                                  effect_type : Aura.Value,
+                                  effect_type: Aura.Value,
-                                  duration : Long,
+                                  duration: Long,
-                                  max_factor : Float,
+                                  max_factor: Float,
-                                  cumulative_damage_degrade : Boolean,
+                                  cumulative_damage_degrade: Boolean,
-                                  vanu_aggravated : Boolean)
+                                  vanu_aggravated: Boolean,
+                                  targets: List[TargetValidation])
 
 object AggravatedDamage {
-  def apply(info : AggravatedInfo,
+  def apply(info: AggravatedInfo,
-            effect_type : Aura.Value,
+            effect_type: Aura.Value,
-            duration : Long,
+            duration: Long,
-            max_factor : Float) : AggravatedDamage =
+            max_factor: Float,
-    AggravatedDamage(List(info), effect_type, duration, max_factor, cumulative_damage_degrade = true, vanu_aggravated = false)
+            targets: List[TargetValidation]): AggravatedDamage =
+    AggravatedDamage(
+      List(info),
+      effect_type,
+      duration,
+      max_factor,
+      cumulative_damage_degrade = true,
+      vanu_aggravated = false,
+      targets
+    )
 
-  def apply(info : AggravatedInfo,
+  def apply(info: AggravatedInfo,
-            effect_type : Aura.Value,
+            effect_type: Aura.Value,
-            duration : Long,
+            duration: Long,
-            max_factor : Float,
+            max_factor: Float,
-            vanu_aggravated : Boolean) : AggravatedDamage =
+            vanu_aggravated: Boolean,
-    AggravatedDamage(List(info), effect_type, duration, max_factor, cumulative_damage_degrade = true, vanu_aggravated)
+            targets: List[TargetValidation]): AggravatedDamage =
+    AggravatedDamage(
+      List(info),
+      effect_type,
+      duration,
+      max_factor,
+      cumulative_damage_degrade = true,
+      vanu_aggravated,
+      targets
+    )
 }

common/src/main/scala/net/psforever/objects/serverobject/aggravated/Aura.scala

@@ -1,5 +1,4 @@
-// Copyright (c) 2020 PSForever
+package net.psforever.objects.serverobject.aggravated
-package net.psforever.objects.avatar
 
 object Aura extends Enumeration {
   final val None = Value(0)

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
+  }
+}

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)

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.InfantryAggravatedDirect,
-      DamageModifiers.AggravatedDirectBurn,
+      DamageModifiers.InfantryAggravatedDirectBurn,
-      DamageModifiers.AggravatedSplash,
+      DamageModifiers.InfantryAggravatedSplash,
-      DamageModifiers.AggravatedSplashBurn,
+      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.InfantryAggravatedDirect,
-      DamageModifiers.AggravatedDirectBurn,
+      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.InfantryAggravatedDirect,
-      DamageModifiers.AggravatedDirectBurn,
+      DamageModifiers.InfantryAggravatedDirectBurn,
-      DamageModifiers.AggravatedSplash,
+      DamageModifiers.InfantryAggravatedSplash,
-      DamageModifiers.AggravatedSplashBurn,
+      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.InfantryAggravatedDirect,
-      DamageModifiers.AggravatedDirectBurn,
+      DamageModifiers.InfantryAggravatedDirectBurn,
-      DamageModifiers.AggravatedSplash,
+      DamageModifiers.InfantryAggravatedSplash,
-      DamageModifiers.AggravatedSplashBurn,
+      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.InfantryAggravatedDirect,
-      DamageModifiers.AggravatedDirectBurn,
+      DamageModifiers.InfantryAggravatedDirectBurn,
-      DamageModifiers.AggravatedSplash,
+      DamageModifiers.InfantryAggravatedSplash,
-      DamageModifiers.AggravatedSplashBurn,
+      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.InfantryAggravatedDirect,
-      DamageModifiers.AggravatedDirectBurn,
+      DamageModifiers.InfantryAggravatedDirectBurn,
-      DamageModifiers.AggravatedSplash,
+      DamageModifiers.InfantryAggravatedSplash,
-      DamageModifiers.AggravatedSplashBurn,
+      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

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
 

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

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}

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
+      }
   }
 }

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 {

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 =>
+        case (Some(aggravation), p: PlayerSource) =>
-          val aggravatedDirectDamage = (aggravation.info.find(_.damage_type == damageType) match {
+          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
+      }
+    }
+  }
 }