introduction of aggravated damage properties and modification of damage pathways such that 'aggravated' is treated as a unique damage type

common/src/main/scala/net/psforever/objects/ballistics/AggravatedDamage.scala

@@ -0,0 +1,37 @@
+// Copyright (c) 2017 PSForever
+package net.psforever.objects.ballistics
+
+import net.psforever.objects.vital.DamageType
+
+object AggravatedEffect extends Enumeration {
+  type Type = Value
+  val Comet, Fire, Plasma, Napalm, None = Value
+}
+
+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 : AggravatedEffect.Value,
+                                  duration : Long,
+                                  max_factor : Float,
+                                  cumulative_damage_degrade : Boolean,
+                                  vanu_aggravated : Boolean)
+
+object AggravatedDamage {
+  def apply(info : AggravatedInfo,
+            effect_type : AggravatedEffect.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 : AggravatedEffect.Value,
+            duration : Long,
+            max_factor : Float,
+            vanu_aggravated : Boolean) : AggravatedDamage =
+    AggravatedDamage(List(info), effect_type, duration, max_factor, cumulative_damage_degrade = true, vanu_aggravated)
+}

common/src/main/scala/net/psforever/objects/vital/StandardDamages.scala

@@ -0,0 +1,176 @@
+// Copyright (c) 2017 PSForever
+//package net.psforever.objects.vital
+//
+//import net.psforever.objects.vital.StandardAmenityDamage.None
+//import net.psforever.objects.vital.StandardDeployableDamage.None
+//import net.psforever.objects.vital.damage._
+//import net.psforever.objects.vital.damage.DamageCalculations._
+//import net.psforever.objects.vital.projectile.ProjectileCalculations
+//
+///**
+//  * A protected super class for calculating "no damage."
+//  * Used for `NoDamage` but also for the base of `*LashDamage` calculation objects
+//  * to maintain the polymorphic identity of `DamageCalculations`.
+//  */
+//protected class NoDamageBase
+//    extends DamageCalculations(
+//      DamageCalculations.NoDamage,
+//      DamageWithModifiers(NoDamageAgainst),
+//      TooFar
+//    )
+//
+//object NoDamage extends NoDamageBase
+//
+//object InfantryHitDamage
+//    extends DamageCalculations(
+//      DirectHitDamageWithDegrade,
+//      DamageWithModifiers(DamageAgainstExoSuit),
+//      DistanceBetweenTargetandSource
+//    )
+//
+//object MaxHitDamage
+//    extends DamageCalculations(
+//      DirectHitDamageWithDegrade,
+//      DamageWithModifiers(DamageAgainstMaxSuit),
+//      DistanceBetweenTargetandSource
+//    )
+//
+//object VehicleHitDamage
+//    extends DamageCalculations(
+//      DirectHitDamageWithDegrade,
+//      DamageWithModifiers(DamageAgainstVehicle),
+//      DistanceBetweenTargetandSource
+//    )
+//
+//object AircraftHitDamage
+//    extends DamageCalculations(
+//      DirectHitDamageWithDegrade,
+//      DamageWithModifiers(DamageAgainstAircraft),
+//      DistanceBetweenTargetandSource
+//    )
+//
+//object InfantrySplashDamage
+//    extends DamageCalculations(
+//      SplashDamageWithRadialDegrade,
+//      DamageWithModifiers(DamageAgainstExoSuit),
+//      DistanceFromExplosionToTarget
+//    )
+//
+//object MaxSplashDamage
+//    extends DamageCalculations(
+//      SplashDamageWithRadialDegrade,
+//      DamageWithModifiers(DamageAgainstMaxSuit),
+//      DistanceFromExplosionToTarget
+//    )
+//
+//object VehicleSplashDamage
+//    extends DamageCalculations(
+//      SplashDamageWithRadialDegrade,
+//      DamageWithModifiers(DamageAgainstVehicle),
+//      DistanceFromExplosionToTarget
+//    )
+//
+//object AircraftSplashDamage
+//    extends DamageCalculations(
+//      SplashDamageWithRadialDegrade,
+//      DamageWithModifiers(DamageAgainstAircraft),
+//      DistanceFromExplosionToTarget
+//    )
+//
+//object InfantrySplashDamageDirect
+//    extends DamageCalculations(
+//      SplashDamageWithRadialDegrade,
+//      DamageWithModifiers(DamageAgainstAircraft),
+//      NoDistance
+//    )
+//
+//object InfantryLashDamage
+//    extends DamageCalculations(
+//      LashDamage,
+//      DamageWithModifiers(DamageAgainstExoSuit),
+//      DistanceBetweenTargetandSource
+//    )
+//
+//object MaxLashDamage
+//    extends DamageCalculations(
+//      LashDamage,
+//      DamageWithModifiers(DamageAgainstMaxSuit),
+//      DistanceBetweenTargetandSource
+//    )
+//
+//object VehicleLashDamage
+//    extends DamageCalculations(
+//      LashDamage,
+//      DamageWithModifiers(DamageAgainstVehicle),
+//      DistanceBetweenTargetandSource
+//    )
+//
+//object AircraftLashDamage
+//    extends DamageCalculations(
+//      LashDamage,
+//      DamageWithModifiers(DamageAgainstAircraft),
+//      DistanceBetweenTargetandSource
+//    )
+//
+//object AmenityHitDamage
+//    extends DamageCalculations(
+//      DirectHitDamageWithDegrade,
+//      DamageWithModifiers(DamageAgainstVehicle),
+//      DistanceBetweenTargetandSource
+//    )
+//
+//object AmenitySplashDamage
+//    extends DamageCalculations(
+//      SplashDamageWithRadialDegrade,
+//      DamageWithModifiers(DamageAgainstVehicle),
+//      DistanceFromExplosionToTarget
+//    )
+//
+//object NoDamageSelection extends DamageSelection {
+//  def Direct = None
+//  def Splash = None
+//  def Lash   = None
+//  def Aggravated : ProjectileCalculations.Form = None
+//}
+//
+//object StandardInfantryDamage extends DamageSelection {
+//  def Direct : ProjectileCalculations.Form = InfantryHitDamage.Calculate
+//  def Splash : ProjectileCalculations.Form = InfantrySplashDamage.Calculate
+//  def Lash : ProjectileCalculations.Form = InfantryLashDamage.Calculate
+//  def Aggravated : ProjectileCalculations.Form = InfantrySplashDamage.Calculate
+//}
+//
+//object StandardMaxDamage extends DamageSelection {
+//  def Direct : ProjectileCalculations.Form = MaxHitDamage.Calculate
+//  def Splash : ProjectileCalculations.Form = MaxSplashDamage.Calculate
+//  def Lash : ProjectileCalculations.Form = MaxLashDamage.Calculate
+//  def Aggravated : ProjectileCalculations.Form = None
+//}
+//
+//object StandardVehicleDamage extends DamageSelection {
+//  def Direct : ProjectileCalculations.Form = VehicleHitDamage.Calculate
+//  def Splash : ProjectileCalculations.Form = VehicleSplashDamage.Calculate
+//  def Lash : ProjectileCalculations.Form = VehicleLashDamage.Calculate
+//  def Aggravated : ProjectileCalculations.Form = None
+//}
+//
+//object StandardAircraftDamage extends DamageSelection {
+//  def Direct : ProjectileCalculations.Form = AircraftHitDamage.Calculate
+//  def Splash : ProjectileCalculations.Form = AircraftSplashDamage.Calculate
+//  def Lash : ProjectileCalculations.Form = AircraftLashDamage.Calculate
+//  def Aggravated : ProjectileCalculations.Form = None
+//}
+//
+//object StandardDeployableDamage extends DamageSelection {
+//  def Direct : ProjectileCalculations.Form = VehicleHitDamage.Calculate
+//  def Splash : ProjectileCalculations.Form = VehicleSplashDamage.Calculate
+//  def Lash : ProjectileCalculations.Form = NoDamage.Calculate
+//  def Aggravated : ProjectileCalculations.Form = None
+//}
+//
+//object StandardAmenityDamage extends DamageSelection {
+//  def Direct : ProjectileCalculations.Form = AmenityHitDamage.Calculate
+//  def Splash : ProjectileCalculations.Form = AmenitySplashDamage.Calculate
+//  def Lash : ProjectileCalculations.Form = NoDamage.Calculate
+//  def Aggravated : ProjectileCalculations.Form = None
+//}

common/src/main/scala/net/psforever/objects/vital/damage/DamageSelection.scala

@@ -0,0 +1,35 @@
+// Copyright (c) 2017 PSForever
+//package net.psforever.objects.vital.damage
+//
+//import net.psforever.objects.ballistics.ResolvedProjectile
+//import net.psforever.objects.vital.{DamageType, NoDamage}
+//import net.psforever.objects.vital.projectile.ProjectileCalculations
+//
+///**
+//  * Maintain information about three primary forms of damage calculation
+//  * and a means to test which calculation is valid in a given situation.
+//  */
+//trait DamageSelection {
+//  final def None: ProjectileCalculations.Form = NoDamage
+//
+//  def Direct : ProjectileCalculations.Form
+//  def Splash : ProjectileCalculations.Form
+//  def Lash : ProjectileCalculations.Form
+//  def Aggravated : ProjectileCalculations.Form
+//
+//  def apply(data : ResolvedProjectile) : ProjectileCalculations.Form = data.projectile.profile.ProjectileDamageType match {
+//    case DamageType.Direct =>     Direct
+//    case DamageType.Splash =>     Splash
+//    case DamageType.Lash =>       Lash
+//    case DamageType.Aggravated => Aggravated
+//    case _ => None
+//  }
+//
+//  def apply(res : DamageType.Value) : ProjectileCalculations.Form = res match {
+//    case DamageType.Direct =>     Direct
+//    case DamageType.Splash =>     Splash
+//    case DamageType.Lash =>       Lash
+//    case DamageType.Aggravated => Aggravated
+//    case _ => None
+//  }
+//}

src/main/scala/net/psforever/actors/session/SessionActor.scala

@@ -744,7 +744,7 @@ class SessionActor extends Actor with MDCContextAware {
                     unk7 = 0
                   )
                 ) //repeat of our entry
-                val playerGuid = player.GUID
+              val playerGuid = player.GUID
                 //turn lfs off
                 val factionChannel = s"${player.Faction}"
                 if (avatar.lookingForSquad) {
@@ -897,7 +897,7 @@ class SessionActor extends Actor with MDCContextAware {
                     SquadUIElement(element.name, element.index, entry.zone_number, entry.health, entry.armor, entry.pos)
                   entry
                 case (entry, element)
-                    if entry.health != element.health || entry.armor != element.armor || entry.pos != element.position =>
+                  if entry.health != element.health || entry.armor != element.armor || entry.pos != element.position =>
                   //other elements that need to be updated
                   squadUI(entry.char_id) =
                     SquadUIElement(element.name, element.index, entry.zone_number, entry.health, entry.armor, entry.pos)
@@ -1291,6 +1291,49 @@ class SessionActor extends Actor with MDCContextAware {
           taskResolver ! RegisterNewAvatar(player)
       }
 
+    case msg @ Zoning.InstantAction.Located(zone, _, spawn_point) =>
+      //in between subsequent reply messages, it does not matter if the destination changes
+      //so long as there is at least one destination at all (including the fallback)
+      if (ContemplateZoningResponse(Zoning.InstantAction.Request(player.Faction), cluster)) {
+        val (pos, ori) = spawn_point.SpecificPoint(player)
+        SpawnThroughZoningProcess(zone, pos, ori)
+      } else if (zoningStatus != Zoning.Status.None) {
+        instantActionFallbackDestination = Some(msg)
+      }
+
+    case Zoning.InstantAction.NotLocated() =>
+      instantActionFallbackDestination match {
+        case Some(Zoning.InstantAction.Located(zone, _, spawn_point))
+          if spawn_point.Owner.Faction == player.Faction && !spawn_point.Offline =>
+          if (ContemplateZoningResponse(Zoning.InstantAction.Request(player.Faction), cluster)) {
+            val (pos, ori) = spawn_point.SpecificPoint(player)
+            SpawnThroughZoningProcess(zone, pos, ori)
+          } else if (zoningCounter == 0) {
+            CancelZoningProcessWithReason("@InstantActionNoHotspotsAvailable")
+          }
+        case _ =>
+          //no instant action available
+          CancelZoningProcessWithReason("@InstantActionNoHotspotsAvailable")
+      }
+
+    case Zoning.Recall.Located(zone, spawn_point) =>
+      if (ContemplateZoningResponse(Zoning.Recall.Request(player.Faction, zone.Id), cluster)) {
+        val (pos, ori) = spawn_point.SpecificPoint(player)
+        SpawnThroughZoningProcess(zone, pos, ori)
+      }
+
+    case Zoning.Recall.Denied(reason) =>
+      CancelZoningProcessWithReason(s"@norecall_sanctuary_$reason", Some(ChatMessageType.CMT_QUIT))
+
+    case Zoning.Quit() =>
+      if (ContemplateZoningResponse(Zoning.Quit(), self)) {
+        log.info("Good-bye")
+        ImmediateDisconnect()
+      }
+
+    case ZoningReset() =>
+      CancelZoningProcess()
+
     case NewPlayerLoaded(tplayer) =>
       //new zone
       log.info(s"Player ${tplayer.Name} has been loaded")
@@ -1402,7 +1445,7 @@ class SessionActor extends Actor with MDCContextAware {
       } else if (tplayer.isAlive) {
         if (
           zoneLoaded.contains(true) &&
-          tplayer.HasGUID && tplayer.Actor != Default.Actor && (continent.GUID(tplayer.VehicleSeated) match {
+            tplayer.HasGUID && tplayer.Actor != Default.Actor && (continent.GUID(tplayer.VehicleSeated) match {
             case Some(o: Vehicle) => o.HasGUID && o.Actor != Default.Actor && !o.Destroyed
             case _                => true
           })
@@ -1566,11 +1609,11 @@ class SessionActor extends Actor with MDCContextAware {
       }
 
     case msg @ Containable.ItemPutInSlot(
-          _: PlanetSideServerObject with Container,
-          _: Equipment,
-          _: Int,
-          _: Option[Equipment]
-        ) =>
+    _: PlanetSideServerObject with Container,
+    _: Equipment,
+    _: Int,
+    _: Option[Equipment]
+    ) =>
       log.info(s"$msg")
 
     case msg @ Containable.CanNotPutItemInSlot(_: PlanetSideServerObject with Container, _: Equipment, _: Int) =>
@@ -1972,19 +2015,19 @@ class SessionActor extends Actor with MDCContextAware {
         }
 
       case AvatarResponse.PlayerState(
-            pos,
-            vel,
-            yaw,
-            pitch,
-            yaw_upper,
-            seq_time,
-            is_crouching,
-            is_jumping,
-            jump_thrust,
-            is_cloaking,
-            spectating,
-            weaponInHand
-          ) =>
+      pos,
+      vel,
+      yaw,
+      pitch,
+      yaw_upper,
+      seq_time,
+      is_crouching,
+      is_jumping,
+      jump_thrust,
+      is_cloaking,
+      spectating,
+      weaponInHand
+      ) =>
         if (tplayer_guid != guid) {
           val now = System.currentTimeMillis()
           val (location, time, distanceSq): (Vector3, Long, Float) = if (spectating) {
@@ -2815,18 +2858,18 @@ class SessionActor extends Actor with MDCContextAware {
         }
 
       case VehicleResponse.VehicleState(
-            vehicle_guid,
-            unk1,
-            pos,
-            ang,
-            vel,
-            unk2,
-            unk3,
-            unk4,
-            wheel_direction,
-            unk5,
-            unk6
-          ) =>
+      vehicle_guid,
+      unk1,
+      pos,
+      ang,
+      vel,
+      unk2,
+      unk3,
+      unk4,
+      wheel_direction,
+      unk5,
+      unk6
+      ) =>
         if (tplayer_guid != guid) {
           sendResponse(
             VehicleStateMessage(vehicle_guid, unk1, pos, ang, vel, unk2, unk3, unk4, wheel_direction, unk5, unk6)
@@ -2960,10 +3003,10 @@ class SessionActor extends Actor with MDCContextAware {
     * @return a tuple composed of an `ObjectAttachMessage` packet and a `CargoMountPointStatusMessage` packet
     */
   def CargoMountBehaviorForUs(
-      carrier: Vehicle,
-      cargo: Vehicle,
-      mountPoint: Int
-  ): (ObjectAttachMessage, CargoMountPointStatusMessage) = {
+                               carrier: Vehicle,
+                               cargo: Vehicle,
+                               mountPoint: Int
+                             ): (ObjectAttachMessage, CargoMountPointStatusMessage) = {
     val msgs @ (attachMessage, mountPointStatusMessage) = CargoBehavior.CargoMountMessages(carrier, cargo, mountPoint)
     CargoMountMessagesForUs(attachMessage, mountPointStatusMessage)
     msgs
@@ -2977,9 +3020,9 @@ class SessionActor extends Actor with MDCContextAware {
     * @param mountPointStatusMessage a `CargoMountPointStatusMessage` packet suitable for initializing cargo operations
     */
   def CargoMountMessagesForUs(
-      attachMessage: ObjectAttachMessage,
-      mountPointStatusMessage: CargoMountPointStatusMessage
-  ): Unit = {
+                               attachMessage: ObjectAttachMessage,
+                               mountPointStatusMessage: CargoMountPointStatusMessage
+                             ): Unit = {
     sendResponse(attachMessage)
     sendResponse(mountPointStatusMessage)
   }
@@ -3743,21 +3786,21 @@ class SessionActor extends Actor with MDCContextAware {
         zoneLoaded = Some(true)
 
       case msg @ PlayerStateMessageUpstream(
-            avatar_guid,
-            pos,
-            vel,
-            yaw,
-            pitch,
-            yaw_upper,
-            seq_time,
-            unk3,
-            is_crouching,
-            is_jumping,
-            jump_thrust,
-            is_cloaking,
-            unk5,
-            unk6
-          ) =>
+      avatar_guid,
+      pos,
+      vel,
+      yaw,
+      pitch,
+      yaw_upper,
+      seq_time,
+      unk3,
+      is_crouching,
+      is_jumping,
+      jump_thrust,
+      is_cloaking,
+      unk5,
+      unk6
+      ) =>
         //log.info(s"$msg")
         persist()
         turnCounterFunc(avatar_guid)
@@ -3872,18 +3915,18 @@ class SessionActor extends Actor with MDCContextAware {
         }
 
       case msg @ VehicleStateMessage(
-            vehicle_guid,
-            unk1,
-            pos,
-            ang,
-            vel,
-            flying,
-            unk6,
-            unk7,
-            wheels,
-            is_decelerating,
-            is_cloaked
-          ) =>
+      vehicle_guid,
+      unk1,
+      pos,
+      ang,
+      vel,
+      flying,
+      unk6,
+      unk7,
+      wheels,
+      is_decelerating,
+      is_cloaked
+      ) =>
         //log.info(s"$msg")
         GetVehicleAndSeat() match {
           case (Some(obj), Some(0)) =>
@@ -4107,7 +4150,7 @@ class SessionActor extends Actor with MDCContextAware {
               //the decimator does not send a ChangeFireState_Start on the last shot
               if (
                 tool.Definition == GlobalDefinitions.phoenix &&
-                tool.Projectile != GlobalDefinitions.phoenix_missile_guided_projectile
+                  tool.Projectile != GlobalDefinitions.phoenix_missile_guided_projectile
               ) {
                 //suppress the decimator's alternate fire mode, however
                 continent.AvatarEvents ! AvatarServiceMessage(
@@ -4232,12 +4275,12 @@ class SessionActor extends Actor with MDCContextAware {
                   }
                   val sumReloadValue: Int = box.Capacity + tailReloadValue
                   val actualReloadValue = (if (sumReloadValue <= reloadValue) {
-                                             deleteFunc(box)
-                                             sumReloadValue
-                                           } else {
-                                             modifyFunc(box, reloadValue - tailReloadValue)
-                                             reloadValue
-                                           }) + currentMagazine
+                    deleteFunc(box)
+                    sumReloadValue
+                  } else {
+                    modifyFunc(box, reloadValue - tailReloadValue)
+                    reloadValue
+                  }) + currentMagazine
                   log.info(s"ReloadMessage: success, $tool <- $actualReloadValue ${tool.AmmoType}")
                   tool.Magazine = actualReloadValue
                   sendResponse(ReloadMessage(item_guid, actualReloadValue, unk1))
@@ -4450,10 +4493,10 @@ class SessionActor extends Actor with MDCContextAware {
         log.info(s"MoveItem: $msg")
         (continent.GUID(source_guid), continent.GUID(destination_guid), ValidObject(item_guid)) match {
           case (
-                Some(source: PlanetSideServerObject with Container),
-                Some(destination: PlanetSideServerObject with Container),
-                Some(item: Equipment)
-              ) =>
+            Some(source: PlanetSideServerObject with Container),
+            Some(destination: PlanetSideServerObject with Container),
+            Some(item: Equipment)
+            ) =>
             source.Actor ! Containable.MoveItem(destination, item, dest)
           case (None, _, _) =>
             log.error(s"MoveItem: wanted to move $item_guid from $source_guid, but could not find source object")
@@ -4524,18 +4567,18 @@ class SessionActor extends Actor with MDCContextAware {
         }
 
       case msg @ UseItemMessage(
-            avatar_guid,
-            item_used_guid,
-            object_guid,
-            unk2,
-            unk3,
-            unk4,
-            unk5,
-            unk6,
-            unk7,
-            unk8,
-            itemType
-          ) =>
+      avatar_guid,
+      item_used_guid,
+      object_guid,
+      unk2,
+      unk3,
+      unk4,
+      unk5,
+      unk6,
+      unk7,
+      unk8,
+      itemType
+      ) =>
         //log.info("UseItem: " + msg)
         // TODO: Not all fields in the response are identical to source in real packet logs (but seems to be ok)
         // TODO: Not all incoming UseItemMessage's respond with another UseItemMessage (i.e. doors only send out GenericObjectStateMsg)
@@ -4812,8 +4855,8 @@ class SessionActor extends Actor with MDCContextAware {
                 //access to trunk
                 if (
                   obj.AccessingTrunk.isEmpty &&
-                  (!obj.PermissionGroup(AccessPermissionGroup.Trunk.id).contains(VehicleLockState.Locked) || obj.Owner
-                    .contains(player.GUID))
+                    (!obj.PermissionGroup(AccessPermissionGroup.Trunk.id).contains(VehicleLockState.Locked) || obj.Owner
+                      .contains(player.GUID))
                 ) {
                   CancelZoningProcessWithDescriptiveReason("cancel_use")
                   obj.AccessingTrunk = player.GUID
@@ -4846,7 +4889,7 @@ class SessionActor extends Actor with MDCContextAware {
                 terminal.Actor ! CommonMessages.Use(player, Some(item))
 
               case None
-                  if terminal.Owner == Building.NoBuilding || terminal.Faction == player.Faction || terminal.HackedBy.nonEmpty =>
+                if terminal.Owner == Building.NoBuilding || terminal.Faction == player.Faction || terminal.HackedBy.nonEmpty =>
                 val tdef = terminal.Definition
                 if (tdef.isInstanceOf[MatrixTerminalDefinition]) {
                   //TODO matrix spawn point; for now, just blindly bind to show work (and hope nothing breaks)
@@ -4856,7 +4899,7 @@ class SessionActor extends Actor with MDCContextAware {
                   )
                 } else if (
                   tdef == GlobalDefinitions.multivehicle_rearm_terminal || tdef == GlobalDefinitions.bfr_rearm_terminal ||
-                  tdef == GlobalDefinitions.air_rearm_terminal || tdef == GlobalDefinitions.ground_rearm_terminal
+                    tdef == GlobalDefinitions.air_rearm_terminal || tdef == GlobalDefinitions.ground_rearm_terminal
                 ) {
                   FindLocalVehicle match {
                     case Some(vehicle) =>
@@ -5225,7 +5268,6 @@ class SessionActor extends Actor with MDCContextAware {
       case msg @ FavoritesRequest(player_guid, loadoutType, action, line, label) =>
         CancelZoningProcessWithDescriptiveReason("cancel_use")
         log.info(s"FavoritesRequest: $msg")
-
         action match {
           case FavoritesAction.Save    => avatarActor ! AvatarActor.SaveLoadout(player, loadoutType, label, line)
           case FavoritesAction.Delete  => avatarActor ! AvatarActor.DeleteLoadout(player, loadoutType, line)
@@ -5247,18 +5289,18 @@ class SessionActor extends Actor with MDCContextAware {
         }
 
       case msg @ WeaponFireMessage(
-            seq_time,
-            weapon_guid,
-            projectile_guid,
-            shot_origin,
-            unk1,
-            unk2,
-            unk3,
-            unk4,
-            unk5,
-            unk6,
-            unk7
-          ) =>
+      seq_time,
+      weapon_guid,
+      projectile_guid,
+      shot_origin,
+      unk1,
+      unk2,
+      unk3,
+      unk4,
+      unk5,
+      unk6,
+      unk7
+      ) =>
         //log.info(s"WeaponFire: $msg")
         HandleWeaponFire(weapon_guid, projectile_guid, shot_origin)
 
@@ -5347,15 +5389,15 @@ class SessionActor extends Actor with MDCContextAware {
         }
 
       case msg @ SplashHitMessage(
-            seq_time,
-            projectile_guid,
-            explosion_pos,
-            direct_victim_uid,
-            unk3,
-            projectile_vel,
-            unk4,
-            targets
-          ) =>
+      seq_time,
+      projectile_guid,
+      explosion_pos,
+      direct_victim_uid,
+      unk3,
+      projectile_vel,
+      unk4,
+      targets
+      ) =>
         log.info(s"Splash: $msg")
         FindProjectileEntry(projectile_guid) match {
           case Some(projectile) =>
@@ -5426,11 +5468,11 @@ class SessionActor extends Actor with MDCContextAware {
         if (deadState != DeadState.RespawnTime) {
           continent.Buildings.values.find(building => building.GUID == building_guid) match {
             case Some(wg: WarpGate) if (wg.Active && (GetKnownVehicleAndSeat() match {
-                  case (Some(vehicle), _) =>
-                    wg.Definition.VehicleAllowance && !wg.Definition.NoWarp.contains(vehicle.Definition)
-                  case _ =>
-                    true
-                })) =>
+              case (Some(vehicle), _) =>
+                wg.Definition.VehicleAllowance && !wg.Definition.NoWarp.contains(vehicle.Definition)
+              case _ =>
+                true
+            })) =>
               deadState = DeadState.RespawnTime
               cluster ! InterstellarClusterService.GetSpawnPoint(
                 destinationZoneGuid.guid,
@@ -5588,17 +5630,17 @@ class SessionActor extends Actor with MDCContextAware {
         log.debug("Ouch! " + msg)
 
       case msg @ BugReportMessage(
-            version_major,
-            version_minor,
-            version_date,
-            bug_type,
-            repeatable,
-            location,
-            zone,
-            pos,
-            summary,
-            desc
-          ) =>
+      version_major,
+      version_minor,
+      version_date,
+      bug_type,
+      repeatable,
+      location,
+      zone,
+      pos,
+      summary,
+      desc
+      ) =>
         log.info("BugReportMessage: " + msg)
 
       case msg @ BindPlayerMessage(action, bindDesc, unk1, logging, unk2, unk3, unk4, pos) =>
@@ -6305,7 +6347,7 @@ class SessionActor extends Actor with MDCContextAware {
             sendResponse(ObjectDetachMessage(tool.GUID, previousBox.GUID, Vector3.Zero, 0f))
             sendResponse(ObjectDetachMessage(player.GUID, box.GUID, Vector3.Zero, 0f))
             obj.Inventory -= x.start //remove replacement ammo from inventory
-            val ammoSlotIndex = tool.FireMode.AmmoSlotIndex
+          val ammoSlotIndex = tool.FireMode.AmmoSlotIndex
             tool.AmmoSlots(ammoSlotIndex).Box = box //put replacement ammo in tool
             sendResponse(ObjectAttachMessage(tool.GUID, box.GUID, ammoSlotIndex))
 
@@ -6330,16 +6372,16 @@ class SessionActor extends Actor with MDCContextAware {
 
             //handle inventory contents
             box.Capacity = (if (sumReloadValue <= fullMagazine) {
-                              sumReloadValue
-                            } else {
-                              val splitReloadAmmo: Int = sumReloadValue - fullMagazine
-                              log.info(
-                                s"ChangeAmmo: taking ${originalBoxCapacity - splitReloadAmmo} from a box of ${originalBoxCapacity} $requestedAmmoType"
-                              )
-                              val boxForInventory = AmmoBox(box.Definition, splitReloadAmmo)
-                              taskResolver ! stowNewFunc(boxForInventory)
-                              fullMagazine
-                            })
+              sumReloadValue
+            } else {
+              val splitReloadAmmo: Int = sumReloadValue - fullMagazine
+              log.info(
+                s"ChangeAmmo: taking ${originalBoxCapacity - splitReloadAmmo} from a box of ${originalBoxCapacity} $requestedAmmoType"
+              )
+              val boxForInventory = AmmoBox(box.Definition, splitReloadAmmo)
+              taskResolver ! stowNewFunc(boxForInventory)
+              fullMagazine
+            })
             sendResponse(
               InventoryStateMessage(box.GUID, tool.GUID, box.Capacity)
             ) //should work for both players and vehicles
@@ -6453,12 +6495,12 @@ class SessionActor extends Actor with MDCContextAware {
           else { xs.map(_.obj.asInstanceOf[Tool].Magazine).reduce(_ + _) }
           val sumReloadValue: Int = box.Magazine + tailReloadValue
           val actualReloadValue = (if (sumReloadValue <= 3) {
-                                     RemoveOldEquipmentFromInventory(player, taskResolver)(x.obj)
-                                     sumReloadValue
-                                   } else {
-                                     ModifyAmmunition(player)(box.AmmoSlot.Box, 3 - tailReloadValue)
-                                     3
-                                   })
+            RemoveOldEquipmentFromInventory(player, taskResolver)(x.obj)
+            sumReloadValue
+          } else {
+            ModifyAmmunition(player)(box.AmmoSlot.Box, 3 - tailReloadValue)
+            3
+          })
           log.info(s"found $actualReloadValue more $ammoType grenades to throw")
           ModifyAmmunition(player)(
             tool.AmmoSlot.Box,
@@ -6480,8 +6522,8 @@ class SessionActor extends Actor with MDCContextAware {
     *         the second value is the slot position of the object
     */
   def FindInLocalContainer(
-      object_guid: PlanetSideGUID
-  )(parent: PlanetSideServerObject with Container): Option[(PlanetSideServerObject with Container, Option[Int])] = {
+                            object_guid: PlanetSideGUID
+                          )(parent: PlanetSideServerObject with Container): Option[(PlanetSideServerObject with Container, Option[Int])] = {
     val slot: Option[Int] = parent.Find(object_guid)
     slot match {
       case place @ Some(_) =>
@@ -6498,10 +6540,10 @@ class SessionActor extends Actor with MDCContextAware {
     * @param reason a string explaining why the state can not or will not change
     */
   def CanNotChangeDeployment(
-      obj: PlanetSideServerObject with Deployment,
-      state: DriveState.Value,
-      reason: String
-  ): Unit = {
+                              obj: PlanetSideServerObject with Deployment,
+                              state: DriveState.Value,
+                              reason: String
+                            ): Unit = {
     val mobileShift: String = if (obj.DeploymentState != DriveState.Mobile) {
       obj.DeploymentState = DriveState.Mobile
       sendResponse(DeployRequestMessage(player.GUID, obj.GUID, DriveState.Mobile, 0, false, Vector3.Zero))
@@ -6943,10 +6985,10 @@ class SessionActor extends Actor with MDCContextAware {
     *         `(None, None)`, otherwise (even if the vehicle can be determined)
     */
   def GetMountableAndSeat(
-      direct: Option[PlanetSideGameObject with Mountable],
-      occupant: Player,
-      zone: Zone
-  ): (Option[PlanetSideGameObject with Mountable], Option[Int]) =
+                           direct: Option[PlanetSideGameObject with Mountable],
+                           occupant: Player,
+                           zone: Zone
+                         ): (Option[PlanetSideGameObject with Mountable], Option[Int]) =
     direct.orElse(zone.GUID(occupant.VehicleSeated)) match {
       case Some(obj: PlanetSideGameObject with Mountable) =>
         obj.PassengerInSeat(occupant) match {
@@ -7623,11 +7665,11 @@ class SessionActor extends Actor with MDCContextAware {
     * @return the projectile
     */
   def ResolveProjectileEntry(
-      projectile_guid: PlanetSideGUID,
-      resolution: ProjectileResolution.Value,
-      target: PlanetSideGameObject with FactionAffinity with Vitality,
-      pos: Vector3
-  ): Option[ResolvedProjectile] = {
+                              projectile_guid: PlanetSideGUID,
+                              resolution: ProjectileResolution.Value,
+                              target: PlanetSideGameObject with FactionAffinity with Vitality,
+                              pos: Vector3
+                            ): Option[ResolvedProjectile] = {
     FindProjectileEntry(projectile_guid) match {
       case Some(projectile) =>
         ResolveProjectileEntry(projectile, resolution, target, pos)
@@ -7645,12 +7687,12 @@ class SessionActor extends Actor with MDCContextAware {
     * @return a copy of the projectile
     */
   def ResolveProjectileEntry(
-      projectile: Projectile,
-      index: Int,
-      resolution: ProjectileResolution.Value,
-      target: PlanetSideGameObject with FactionAffinity with Vitality,
-      pos: Vector3
-  ): Option[ResolvedProjectile] = {
+                              projectile: Projectile,
+                              index: Int,
+                              resolution: ProjectileResolution.Value,
+                              target: PlanetSideGameObject with FactionAffinity with Vitality,
+                              pos: Vector3
+                            ): Option[ResolvedProjectile] = {
     if (!projectiles(index).contains(projectile)) {
       log.error(s"expected projectile could not be found at $index; can not resolve")
       None
@@ -7666,11 +7708,11 @@ class SessionActor extends Actor with MDCContextAware {
     * @return a copy of the projectile
     */
   def ResolveProjectileEntry(
-      projectile: Projectile,
-      resolution: ProjectileResolution.Value,
-      target: PlanetSideGameObject with FactionAffinity with Vitality,
-      pos: Vector3
-  ): Option[ResolvedProjectile] = {
+                              projectile: Projectile,
+                              resolution: ProjectileResolution.Value,
+                              target: PlanetSideGameObject with FactionAffinity with Vitality,
+                              pos: Vector3
+                            ): Option[ResolvedProjectile] = {
     if (projectile.isMiss) {
       log.error("expected projectile was already counted as a missed shot; can not resolve any further")
       None
@@ -7762,11 +7804,11 @@ class SessionActor extends Actor with MDCContextAware {
     * @return a `DestroyDisplayMessage` packet that is properly formatted
     */
   def DestroyDisplayMessage(
-      killer: SourceEntry,
-      victim: SourceEntry,
-      method: Int,
-      unk: Int = 121
-  ): DestroyDisplayMessage = {
+                             killer: SourceEntry,
+                             victim: SourceEntry,
+                             method: Int,
+                             unk: Int = 121
+                           ): DestroyDisplayMessage = {
     val killer_seated = killer match {
       case obj: PlayerSource => obj.Seated
       case _                 => false
@@ -7926,12 +7968,12 @@ class SessionActor extends Actor with MDCContextAware {
     * @return `true`, if the desired certification requirements are met; `false`, otherwise
     */
   def ConstructionItemPermissionComparison(
-      sample: Set[Certification],
-      test: Set[Certification]
-  ): Boolean = {
-    import Certification._
-    val engineeringCerts: Set[Certification] = Set(AssaultEngineering, FortificationEngineering)
-    val testDiff: Set[Certification]         = test diff (engineeringCerts ++ Set(AdvancedEngineering))
+                                            sample: Set[CertificationType.Value],
+                                            test: Set[CertificationType.Value]
+                                          ): Boolean = {
+    import CertificationType._
+    val engineeringCerts: Set[CertificationType.Value] = Set(AssaultEngineering, FortificationEngineering)
+    val testDiff: Set[CertificationType.Value]         = test diff (engineeringCerts ++ Set(AdvancedEngineering))
     //substitute `AssaultEngineering` and `FortificationEngineering` for `AdvancedEngineering`
     val sampleIntersect = if (sample contains AdvancedEngineering) {
       engineeringCerts
@@ -8073,10 +8115,10 @@ class SessionActor extends Actor with MDCContextAware {
     *        `false`, otherwise
     */
   def SafelyRemoveConstructionItemFromSlot(
-      tool: ConstructionItem,
-      index: Int,
-      logDecorator: String = "SafelyRemoveConstructionItemFromSlot"
-  ): Boolean = {
+                                            tool: ConstructionItem,
+                                            index: Int,
+                                            logDecorator: String = "SafelyRemoveConstructionItemFromSlot"
+                                          ): Boolean = {
     if ({
       val holster = player.Slot(index)
       if (holster.Equipment.contains(tool)) {
@@ -8175,7 +8217,7 @@ class SessionActor extends Actor with MDCContextAware {
     */
   def FindEquipmentToDelete(object_guid: PlanetSideGUID, obj: Equipment): Boolean = {
     val findFunc
-        : PlanetSideServerObject with Container => Option[(PlanetSideServerObject with Container, Option[Int])] =
+    : PlanetSideServerObject with Container => Option[(PlanetSideServerObject with Container, Option[Int])] =
       FindInLocalContainer(object_guid)
 
     findFunc(player.avatar.locker)
@@ -8242,12 +8284,12 @@ class SessionActor extends Actor with MDCContextAware {
     * @param deletionType the value passed to `ObjectDeleteMessage` concerning the deconstruction animation
     */
   def DeconstructDeployable(
-      obj: PlanetSideGameObject with Deployable,
-      guid: PlanetSideGUID,
-      pos: Vector3,
-      orient: Vector3,
-      deletionType: Int
-  ): Unit = {
+                             obj: PlanetSideGameObject with Deployable,
+                             guid: PlanetSideGUID,
+                             pos: Vector3,
+                             orient: Vector3,
+                             deletionType: Int
+                           ): Unit = {
     StartBundlingPackets()
     sendResponse(SetEmpireMessage(guid, PlanetSideEmpire.NEUTRAL)) //for some, removes the green marker circle
     sendResponse(TriggerEffectMessage("spawn_object_failed_effect", pos, orient))
@@ -8511,17 +8553,17 @@ class SessionActor extends Actor with MDCContextAware {
       player.Continent = zoneId //forward-set the continent id to perform a test
       interstellarFerryTopLevelGUID =
         (if (
-           manifest.passengers.isEmpty && manifest.cargo.count { case (name, _) => !name.equals("MISSING_DRIVER") } == 0
-         ) {
-           //do not delete if vehicle has passengers or cargo
-           continent.VehicleEvents ! VehicleServiceMessage(
-             continent.id,
-             VehicleAction.UnloadVehicle(pguid, continent, vehicle, topLevel)
-           )
-           None
-         } else {
-           Some(topLevel)
-         })
+          manifest.passengers.isEmpty && manifest.cargo.count { case (name, _) => !name.equals("MISSING_DRIVER") } == 0
+        ) {
+          //do not delete if vehicle has passengers or cargo
+          continent.VehicleEvents ! VehicleServiceMessage(
+            continent.Id,
+            VehicleAction.UnloadVehicle(pguid, continent, vehicle, topLevel)
+          )
+          None
+        } else {
+          Some(topLevel)
+        })
       //unregister vehicle and driver whole + GiveWorld
       continent.Transport ! Zone.Vehicle.Despawn(vehicle)
       taskThenZoneChange(
@@ -8685,10 +8727,10 @@ class SessionActor extends Actor with MDCContextAware {
     * @param remoteTelepad the endpoint of the teleportation system that exists in the environment
     */
   def LinkRouterToRemoteTelepad(
-      router: Vehicle,
-      internalTelepad: Utility.InternalTelepad,
-      remoteTelepad: TelepadDeployable
-  ): Unit = {
+                                 router: Vehicle,
+                                 internalTelepad: Utility.InternalTelepad,
+                                 remoteTelepad: TelepadDeployable
+                               ): Unit = {
     internalTelepad.Telepad = remoteTelepad.GUID //necessary; backwards link to the (new) telepad
     CreateRouterInternalTelepad(router, internalTelepad)
     LinkRemoteTelepad(remoteTelepad.GUID)
@@ -8749,12 +8791,12 @@ class SessionActor extends Actor with MDCContextAware {
     * @param dest the destination of the teleportation (where the player is going)
     */
   def UseRouterTelepadSystem(
-      router: Vehicle,
-      internalTelepad: InternalTelepad,
-      remoteTelepad: TelepadDeployable,
-      src: PlanetSideGameObject with TelepadLike,
-      dest: PlanetSideGameObject with TelepadLike
-  ) = {
+                              router: Vehicle,
+                              internalTelepad: InternalTelepad,
+                              remoteTelepad: TelepadDeployable,
+                              src: PlanetSideGameObject with TelepadLike,
+                              dest: PlanetSideGameObject with TelepadLike
+                            ) = {
     val time = System.nanoTime
     if (
       time - recentTeleportAttempt > (2 seconds).toNanos && router.DeploymentState == DriveState.Deployed && internalTelepad.Active && remoteTelepad.Active
@@ -9003,7 +9045,7 @@ class SessionActor extends Actor with MDCContextAware {
       // Charge
       else if (
         player.Capacitor < player.ExoSuitDef.MaxCapacitor
-        && (player.CapacitorState == CapacitorStateType.Idle || player.CapacitorState == CapacitorStateType.Charging || (player.CapacitorState == CapacitorStateType.ChargeDelay && System
+          && (player.CapacitorState == CapacitorStateType.Idle || player.CapacitorState == CapacitorStateType.Charging || (player.CapacitorState == CapacitorStateType.ChargeDelay && System
           .currentTimeMillis() - player.CapacitorLastUsedMillis > player.ExoSuitDef.CapacitorRechargeDelayMillis))
       ) {
         if (player.CapacitorState == CapacitorStateType.Charging) {
@@ -9137,10 +9179,10 @@ class SessionActor extends Actor with MDCContextAware {
   }
 
   def CheckForHitPositionDiscrepancy(
-      projectile_guid: PlanetSideGUID,
-      hitPos: Vector3,
-      target: PlanetSideGameObject with FactionAffinity with Vitality
-  ): Unit = {
+                                      projectile_guid: PlanetSideGUID,
+                                      hitPos: Vector3,
+                                      target: PlanetSideGameObject with FactionAffinity with Vitality
+                                    ): Unit = {
     val hitPositionDiscrepancy = Vector3.DistanceSquared(hitPos, target.Position)
     if (hitPositionDiscrepancy > Config.app.antiCheat.hitPositionDiscrepancyThreshold) {
       // If the target position on the server does not match the position where the projectile landed within reason there may be foul play
@@ -9350,18 +9392,18 @@ class SessionActor extends Actor with MDCContextAware {
               s"WeaponFireMessage: ${projectile_info.Name} is a remote projectile"
             )
             taskResolver ! (if (projectile.HasGUID) {
-                              continent.AvatarEvents ! AvatarServiceMessage(
-                                continent.id,
-                                AvatarAction.ProjectileExplodes(
-                                  player.GUID,
-                                  projectile.GUID,
-                                  projectile
-                                )
-                              )
-                              ReregisterProjectile(projectile)
-                            } else {
-                              RegisterProjectile(projectile)
-                            })
+              continent.AvatarEvents ! AvatarServiceMessage(
+                continent.Id,
+                AvatarAction.ProjectileExplodes(
+                  player.GUID,
+                  projectile.GUID,
+                  projectile
+                )
+              )
+              ReregisterProjectile(projectile)
+            } else {
+              RegisterProjectile(projectile)
+            })
           }
           projectilesToCleanUp(projectileIndex) = false
 

src/main/scala/net/psforever/objects/GlobalDefinitions.scala

@@ -2,7 +2,7 @@
 package net.psforever.objects
 
 import net.psforever.objects.avatar.Certification
-import net.psforever.objects.ballistics.Projectiles
+import net.psforever.objects.ballistics.{AggravatedDamage, AggravatedEffect, AggravatedInfo, Projectiles}
 import net.psforever.objects.ce.{DeployableCategory, DeployedItem}
 import net.psforever.objects.definition._
 import net.psforever.objects.definition.converter._
@@ -207,6 +207,8 @@ object GlobalDefinitions {
 
   val flail_projectile = ProjectileDefinition(Projectiles.flail_projectile)
 
+  val flamethrower_fire_cloud = ProjectileDefinition(Projectiles.flamethrower_projectile) //flamethrower_fire_cloud
+
   val flamethrower_fireball = ProjectileDefinition(Projectiles.flamethrower_fireball)
 
   val flamethrower_projectile = ProjectileDefinition(Projectiles.flamethrower_projectile)
@@ -2269,6 +2271,7 @@ object GlobalDefinitions {
     ProjectileDefinition.CalculateDerivedFields(aphelion_laser_projectile)
 
     aphelion_plasma_rocket_projectile.Name = "aphelion_plasma_rocket_projectile"
+    //has property aggravated_damage_max_factor, but it's the aphelion_plasma_cloud that performs aggravated damage
     aphelion_plasma_rocket_projectile.Damage0 = 38
     aphelion_plasma_rocket_projectile.Damage1 = 70
     aphelion_plasma_rocket_projectile.Damage2 = 95
@@ -2313,6 +2316,13 @@ object GlobalDefinitions {
     aphelion_starfire_projectile.InitialVelocity = 45
     aphelion_starfire_projectile.Lifespan = 7f
     aphelion_starfire_projectile.ProjectileDamageType = DamageType.Aggravated
+    aphelion_starfire_projectile.Aggravated = AggravatedDamage(
+      AggravatedInfo(DamageType.Direct, 0.25f, 250),
+      AggravatedEffect.None,
+      0,
+      0f,
+      true
+    )
     aphelion_starfire_projectile.ExistsOnRemoteClients = true
     aphelion_starfire_projectile.RemoteClientData = (39577, 249) //starfire_projectile data
     aphelion_starfire_projectile.AutoLock = true
@@ -2437,6 +2447,12 @@ object GlobalDefinitions {
     comet_projectile.DamageAtEdge = 0.45f
     comet_projectile.DamageRadius = 1.0f
     comet_projectile.ProjectileDamageType = DamageType.Aggravated
+    comet_projectile.Aggravated = AggravatedDamage(
+      AggravatedInfo(DamageType.Direct, 0.2f, 500),
+      AggravatedEffect.Comet,
+      0,
+      10f
+    )
     comet_projectile.InitialVelocity = 80
     comet_projectile.Lifespan = 3.1f
     ProjectileDefinition.CalculateDerivedFields(comet_projectile)
@@ -2582,6 +2598,14 @@ object GlobalDefinitions {
     flamethrower_fireball.DamageAtEdge = 0.15f
     flamethrower_fireball.DamageRadius = 5f
     flamethrower_fireball.ProjectileDamageType = DamageType.Aggravated
+    flamethrower_fireball.Aggravated = AggravatedDamage(
+      List(AggravatedInfo(DamageType.Direct, 0.9f, 500), AggravatedInfo(DamageType.Splash, 0.9f, 500)),
+      AggravatedEffect.Fire,
+      5000,
+      0.1f,
+      false,
+      false
+    )
     flamethrower_fireball.InitialVelocity = 15
     flamethrower_fireball.Lifespan = 1.2f
     ProjectileDefinition.CalculateDerivedFields(flamethrower_fireball)
@@ -2595,6 +2619,14 @@ object GlobalDefinitions {
     flamethrower_projectile.Acceleration = -5
     flamethrower_projectile.AccelerationUntil = 2f
     flamethrower_projectile.ProjectileDamageType = DamageType.Aggravated
+    flamethrower_projectile.Aggravated = AggravatedDamage(
+      List(AggravatedInfo(DamageType.Direct, 0.5f, 500)),
+      AggravatedEffect.Fire,
+      5000,
+      0.5f,
+      false,
+      false
+    )
     flamethrower_projectile.DegradeDelay = 1.0f
     flamethrower_projectile.DegradeMultiplier = 0.5f
     flamethrower_projectile.InitialVelocity = 10
@@ -3423,6 +3455,14 @@ object GlobalDefinitions {
     plasma_cartridge_projectile.DamageAtEdge = 0.2f
     plasma_cartridge_projectile.DamageRadius = 7f
     plasma_cartridge_projectile.ProjectileDamageType = DamageType.Aggravated
+    plasma_cartridge_projectile.Aggravated = AggravatedDamage(
+      List(AggravatedInfo(DamageType.Direct, 0.25f, 750), AggravatedInfo(DamageType.Splash, 0.25f, 1000)),
+      AggravatedEffect.Plasma,
+      0,
+      1.5f,
+      true,
+      false
+    )
     plasma_cartridge_projectile.InitialVelocity = 30
     plasma_cartridge_projectile.Lifespan = 15f
     ProjectileDefinition.CalculateDerivedFields(plasma_cartridge_projectile)
@@ -3434,6 +3474,14 @@ object GlobalDefinitions {
     plasma_cartridge_projectile_b.DamageAtEdge = 0.2f
     plasma_cartridge_projectile_b.DamageRadius = 7f
     plasma_cartridge_projectile_b.ProjectileDamageType = DamageType.Aggravated
+    plasma_cartridge_projectile_b.Aggravated = AggravatedDamage(
+      List(AggravatedInfo(DamageType.Direct, 0.25f, 750), AggravatedInfo(DamageType.Splash, 0.25f, 1000)),
+      AggravatedEffect.Plasma,
+      0,
+      1.5f,
+      true,
+      false
+    )
     plasma_cartridge_projectile_b.InitialVelocity = 30
     plasma_cartridge_projectile_b.Lifespan = 2f
     ProjectileDefinition.CalculateDerivedFields(plasma_cartridge_projectile_b)
@@ -3444,6 +3492,14 @@ object GlobalDefinitions {
     plasma_grenade_projectile.DamageAtEdge = 0.1f
     plasma_grenade_projectile.DamageRadius = 7f
     plasma_grenade_projectile.ProjectileDamageType = DamageType.Aggravated
+    plasma_grenade_projectile.Aggravated = AggravatedDamage(
+      List(AggravatedInfo(DamageType.Direct, 0.25f, 750), AggravatedInfo(DamageType.Splash, 0.25f, 1000)),
+      AggravatedEffect.Plasma,
+      0,
+      1.5f,
+      true,
+      false
+    )
     plasma_grenade_projectile.InitialVelocity = 30
     plasma_grenade_projectile.Lifespan = 15f
     ProjectileDefinition.CalculateDerivedFields(plasma_grenade_projectile)
@@ -3455,6 +3511,14 @@ object GlobalDefinitions {
     plasma_grenade_projectile_B.DamageAtEdge = 0.1f
     plasma_grenade_projectile_B.DamageRadius = 7f
     plasma_grenade_projectile_B.ProjectileDamageType = DamageType.Aggravated
+    plasma_grenade_projectile_B.Aggravated = AggravatedDamage(
+      List(AggravatedInfo(DamageType.Direct, 0.25f, 750), AggravatedInfo(DamageType.Splash, 0.25f, 1000)),
+      AggravatedEffect.Plasma,
+      0,
+      1.5f,
+      true,
+      false
+    )
     plasma_grenade_projectile_B.InitialVelocity = 30
     plasma_grenade_projectile_B.Lifespan = 3f
     ProjectileDefinition.CalculateDerivedFields(plasma_grenade_projectile_B)
@@ -3756,6 +3820,13 @@ object GlobalDefinitions {
     starfire_projectile.Acceleration = 12
     starfire_projectile.AccelerationUntil = 5f
     starfire_projectile.ProjectileDamageType = DamageType.Aggravated
+    starfire_projectile.Aggravated = AggravatedDamage(
+      AggravatedInfo(DamageType.Direct, 0.25f, 250),
+      AggravatedEffect.Comet,
+      0,
+      0f,
+      true
+    )
     starfire_projectile.InitialVelocity = 45
     starfire_projectile.Lifespan = 7.8f
     starfire_projectile.ExistsOnRemoteClients = true

src/main/scala/net/psforever/objects/ballistics/Projectile.scala

@@ -10,11 +10,11 @@ import net.psforever.types.Vector3
 
 /**
   * A summation of weapon (`Tool`) discharge.
-  * @see `ProjectileDefinition`<br>
-  *       `ToolDefinition`<br>
-  *       `FireModeDefinition`<br>
-  *       `SourceEntry`<br>
-  *       `PlayerSource`
+  * @see `ProjectileDefinition`
+  * @see `ToolDefinition`
+  * @see `FireModeDefinition`
+  * @see `SourceEntry`
+  * @see `PlayerSource`
   * @param profile an explanation of the damage that can be performed by this discharge
   * @param tool_def the weapon that caused this discharge
   * @param fire_mode the current fire mode of the tool used

src/main/scala/net/psforever/objects/ballistics/ResolvedProjectile.scala

@@ -9,14 +9,13 @@ import net.psforever.types.Vector3
   * about the interaction of weapons discharge and a target
   * to the point that the original event might be reconstructed.
   * Reenacting the calculations of this entry should always produce the same values.
-  * @param resolution how the projectile hit was executed
   * @param projectile the original projectile
   * @param target what the projectile hit
   * @param damage_model the kind of damage model to which the `target` is/was subject
   * @param hit_pos where the projectile hit
   */
 final case class ResolvedProjectile(
-    resolution: ProjectileResolution.Value,
+    resolution : ProjectileResolution.Value,
     projectile: Projectile,
     target: SourceEntry,
     damage_model: DamageResistanceModel,

src/main/scala/net/psforever/objects/definition/ProjectileDefinition.scala

@@ -1,7 +1,7 @@
 // Copyright (c) 2017 PSForever
 package net.psforever.objects.definition
 
-import net.psforever.objects.ballistics.Projectiles
+import net.psforever.objects.ballistics.{AggravatedDamage, Projectiles}
 import net.psforever.objects.equipment.JammingUnit
 import net.psforever.objects.vital.damage.DamageModifiers
 import net.psforever.objects.vital.{DamageType, StandardDamageProfile}
@@ -36,6 +36,7 @@ class ProjectileDefinition(objectId: Int)
   private var autoLock: Boolean         = false
   private var additionalEffect: Boolean = false
   private var jammerProjectile: Boolean = false
+  private var aggravated_damage : Option[AggravatedDamage] = None
   //derived calculations
   private var distanceMax: Float              = 0f
   private var distanceFromAcceleration: Float = 0f
@@ -174,7 +175,16 @@ class ProjectileDefinition(objectId: Int)
     JammerProjectile
   }
 
-  def DistanceMax: Float = distanceMax //accessor only
+  def Aggravated : Option[AggravatedDamage] = aggravated_damage
+
+  def Aggravated_=(damage : AggravatedDamage) : Option[AggravatedDamage] = Aggravated_=(Some(damage))
+
+  def Aggravated_=(damage : Option[AggravatedDamage]) : Option[AggravatedDamage] = {
+    aggravated_damage = damage
+    Aggravated
+  }
+
+  def DistanceMax : Float = distanceMax //accessor only
 
   def DistanceFromAcceleration: Float = distanceFromAcceleration //accessor only
 

src/main/scala/net/psforever/objects/vital/DamageResistanceModel.scala

@@ -1,8 +1,8 @@
 // Copyright (c) 2017 PSForever
 package net.psforever.objects.vital
 
-import net.psforever.objects.ballistics.{ProjectileResolution, ResolvedProjectile}
 import net.psforever.objects.vital.damage.DamageCalculations
+import net.psforever.objects.ballistics.ResolvedProjectile
 import net.psforever.objects.vital.projectile.ProjectileCalculations
 import net.psforever.objects.vital.resistance.ResistanceSelection
 import net.psforever.objects.vital.resolution.ResolutionCalculations
@@ -72,7 +72,7 @@ trait DamageResistanceModel {
     * @param resolution an explicit damage resolution overriding the one in the `ResolvedProjectile` object
     * @return a function literal that encapsulates delayed modification instructions for certain objects
     */
-  def Calculate(data: ResolvedProjectile, resolution: ProjectileResolution.Value): ResolutionCalculations.Output = {
+  def Calculate(data: ResolvedProjectile, resolution: DamageType.Value): ResolutionCalculations.Output = {
     val res: ProjectileCalculations.Form = ResistUsing(resolution)
     Model(DamageUsing, res, data)
   }

src/main/scala/net/psforever/objects/vital/DamageType.scala

@@ -9,5 +9,5 @@ package net.psforever.objects.vital
 object DamageType extends Enumeration(1) {
   type Type = Value
 
-  final val Direct, Splash, Radiation, Aggravated, Plasma, Comet, None = Value
+  final val Direct, Splash, Lash, Radiation, Aggravated, Plasma, Comet, None = Value
 }

src/main/scala/net/psforever/objects/vital/StandardResistances.scala

@@ -6,70 +6,70 @@ import net.psforever.objects.vital.projectile.ProjectileCalculations
 import net.psforever.objects.vital.resistance.{ResistanceCalculations, ResistanceSelection}
 
 object NoResistance
-    extends ResistanceCalculations[SourceEntry](
-      ResistanceCalculations.ValidInfantryTarget,
-      ResistanceCalculations.NoResistExtractor
-    )
+  extends ResistanceCalculations[SourceEntry](
+    ResistanceCalculations.ValidInfantryTarget,
+    ResistanceCalculations.NoResistExtractor
+  )
 
 object InfantryHitResistance
-    extends ResistanceCalculations[PlayerSource](
-      ResistanceCalculations.ValidInfantryTarget,
-      ResistanceCalculations.ExoSuitDirectExtractor
-    )
+  extends ResistanceCalculations[PlayerSource](
+    ResistanceCalculations.ValidInfantryTarget,
+    ResistanceCalculations.ExoSuitDirectExtractor
+  )
 
 object InfantrySplashResistance
-    extends ResistanceCalculations[PlayerSource](
-      ResistanceCalculations.ValidInfantryTarget,
-      ResistanceCalculations.ExoSuitSplashExtractor
-    )
+  extends ResistanceCalculations[PlayerSource](
+    ResistanceCalculations.ValidInfantryTarget,
+    ResistanceCalculations.ExoSuitSplashExtractor
+  )
 
 object InfantryLashResistance
-    extends ResistanceCalculations[PlayerSource](
-      ResistanceCalculations.ValidInfantryTarget,
-      ResistanceCalculations.MaximumResistance
-    )
+  extends ResistanceCalculations[PlayerSource](
+    ResistanceCalculations.ValidInfantryTarget,
+    ResistanceCalculations.MaximumResistance
+  )
 
 object InfantryAggravatedResistance
-    extends ResistanceCalculations[PlayerSource](
-      ResistanceCalculations.ValidInfantryTarget,
-      ResistanceCalculations.ExoSuitAggravatedExtractor
-    )
+  extends ResistanceCalculations[PlayerSource](
+    ResistanceCalculations.ValidInfantryTarget,
+    ResistanceCalculations.ExoSuitAggravatedExtractor
+  )
 
 object VehicleHitResistance
-    extends ResistanceCalculations[VehicleSource](
-      ResistanceCalculations.ValidVehicleTarget,
-      ResistanceCalculations.VehicleDirectExtractor
-    )
+  extends ResistanceCalculations[VehicleSource](
+    ResistanceCalculations.ValidVehicleTarget,
+    ResistanceCalculations.VehicleDirectExtractor
+  )
 
 object VehicleSplashResistance
-    extends ResistanceCalculations[VehicleSource](
-      ResistanceCalculations.ValidVehicleTarget,
-      ResistanceCalculations.VehicleSplashExtractor
-    )
+  extends ResistanceCalculations[VehicleSource](
+    ResistanceCalculations.ValidVehicleTarget,
+    ResistanceCalculations.VehicleSplashExtractor
+  )
 
 object VehicleLashResistance
-    extends ResistanceCalculations[VehicleSource](
-      ResistanceCalculations.ValidVehicleTarget,
-      ResistanceCalculations.NoResistExtractor
-    )
+  extends ResistanceCalculations[VehicleSource](
+    ResistanceCalculations.ValidVehicleTarget,
+    ResistanceCalculations.NoResistExtractor
+  )
 
 object VehicleAggravatedResistance
-    extends ResistanceCalculations[VehicleSource](
-      ResistanceCalculations.ValidVehicleTarget,
-      ResistanceCalculations.VehicleAggravatedExtractor
-    )
+  extends ResistanceCalculations[VehicleSource](
+    ResistanceCalculations.ValidVehicleTarget,
+    ResistanceCalculations.VehicleAggravatedExtractor
+  )
 
 object AmenityHitResistance
-    extends ResistanceCalculations[ObjectSource](
-      ResistanceCalculations.ValidAmenityTarget,
-      ResistanceCalculations.OtherDirectExtractor
-    )
+  extends ResistanceCalculations[ObjectSource](
+    ResistanceCalculations.ValidAmenityTarget,
+    ResistanceCalculations.OtherDirectExtractor
+  )
 
-object AMenitySplashResistance
-    extends ResistanceCalculations[ObjectSource](
-      ResistanceCalculations.ValidAmenityTarget,
-      ResistanceCalculations.OtherSplashExtractor
-    )
+object AmenitySplashResistance
+  extends ResistanceCalculations[ObjectSource](
+    ResistanceCalculations.ValidAmenityTarget,
+    ResistanceCalculations.OtherSplashExtractor
+  )
 
 object NoResistanceSelection extends ResistanceSelection {
   def Direct: ProjectileCalculations.Form     = None

src/main/scala/net/psforever/objects/vital/resistance/ResistanceSelection.scala

@@ -2,7 +2,7 @@
 package net.psforever.objects.vital.resistance
 
 import net.psforever.objects.ballistics._
-import net.psforever.objects.vital.NoResistance
+import net.psforever.objects.vital.{DamageType, NoResistance}
 import net.psforever.objects.vital.projectile.ProjectileCalculations
 
 /**
@@ -17,19 +17,19 @@ trait ResistanceSelection {
   def Lash: ProjectileCalculations.Form
   def Aggravated: ProjectileCalculations.Form
 
-  def apply(data: ResolvedProjectile): ProjectileCalculations.Form =
-    data.resolution match {
-      case ProjectileResolution.Hit    => Direct
-      case ProjectileResolution.Splash => Splash
-      case ProjectileResolution.Lash   => Lash
-      case _                           => None
-    }
+  def apply(data : ResolvedProjectile) : ProjectileCalculations.Form = data.projectile.profile.ProjectileDamageType match {
+    case DamageType.Direct =>     Direct
+    case DamageType.Splash =>     Splash
+    case DamageType.Lash =>       Lash
+    case DamageType.Aggravated => Aggravated
+    case _ => None
+  }
 
-  def apply(res: ProjectileResolution.Value): ProjectileCalculations.Form =
-    res match {
-      case ProjectileResolution.Hit    => Direct
-      case ProjectileResolution.Splash => Splash
-      case ProjectileResolution.Lash   => Lash
-      case _                           => None
-    }
+  def apply(res : DamageType.Value) : ProjectileCalculations.Form = res match {
+    case DamageType.Direct =>     Direct
+    case DamageType.Splash =>     Splash
+    case DamageType.Lash =>       Lash
+    case DamageType.Aggravated => Aggravated
+    case _ => None
+  }
 }

src/test/scala/objects/DamageModelTests.scala

@@ -28,7 +28,7 @@ class DamageCalculationsTests extends Specification {
     val target     = Vehicle(GlobalDefinitions.fury)
     target.Position = Vector3(10, 0, 0)
     val resprojectile = ResolvedProjectile(
-      ProjectileResolution.Splash,
+      ProjectileResolution.Hit,
       projectile,
       SourceEntry(target),
       target.DamageModel,
@@ -180,7 +180,7 @@ class ResistanceCalculationsTests extends Specification {
     "ignore all targets" in {
       val target = Vehicle(GlobalDefinitions.fury)
       val resprojectile = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target),
         target.DamageModel,
@@ -192,7 +192,7 @@ class ResistanceCalculationsTests extends Specification {
     "discern standard infantry targets" in {
       val target = player
       val resprojectile = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target),
         target.DamageModel,
@@ -208,7 +208,7 @@ class ResistanceCalculationsTests extends Specification {
       val target = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
       target.ExoSuit = ExoSuitType.MAX
       val resprojectile = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target),
         target.DamageModel,
@@ -223,7 +223,7 @@ class ResistanceCalculationsTests extends Specification {
     "discern ground vehicle targets" in {
       val target = Vehicle(GlobalDefinitions.fury)
       val resprojectile = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target),
         target.DamageModel,
@@ -238,7 +238,7 @@ class ResistanceCalculationsTests extends Specification {
     "discern flying vehicle targets" in {
       val target = Vehicle(GlobalDefinitions.mosquito)
       val resprojectile = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target),
         target.DamageModel,
@@ -284,7 +284,7 @@ class ResolutionCalculationsTests extends Specification {
     "calculate no damage" in {
       val target = player
       val resprojectile = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target),
         target.DamageModel,
@@ -296,7 +296,7 @@ class ResolutionCalculationsTests extends Specification {
     "calculate no infantry damage for vehicles" in {
       val target1 = Vehicle(GlobalDefinitions.fury) //!
       val resprojectile1 = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target1),
         target1.DamageModel,
@@ -306,7 +306,7 @@ class ResolutionCalculationsTests extends Specification {
 
       val target2 = player
       val resprojectile2 = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target2),
         target2.DamageModel,
@@ -340,7 +340,7 @@ class ResolutionCalculationsTests extends Specification {
     "calculate no max damage for vehicles" in {
       val target1 = Vehicle(GlobalDefinitions.fury) //!
       val resprojectile1 = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target1),
         target1.DamageModel,
@@ -350,7 +350,7 @@ class ResolutionCalculationsTests extends Specification {
 
       val target2 = player2
       val resprojectile2 = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target2),
         target2.DamageModel,
@@ -376,7 +376,7 @@ class ResolutionCalculationsTests extends Specification {
     "do not care if target is infantry for vehicle calculations" in {
       val target1 = player
       val resprojectile1 = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target1),
         target1.DamageModel,
@@ -386,7 +386,7 @@ class ResolutionCalculationsTests extends Specification {
 
       val target2 = Vehicle(GlobalDefinitions.fury) //!
       val resprojectile2 = ResolvedProjectile(
-        ProjectileResolution.Splash,
+        ProjectileResolution.Hit,
         projectile,
         SourceEntry(target2),
         target2.DamageModel,
@@ -450,7 +450,6 @@ class DamageModelTests extends Specification {
         Vector3.Zero
       )
       val func: Any => ResolvedProjectile = resprojectile.damage_model.Calculate(resprojectile)
-
       func(tplayer)
       tplayer.Health mustEqual 54
       tplayer.Armor mustEqual 46
@@ -471,8 +470,7 @@ class DamageModelTests extends Specification {
         Vector3.Zero
       )
       val func: Any => ResolvedProjectile =
-        resprojectile.damage_model.Calculate(resprojectile, ProjectileResolution.Splash)
-
+        resprojectile.damage_model.Calculate(resprojectile, DamageType.Splash)
       func(tplayer)
       tplayer.Health mustEqual 65
       tplayer.Armor mustEqual 35
@@ -572,7 +570,7 @@ class DamageModelTests extends Specification {
         Vector3.Zero
       )
       val func: Any => ResolvedProjectile =
-        resprojectile.damage_model.Calculate(resprojectile, ProjectileResolution.Splash)
+        resprojectile.damage_model.Calculate(resprojectile, DamageType.Splash)
 
       func(vehicle)
       vehicle.Health mustEqual 518

src/test/scala/objects/DamageableTest.scala

@@ -40,7 +40,6 @@ class DamageableTest extends Specification {
     "permit damage" in {
       val target = new SensorDeployable(GlobalDefinitions.motionalarmsensor)
       val resolved = ResolvedProjectile(
-        ProjectileResolution.Splash,
         Projectile(projectileA, weaponA.Definition, weaponA.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
         SourceEntry(target),
         target.DamageModel,
@@ -53,7 +52,6 @@ class DamageableTest extends Specification {
     "ignore attempts at non-zero damage" in {
       val target = new SensorDeployable(GlobalDefinitions.motionalarmsensor)
       val resolved = ResolvedProjectile(
-        ProjectileResolution.Splash,
         Projectile(
           projectileA,
           weaponA.Definition,
@@ -78,7 +76,6 @@ class DamageableTest extends Specification {
           Faction = player1.Faction
         }
       val resolved = ResolvedProjectile(
-        ProjectileResolution.Splash,
         Projectile(projectileA, weaponA.Definition, weaponA.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
         SourceEntry(target),
         target.DamageModel,
@@ -101,7 +98,6 @@ class DamageableTest extends Specification {
           Faction = PlanetSideEmpire.NC
         }
       val resolved = ResolvedProjectile(
-        ProjectileResolution.Splash,
         Projectile(projectileA, weaponA.Definition, weaponA.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
         SourceEntry(target),
         target.DamageModel,
@@ -128,7 +124,6 @@ class DamageableTest extends Specification {
           Faction = player1.Faction
         }
       val resolved = ResolvedProjectile(
-        ProjectileResolution.Splash,
         Projectile(projectileA, weaponA.Definition, weaponA.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
         SourceEntry(target),
         target.DamageModel,
@@ -152,7 +147,6 @@ class DamageableTest extends Specification {
     "permit jamming" in {
       val target = new SensorDeployable(GlobalDefinitions.motionalarmsensor)
       val resolved = ResolvedProjectile(
-        ProjectileResolution.Splash,
         Projectile(projectileB, weaponB.Definition, weaponB.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
         SourceEntry(target),
         target.DamageModel,
@@ -166,7 +160,6 @@ class DamageableTest extends Specification {
     "ignore attempts at jamming if the projectile is does not cause the effect" in {
       val target = new SensorDeployable(GlobalDefinitions.motionalarmsensor)
       val resolved = ResolvedProjectile(
-        ProjectileResolution.Splash,
         Projectile(projectileA, weaponA.Definition, weaponA.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
         SourceEntry(target),
         target.DamageModel,
@@ -181,7 +174,6 @@ class DamageableTest extends Specification {
       val target = new SensorDeployable(GlobalDefinitions.motionalarmsensor)
       target.Faction = player1.Faction
       val resolved = ResolvedProjectile(
-        ProjectileResolution.Splash,
         Projectile(projectileB, weaponB.Definition, weaponB.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
         SourceEntry(target),
         target.DamageModel,
@@ -196,7 +188,6 @@ class DamageableTest extends Specification {
     "ignore attempts at jamming targets that are not jammable" in {
       val target = new TrapDeployable(GlobalDefinitions.tank_traps)
       val resolved = ResolvedProjectile(
-        ProjectileResolution.Splash,
         Projectile(projectileB, weaponB.Definition, weaponB.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
         SourceEntry(target),
         target.DamageModel,
@@ -216,7 +207,6 @@ class DamageableTest extends Specification {
       val target = new SensorDeployable(GlobalDefinitions.motionalarmsensor)
       target.Faction = player1.Faction
       val resolved = ResolvedProjectile(
-        ProjectileResolution.Splash,
         Projectile(projectileB, weaponB.Definition, weaponB.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
         SourceEntry(target),
         target.DamageModel,
@@ -271,7 +261,6 @@ class DamageableEntityDamageTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -342,7 +331,6 @@ class DamageableEntityDestroyedTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -416,7 +404,6 @@ class DamageableEntityNotDestroyTwice extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -487,7 +474,6 @@ class DamageableAmenityTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -580,7 +566,6 @@ class DamageableMountableDamageTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -675,7 +660,6 @@ class DamageableMountableDestroyTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -764,7 +748,6 @@ class DamageableWeaponTurretDamageTest extends ActorTest {
   val projectile   = weapon.Projectile
   val turretSource = SourceEntry(turret)
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Hit,
     Projectile(
       projectile,
       weapon.Definition,
@@ -862,7 +845,6 @@ class DamageableWeaponTurretJammerTest extends ActorTest {
   val projectile   = weapon.Projectile
   val turretSource = SourceEntry(turret)
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -964,7 +946,6 @@ class DamageableWeaponTurretDestructionTest extends ActorTest {
   val weaponA      = Tool(GlobalDefinitions.jammer_grenade)
   val projectileA  = weaponA.Projectile
   val resolvedA = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectileA,
       weaponA.Definition,
@@ -983,7 +964,6 @@ class DamageableWeaponTurretDestructionTest extends ActorTest {
   val weaponB     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectileB = weaponB.Projectile
   val resolvedB = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectileB,
       weaponB.Definition,
@@ -1046,8 +1026,8 @@ class DamageableWeaponTurretDestructionTest extends ActorTest {
       )
       assert(
         msg56.head match {
-          case VehicleServiceMessage.TurretUpgrade(SupportActor.ClearSpecific(List(t), _)) if t eq turret => true
-          case _                                                                                          => false
+          case VehicleServiceMessage.TurretUpgrade(SupportActor.ClearSpecific(List(t), _)) if turret eq t => true
+          case _                                                                           => false
         }
       )
       assert(
@@ -1105,7 +1085,6 @@ class DamageableVehicleDamageTest extends ActorTest {
   val projectile    = weapon.Projectile
   val vehicleSource = SourceEntry(atv)
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Hit,
     Projectile(
       projectile,
       weapon.Definition,
@@ -1237,7 +1216,6 @@ class DamageableVehicleDamageMountedTest extends ActorTest {
   val projectile    = weapon.Projectile
   val vehicleSource = SourceEntry(lodestar)
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Hit,
     Projectile(
       projectile,
       weapon.Definition,
@@ -1385,7 +1363,6 @@ class DamageableVehicleJammeringMountedTest extends ActorTest {
   val weapon        = Tool(GlobalDefinitions.jammer_grenade)
   val projectile    = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -1475,7 +1452,6 @@ class DamageableVehicleDestroyTest extends ActorTest {
   val projectile    = weapon.Projectile
   val vehicleSource = SourceEntry(atv)
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Hit,
     Projectile(
       projectile,
       weapon.Definition,
@@ -1601,7 +1577,6 @@ class DamageableVehicleDestroyMountedTest extends ActorTest {
   val weaponA       = Tool(GlobalDefinitions.jammer_grenade)
   val projectileA   = weaponA.Projectile
   val resolvedA = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectileA,
       weaponA.Definition,
@@ -1620,7 +1595,6 @@ class DamageableVehicleDestroyMountedTest extends ActorTest {
   val weaponB     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectileB = weaponB.Projectile
   val resolvedB = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectileB,
       weaponB.Definition,

src/test/scala/objects/DeployableTest.scala

@@ -334,7 +334,6 @@ class ExplosiveDeployableJammerTest extends ActorTest {
   val pSource     = PlayerSource(player1)
   val projectile  = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(projectile, weapon.Definition, weapon.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
     jMineSource,
     j_mine.DamageModel,
@@ -432,7 +431,6 @@ class ExplosiveDeployableJammerExplodeTest extends ActorTest {
   val pSource     = PlayerSource(player1)
   val projectile  = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(projectile, weapon.Definition, weapon.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
     hMineSource,
     h_mine.DamageModel,
@@ -542,7 +540,6 @@ class ExplosiveDeployableDestructionTest extends ActorTest {
   val pSource     = PlayerSource(player1)
   val projectile  = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(projectile, weapon.Definition, weapon.FireMode, pSource, 0, Vector3.Zero, Vector3.Zero),
     hMineSource,
     h_mine.DamageModel,

src/test/scala/objects/GeneratorTest.scala

@@ -80,7 +80,6 @@ class GeneratorControlDamageTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -162,7 +161,6 @@ class GeneratorControlCriticalTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -253,7 +251,6 @@ class GeneratorControlDestroyedTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -384,7 +381,6 @@ class GeneratorControlKillsTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -507,7 +503,6 @@ class GeneratorControlNotDestroyTwice extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -597,7 +592,6 @@ class GeneratorControlNotDamageIfExplodingTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,
@@ -691,7 +685,6 @@ class GeneratorControlNotRepairIfExplodingTest extends ActorTest {
   val weapon     = Tool(GlobalDefinitions.phoenix) //decimator
   val projectile = weapon.Projectile
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Splash,
     Projectile(
       projectile,
       weapon.Definition,

src/test/scala/objects/PlayerControlTest.scala

@@ -378,7 +378,6 @@ class PlayerControlDamageTest extends ActorTest {
   val projectile   = tool.Projectile
   val playerSource = SourceEntry(player2)
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Hit,
     Projectile(
       projectile,
       tool.Definition,
@@ -478,7 +477,6 @@ class PlayerControlDeathStandingTest extends ActorTest {
   val projectile    = tool.Projectile
   val player1Source = SourceEntry(player1)
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Hit,
     Projectile(projectile, tool.Definition, tool.FireMode, player1Source, 0, Vector3(2, 0, 0), Vector3(-1, 0, 0)),
     SourceEntry(player2),
     player2.DamageModel,
@@ -607,7 +605,6 @@ class PlayerControlDeathSeatedTest extends ActorTest {
   val projectile    = tool.Projectile
   val player1Source = SourceEntry(player1)
   val resolved = ResolvedProjectile(
-    ProjectileResolution.Hit,
     Projectile(projectile, tool.Definition, tool.FireMode, player1Source, 0, Vector3(2, 0, 0), Vector3(-1, 0, 0)),
     SourceEntry(player2),
     player2.DamageModel,

src/test/scala/objects/ProjectileTest.scala

@@ -352,13 +352,11 @@ class ProjectileTest extends Specification {
 
     "construct" in {
       val obj = ResolvedProjectile(
-        ProjectileResolution.Hit,
         projectile,
         PlayerSource(player2),
         fury_dm,
         Vector3(1.2f, 3.4f, 5.6f)
       )
-      obj.resolution mustEqual ProjectileResolution.Hit
       obj.projectile mustEqual projectile
       obj.target mustEqual p2_source
       obj.damage_model mustEqual fury.DamageModel

src/test/scala/objects/VehicleTest.scala

@@ -997,7 +997,7 @@ class VehicleControlShieldsNotChargingTooEarlyTest extends ActorTest {
 //  val p_source = PlayerSource( Player(Avatar(0, "TestTarget", PlanetSideEmpire.NC, CharacterGender.Female, 1, CharacterVoice.Mute)) )
 //  val projectile = Projectile(beamer_wep.Projectile, GlobalDefinitions.beamer, beamer_wep.FireMode, p_source, GlobalDefinitions.beamer.ObjectId, Vector3.Zero, Vector3.Zero)
 //  val fury_dm = Vehicle(GlobalDefinitions.fury).DamageModel
-//  val obj = ResolvedProjectile(ProjectileResolution.Hit, projectile, p_source, fury_dm, Vector3(1.2f, 3.4f, 5.6f))
+//  val obj = ResolvedProjectile(projectile, p_source, fury_dm, Vector3(1.2f, 3.4f, 5.6f))
 //
 //  "not charge vehicle shields if recently damaged" in {
 //    assert(vehicle.Shields == 0)

src/test/scala/objects/VitalityTest.scala

@@ -21,7 +21,6 @@ class VitalityTest extends Specification {
       val pSource    = PlayerSource(player)
       val projectile = Projectile(proj, wep, wep_fmode, player, Vector3(2, 2, 0), Vector3.Zero)
       val resprojectile = ResolvedProjectile(
-        ProjectileResolution.Splash,
         projectile,
         SourceEntry(player),
         player.DamageModel,
@@ -69,7 +68,6 @@ class VitalityTest extends Specification {
       val pSource    = PlayerSource(player)
       val projectile = Projectile(proj, wep, wep_fmode, player, Vector3(2, 2, 0), Vector3.Zero)
       val resprojectile = ResolvedProjectile(
-        ProjectileResolution.Splash,
         projectile,
         SourceEntry(player),
         player.DamageModel,