created generic progress messages and moved their creation into the specific control agencies that would utilize them; this moves code out from WSA and restores the original purpose of CommonMessages.Hack (#349)

common/src/main/scala/net/psforever/objects/avatar/PlayerControl.scala

@@ -2,14 +2,11 @@
 package net.psforever.objects.avatar
 
 import akka.actor.Actor
-import net.psforever.objects.{DefaultCancellable, ImplantSlot, Player}
+import net.psforever.objects.{DefaultCancellable, GlobalDefinitions, ImplantSlot, Player, Players, Tool}
 import net.psforever.objects.ballistics.{PlayerSource, ResolvedProjectile, SourceEntry}
 import net.psforever.objects.definition.ImplantDefinition
-import net.psforever.objects.equipment.{JammableBehavior, JammableUnit}
-import net.psforever.objects.vital.{PlayerSuicide, Vitality}
-import net.psforever.objects.{GlobalDefinitions, Player, Tool}
-import net.psforever.objects.ballistics.{PlayerSource, ResolvedProjectile}
 import net.psforever.objects.equipment.{Ammo, JammableBehavior, JammableUnit}
+import net.psforever.objects.vital.{PlayerSuicide, Vitality}
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.serverobject.damage.Damageable
 import net.psforever.objects.serverobject.mount.Mountable
@@ -17,8 +14,7 @@ import net.psforever.objects.serverobject.repair.Repairable
 import net.psforever.objects.vital._
 import net.psforever.objects.zones.Zone
 import net.psforever.packet.game._
-import net.psforever.types.{ExoSuitType, ImplantType, PlanetSideGUID}
-import net.psforever.types.{ExoSuitType, Vector3}
+import net.psforever.types.{ExoSuitType, ImplantType, PlanetSideGUID, Vector3}
 import services.Service
 import services.avatar.{AvatarAction, AvatarServiceMessage}
 
@@ -167,7 +163,11 @@ class PlayerControl(player : Player) extends Actor
         if(user != player && user.isAlive && !user.isMoving &&
           !player.isBackpack &&
           item.Magazine >= 25) {
-          sender ! CommonMessages.Use(player, Some((item, user)))
+          sender ! CommonMessages.Progress(
+            4,
+            Players.FinishRevivingPlayer(player, user.Name),
+            Players.RevivingTickAction(player, user, item)
+          )
         }
 
       case CommonMessages.Use(user, Some(item : Tool)) if item.Definition == GlobalDefinitions.bank =>

common/src/main/scala/net/psforever/objects/serverobject/CommonMessages.scala

@@ -10,4 +10,17 @@ object CommonMessages {
   final case class Unuse(player : Player, data : Option[Any] = None)
   final case class Hack(player : Player, obj : PlanetSideServerObject with Hackable, data : Option[Any] = None)
   final case class ClearHack()
+
+  /**
+    * The message that initializes a process -
+    * some form of user-driven activity with a certain eventual outcome and potential feedback per cycle.
+    * The feedback is usually only known to the individual attempting the process.
+    * @param delta how much the progress value changes each tick, which will be treated as a percentage;
+    *              must be a positive value
+    * @param completionAction a finalizing action performed once the progress reaches 100(%)
+    * @param tickAction an action that is performed for each increase of progress
+    */
+  final case class Progress(delta : Float, completionAction : ()=>Unit, tickAction : Float=>Boolean) {
+    assert(delta > 0, s"progress activity change value must be positive number - $delta")
+  }
 }

common/src/main/scala/net/psforever/objects/serverobject/implantmech/ImplantTerminalMechControl.scala

@@ -9,7 +9,7 @@ import net.psforever.objects.serverobject.mount.{Mountable, MountableBehavior}
 import net.psforever.objects.serverobject.affinity.FactionAffinityBehavior
 import net.psforever.objects.serverobject.damage.Damageable.Target
 import net.psforever.objects.serverobject.damage.{Damageable, DamageableEntity, DamageableMountable}
-import net.psforever.objects.serverobject.hackable.HackableBehavior
+import net.psforever.objects.serverobject.hackable.{GenericHackables, HackableBehavior}
 import net.psforever.objects.serverobject.repair.RepairableEntity
 import net.psforever.objects.serverobject.structures.Building
 
@@ -41,7 +41,11 @@ class ImplantTerminalMechControl(mech : ImplantTerminalMech) extends Actor
         //TODO setup certifications check
         mech.Owner match {
           case b : Building if (b.Faction != player.Faction || b.CaptureConsoleIsHacked) && mech.HackedBy.isEmpty =>
-            sender ! CommonMessages.Hack(player, mech, Some(item))
+            sender ! CommonMessages.Progress(
+              GenericHackables.GetHackSpeed(player, mech),
+              GenericHackables.FinishHacking(mech, player, 3212836864L),
+              GenericHackables.HackingTickAction(progressType = 1, player, mech, item.GUID)
+            )
           case _ => ;
         }
       case _ => ;

common/src/main/scala/net/psforever/objects/serverobject/locks/IFFLockControl.scala

@@ -5,7 +5,7 @@ import akka.actor.Actor
 import net.psforever.objects.{GlobalDefinitions, SimpleItem}
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.serverobject.affinity.{FactionAffinity, FactionAffinityBehavior}
-import net.psforever.objects.serverobject.hackable.HackableBehavior
+import net.psforever.objects.serverobject.hackable.{GenericHackables, HackableBehavior}
 
 /**
   * An `Actor` that handles messages being dispatched to a specific `IFFLock`.
@@ -20,8 +20,19 @@ class IFFLockControl(lock : IFFLock) extends Actor with FactionAffinityBehavior.
     .orElse(hackableBehavior)
     .orElse {
       case CommonMessages.Use(player, Some(item : SimpleItem)) if item.Definition == GlobalDefinitions.remote_electronics_kit =>
-        if((lock.Faction != player.Faction && lock.HackedBy.isEmpty) || (lock.Faction == player.Faction && lock.HackedBy.nonEmpty)) {
-          sender ! CommonMessages.Hack(player, lock, Some(item))
+        if(lock.Faction != player.Faction && lock.HackedBy.isEmpty) {
+          sender ! CommonMessages.Progress(
+            GenericHackables.GetHackSpeed(player, lock),
+            GenericHackables.FinishHacking(lock, player, 1114636288L),
+            GenericHackables.HackingTickAction(progressType = 1, player, lock, item.GUID)
+          )
+        }
+        else if(lock.Faction == player.Faction && lock.HackedBy.nonEmpty) {
+          sender ! CommonMessages.Progress(
+            GenericHackables.GetHackSpeed(player, lock),
+            IFFLocks.FinishResecuringIFFLock(lock),
+            GenericHackables.HackingTickAction(progressType = 1, player, lock, item.GUID)
+          )
         }
         else {
           val log = org.log4s.getLogger

common/src/main/scala/net/psforever/objects/serverobject/mblocker/LockerControl.scala

@@ -5,7 +5,7 @@ import akka.actor.Actor
 import net.psforever.objects.{GlobalDefinitions, SimpleItem}
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.serverobject.affinity.{FactionAffinity, FactionAffinityBehavior}
-import net.psforever.objects.serverobject.hackable.HackableBehavior
+import net.psforever.objects.serverobject.hackable.{GenericHackables, HackableBehavior}
 
 /**
   * An `Actor` that handles messages being dispatched to a specific `Locker`.
@@ -21,7 +21,11 @@ class LockerControl(locker : Locker) extends Actor with FactionAffinityBehavior.
       case CommonMessages.Use(player, Some(item : SimpleItem)) if item.Definition == GlobalDefinitions.remote_electronics_kit =>
         //TODO setup certifications check
         if(locker.Faction != player.Faction && locker.HackedBy.isEmpty) {
-          sender ! CommonMessages.Hack(player, locker, Some(item))
+          sender ! CommonMessages.Progress(
+            GenericHackables.GetHackSpeed(player, locker),
+            GenericHackables.FinishHacking(locker, player, 3212836864L),
+            GenericHackables.HackingTickAction(progressType = 1, player, locker, item.GUID)
+          )
         }
       case _ => ;
   }

common/src/main/scala/net/psforever/objects/serverobject/terminals/CaptureTerminalControl.scala

@@ -5,7 +5,7 @@ import akka.actor.Actor
 import net.psforever.objects.{GlobalDefinitions, SimpleItem}
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.serverobject.affinity.{FactionAffinity, FactionAffinityBehavior}
-import net.psforever.objects.serverobject.hackable.HackableBehavior
+import net.psforever.objects.serverobject.hackable.{GenericHackables, HackableBehavior}
 
 
 class CaptureTerminalControl(terminal : CaptureTerminal) extends Actor with FactionAffinityBehavior.Check with HackableBehavior.GenericHackable {
@@ -21,7 +21,11 @@ class CaptureTerminalControl(terminal : CaptureTerminal) extends Actor with Fact
           case _ => terminal.Faction != player.Faction
         }
         if(canHack) {
-          sender ! CommonMessages.Hack(player, terminal, Some(item))
+          sender ! CommonMessages.Progress(
+            GenericHackables.GetHackSpeed(player, terminal),
+            CaptureTerminals.FinishHackingCaptureConsole(terminal, player, 3212836864L),
+            GenericHackables.HackingTickAction(progressType = 1, player, terminal, item.GUID)
+          )
         }
 
       case _ => ; //no default message

common/src/main/scala/net/psforever/objects/serverobject/terminals/ProximityTerminalControl.scala

@@ -6,7 +6,7 @@ import net.psforever.objects._
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.serverobject.affinity.FactionAffinityBehavior
 import net.psforever.objects.serverobject.damage.DamageableAmenity
-import net.psforever.objects.serverobject.hackable.HackableBehavior
+import net.psforever.objects.serverobject.hackable.{GenericHackables, HackableBehavior}
 import net.psforever.objects.serverobject.repair.RepairableAmenity
 import net.psforever.objects.serverobject.structures.Building
 
@@ -43,7 +43,11 @@ class ProximityTerminalControl(term : Terminal with ProximityUnit) extends Actor
         //TODO setup certifications check
         term.Owner match {
           case b : Building if (b.Faction != player.Faction || b.CaptureConsoleIsHacked) && term.HackedBy.isEmpty =>
-            sender ! CommonMessages.Hack(player, term, Some(item))
+            sender ! CommonMessages.Progress(
+              GenericHackables.GetHackSpeed(player, term),
+              GenericHackables.FinishHacking(term, player, 3212836864L),
+              GenericHackables.HackingTickAction(progressType = 1, player, term, item.GUID)
+            )
           case _ => ;
         }
 

common/src/main/scala/net/psforever/objects/serverobject/terminals/TerminalControl.scala

@@ -6,7 +6,7 @@ import net.psforever.objects.{GlobalDefinitions, SimpleItem}
 import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.serverobject.affinity.FactionAffinityBehavior
 import net.psforever.objects.serverobject.damage.DamageableAmenity
-import net.psforever.objects.serverobject.hackable.HackableBehavior
+import net.psforever.objects.serverobject.hackable.{GenericHackables, HackableBehavior}
 import net.psforever.objects.serverobject.repair.RepairableAmenity
 import net.psforever.objects.serverobject.structures.Building
 
@@ -36,7 +36,11 @@ class TerminalControl(term : Terminal) extends Actor
         //TODO setup certifications check
         term.Owner match {
           case b : Building if (b.Faction != player.Faction || b.CaptureConsoleIsHacked) && term.HackedBy.isEmpty =>
-            sender ! CommonMessages.Hack(player, term, Some(item))
+            sender ! CommonMessages.Progress(
+              GenericHackables.GetHackSpeed(player, term),
+              GenericHackables.FinishHacking(term, player, 3212836864L),
+              GenericHackables.HackingTickAction(progressType = 1, player, term, item.GUID)
+            )
           case _ => ;
         }
       case _ => ;

common/src/main/scala/net/psforever/objects/serverobject/turret/FacilityTurretControl.scala

@@ -3,11 +3,13 @@ package net.psforever.objects.serverobject.turret
 
 import akka.actor.Actor
 import net.psforever.objects.ballistics.ResolvedProjectile
-import net.psforever.objects.{GlobalDefinitions, Player}
-import net.psforever.objects.equipment.JammableMountedWeapons
+import net.psforever.objects.{GlobalDefinitions, Player, Tool}
+import net.psforever.objects.equipment.{Ammo, JammableMountedWeapons}
+import net.psforever.objects.serverobject.CommonMessages
 import net.psforever.objects.serverobject.mount.MountableBehavior
 import net.psforever.objects.serverobject.affinity.FactionAffinityBehavior
 import net.psforever.objects.serverobject.damage.DamageableWeaponTurret
+import net.psforever.objects.serverobject.hackable.GenericHackables
 import net.psforever.objects.serverobject.repair.Repairable.Target
 import net.psforever.objects.serverobject.repair.RepairableWeaponTurret
 import services.avatar.{AvatarAction, AvatarServiceMessage}
@@ -49,6 +51,20 @@ class FacilityTurretControl(turret : FacilityTurret) extends Actor
     .orElse(takesDamage)
     .orElse(canBeRepairedByNanoDispenser)
     .orElse {
+      case CommonMessages.Use(player, Some((item : Tool, upgradeValue : Int)))
+        if player.Faction == turret.Faction &&
+          item.Definition == GlobalDefinitions.nano_dispenser && item.AmmoType == Ammo.upgrade_canister &&
+          item.Magazine > 0 && turret.Seats.values.forall(!_.isOccupied) =>
+        TurretUpgrade.values.find(_.id == upgradeValue) match {
+          case Some(upgrade) if turret.Upgrade != upgrade && turret.Definition.Weapons.values.flatMap( _.keySet).exists(_ == upgrade) =>
+            sender ! CommonMessages.Progress(
+              1.25f,
+              WeaponTurrets.FinishUpgradingMannedTurret(turret, player, item, upgrade),
+              GenericHackables.HackingTickAction(progressType = 2, player, turret, item.GUID)
+            )
+          case _ => ;
+        }
+
       case FacilityTurret.RechargeAmmo() =>
         val weapon = turret.ControlledWeapon(1).get.asInstanceOf[net.psforever.objects.Tool]
         // recharge when last shot fired 3s delay, +1, 200ms interval

common/src/main/scala/net/psforever/objects/vehicles/VehicleControl.scala

@@ -2,7 +2,7 @@
 package net.psforever.objects.vehicles
 
 import akka.actor.{Actor, ActorRef}
-import net.psforever.objects.{GlobalDefinitions, SimpleItem, Vehicle}
+import net.psforever.objects.{GlobalDefinitions, SimpleItem, Vehicle, Vehicles}
 import net.psforever.objects.ballistics.{ResolvedProjectile, VehicleSource}
 import net.psforever.objects.equipment.JammableMountedWeapons
 import net.psforever.objects.serverobject.CommonMessages
@@ -10,6 +10,7 @@ import net.psforever.objects.serverobject.mount.{Mountable, MountableBehavior}
 import net.psforever.objects.serverobject.affinity.{FactionAffinity, FactionAffinityBehavior}
 import net.psforever.objects.serverobject.damage.DamageableVehicle
 import net.psforever.objects.serverobject.deploy.DeploymentBehavior
+import net.psforever.objects.serverobject.hackable.GenericHackables
 import net.psforever.objects.serverobject.repair.RepairableVehicle
 import net.psforever.objects.vital.VehicleShieldCharge
 import net.psforever.types.{ExoSuitType, PlanetSideGUID}
@@ -86,7 +87,11 @@ class VehicleControl(vehicle : Vehicle) extends Actor
       case CommonMessages.Use(player, Some(item : SimpleItem)) if item.Definition == GlobalDefinitions.remote_electronics_kit =>
         //TODO setup certifications check
         if(vehicle.Faction != player.Faction) {
-          sender ! CommonMessages.Hack(player, vehicle, Some(item))
+          sender ! CommonMessages.Progress(
+            GenericHackables.GetHackSpeed(player, vehicle),
+            Vehicles.FinishHackingVehicle(vehicle, player,3212836864L),
+            GenericHackables.HackingTickAction(progressType = 1, player, vehicle, item.GUID)
+          )
         }
 
       case Vehicle.PrepareForDeletion() =>

pslogin/src/main/scala/WorldSessionActor.scala

@@ -298,100 +298,12 @@ class WorldSessionActor extends Actor
     case AvatarServiceResponse(toChannel, guid, reply) =>
       HandleAvatarServiceResponse(toChannel, guid, reply)
 
-    case CommonMessages.Hack(tplayer, obj : Locker, Some(item : SimpleItem)) if tplayer == player =>
-      val hackSpeed = GenericHackables.GetHackSpeed(player, obj)
-      if(hackSpeed > 0) {
-        progressBarValue = Some(-hackSpeed)
-        self ! Progress(
-          hackSpeed,
-          GenericHackables.FinishHacking(obj, tplayer, 3212836864L),
-          GenericHackables.HackingTickAction(progressType = 1, tplayer, obj, item.GUID)
-        )
-        log.info(s"${tplayer.Name} is hacking a locker")
-      }
+    case CommonMessages.Progress(rate, finishedAction, stepAction) =>
+      progressBarValue = Some(-rate)
+      self ! ProgressEvent(rate, finishedAction, stepAction)
 
-    case CommonMessages.Hack(tplayer, obj : CaptureTerminal, Some(item : SimpleItem)) if tplayer == player =>
-      val hackSpeed = GenericHackables.GetHackSpeed(player, obj)
-      if(hackSpeed > 0) {
-        progressBarValue = Some(-hackSpeed)
-        self ! Progress(
-          hackSpeed,
-          CaptureTerminals.FinishHackingCaptureConsole(obj, player, 3212836864L),
-          GenericHackables.HackingTickAction(progressType = 1, tplayer, obj, item.GUID)
-        )
-        log.info(s"${tplayer.Name} is hacking a capture terminal")
-      }
-
-    case CommonMessages.Hack(tplayer, obj : ImplantTerminalMech, Some(item : SimpleItem)) if tplayer == player =>
-      val hackSpeed = GenericHackables.GetHackSpeed(player, obj)
-      if(hackSpeed > 0) {
-        progressBarValue = Some(-hackSpeed)
-        self ! Progress(
-          hackSpeed,
-          GenericHackables.FinishHacking(obj, tplayer, 3212836864L),
-          GenericHackables.HackingTickAction(progressType = 1, tplayer, obj, item.GUID)
-        )
-        log.info(s"${tplayer.Name} is hacking an implant terminal")
-      }
-
-    case CommonMessages.Hack(tplayer, obj : Terminal, Some(item : SimpleItem)) if tplayer == player =>
-      val hackSpeed = GenericHackables.GetHackSpeed(player, obj)
-      if(hackSpeed > 0) {
-        progressBarValue = Some(-hackSpeed)
-        self ! Progress(
-          hackSpeed,
-          GenericHackables.FinishHacking(obj, tplayer, 3212836864L),
-          GenericHackables.HackingTickAction(progressType = 1, tplayer, obj, item.GUID)
-        )
-        log.info(s"${tplayer.Name} is hacking a terminal")
-      }
-
-    case CommonMessages.Hack(tplayer, obj : IFFLock, Some(item : SimpleItem)) if tplayer == player =>
-      val hackSpeed = GenericHackables.GetHackSpeed(player, obj)
-      if(hackSpeed > 0) {
-        progressBarValue = Some(-hackSpeed)
-        if(obj.Faction != tplayer.Faction) {
-          // Enemy faction is hacking this IFF lock
-          self ! Progress(
-            hackSpeed,
-            GenericHackables.FinishHacking(obj, tplayer, 1114636288L),
-            GenericHackables.HackingTickAction(progressType = 1, tplayer, obj, item.GUID)
-          )
-          log.info(s"${tplayer.Name} is hacking an IFF lock")
-        }
-        else {
-          // IFF Lock is being resecured by it's owner faction
-          self ! Progress(
-            hackSpeed,
-            IFFLocks.FinishResecuringIFFLock(obj),
-            GenericHackables.HackingTickAction(progressType = 1, player, obj, item.GUID)
-          )
-          log.info(s"${player.Name} is resecuring an IFF lock")
-        }
-      }
-
-    case CommonMessages.Hack(tplayer, obj : Vehicle, Some(item : SimpleItem)) if tplayer == player =>
-      val hackSpeed = GenericHackables.GetHackSpeed(player, obj)
-      if(hackSpeed > 0) {
-        progressBarValue = Some(-hackSpeed)
-        self ! Progress(
-          hackSpeed,
-          Vehicles.FinishHackingVehicle(obj, tplayer,3212836864L),
-          GenericHackables.HackingTickAction(progressType = 1, tplayer, obj, item.GUID)
-        )
-        log.trace(s"${tplayer.Name} is hacking a vehicle")
-      }
-
-    case CommonMessages.Use(tplayer, Some((item : Tool, user : Player))) =>
-      if(progressBarValue.isEmpty) {
-        progressBarValue = Some(-4)
-        self ! Progress(
-          4,
-          Players.FinishRevivingPlayer(tplayer, user.Name),
-          Players.RevivingTickAction(tplayer, user, item)
-        )
-        log.trace(s"${user.Name} is reviving a dead ally")
-      }
+    case ProgressEvent(delta, completeAction, tickAction) =>
+      HandleProgressChange(delta, completeAction, tickAction)
 
     case Door.DoorMessage(tplayer, msg, order) =>
       HandleDoorMessage(tplayer, msg, order)
@@ -1261,9 +1173,6 @@ class WorldSessionActor extends Actor
     case NtuDischarging(tplayer, vehicle, silo_guid) =>
       HandleNtuDischarging(tplayer, vehicle, silo_guid)
 
-    case Progress(delta, completeAction, tickAction) =>
-      HandleProgressChange(delta, completeAction, tickAction)
-
     case Vitality.DamageResolution(target : TelepadDeployable, _) =>
       //telepads
       if(target.Health <= 0) {
@@ -3088,7 +2997,7 @@ class WorldSessionActor extends Actor
   }
 
   /**
-    * Handle the message that indidctes the level of completion of a process.
+    * Handle the message that indicates the level of completion of a process.
     * The process is any form of user-driven activity with a certain eventual outcome
     * but indeterminate progress feedback per cycle.<br>
     * <br>
@@ -3127,7 +3036,7 @@ class WorldSessionActor extends Actor
             progressBarValue = Some(next)
             import scala.concurrent.ExecutionContext.Implicits.global
             progressBarUpdate = context.system.scheduler.scheduleOnce(100 milliseconds, self,
-              Progress(delta, completionAction, tickAction)
+              ProgressEvent(delta, completionAction, tickAction)
             )
           }
           else {
@@ -3140,7 +3049,7 @@ class WorldSessionActor extends Actor
             progressBarValue = Some(next)
             import scala.concurrent.ExecutionContext.Implicits.global
             progressBarUpdate = context.system.scheduler.scheduleOnce(250 milliseconds, self,
-              Progress(delta, completionAction, tickAction)
+              ProgressEvent(delta, completionAction, tickAction)
             )
           }
           else {
@@ -5143,25 +5052,10 @@ class WorldSessionActor extends Actor
           }
 
         case Some(obj : FacilityTurret) =>
-          val tdef = obj.Definition
-          (obj.Owner, equipment) match {
-            case (b : Building, Some(gluegun : Tool)) if b.Faction == player.Faction &&
-              gluegun.Definition == GlobalDefinitions.nano_dispenser =>
-              gluegun.AmmoType match {
-                case Ammo.armor_canister => //repair
-                  obj.Actor ! CommonMessages.Use(player, Some(gluegun))
-
-                case Ammo.upgrade_canister if gluegun.Magazine > 0 && obj.Seats.values.forall(!_.isOccupied) => //upgrade
-                  progressBarValue = Some(-1.25f)
-                  self ! Progress(
-                    delta = 1.25f,
-                    WeaponTurrets.FinishUpgradingMannedTurret(obj, player, gluegun, TurretUpgrade(unk2.toInt)),
-                    GenericHackables.HackingTickAction(progressType = 2, player, obj, gluegun.GUID)
-                  )
-
-                case _ => ;
-              }
-
+          equipment match {
+            case Some(item) =>
+              obj.Actor ! CommonMessages.Use(player, Some(item)) //try generic
+              obj.Actor ! CommonMessages.Use(player, Some((item, unk2.toInt))) //try upgrade path
             case _ => ;
           }
 
@@ -10816,17 +10710,14 @@ object WorldSessionActor {
   private final case class VehicleLoaded(vehicle : Vehicle)
 
   /**
-    * The message that indidctes the level of completion of a process.
-    * The process is any form of user-driven activity with a certain eventual outcome
-    * but indeterminate progress feedback per cycle.
+    * The message that progresses some form of user-driven activity with a certain eventual outcome
+    * and potential feedback per cycle.
     * @param delta how much the progress value changes each tick, which will be treated as a percentage;
     *              must be a positive value
-    * @param completeAction a finalizing action performed once the progress reaches 100(%)
+    * @param completionAction a finalizing action performed once the progress reaches 100(%)
     * @param tickAction an action that is performed for each increase of progress
     */
-  private final case class Progress(delta : Float, completionAction : ()=>Unit, tickAction : Float=>Boolean) {
-    assert(delta > 0, s"progress activity change value must be positive number - $delta")
-  }
+  final case class ProgressEvent(delta : Float, completionAction : ()=>Unit, tickAction : Float=>Boolean)
 
   protected final case class SquadUIElement(name : String, index : Int, zone : Int, health : Int, armor : Int, position : Vector3)