PSForever/PSF-LoginServer
1
0
Fork 0
mirror of https://github.com/psforever/PSF-LoginServer.git synced 2026-01-19 18:44:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Unique Number System Operations (#906)

Browse source 
* propagation of the ask pattern into the unique number actor

* TaskWorkflow as a replacement for TaskResolver; includes working tests

* AvailabilityPolicy has been changed slightly; number source restriction mechanic has been completely removed

* TaskResolver is gone and done and TaskWorkflow replaces it

* number pool variety

* every zone gets a custom tailored 'environment' number pool, as well as all other number pools; uns involves many more static functions and hard-defined variables

* repairs to uns and guidtask tests; worked uns into unops, an actorless version, but did not integrate into server

* shuffled around files in the guid package, causing import threshing; wrote extensive comments; repaired tests; classes related to the old unique number system have been removed

* created straightforward tasks; simplified number pool actor calls; repaired tests due to modifications to generic pool

* bad merge recovery
This commit is contained in:
Fate-JH 2021-08-15 21:27:45 -04:00 committed by GitHub
parent ce2a3f5422
commit 9841b7e97d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
114 changed files with 2323 additions and 3374 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
server/src/test/scala/actor/service/AvatarServiceTest.scala
View file

@ -491,11 +491,7 @@ class AvatarStowEquipmentTest extends ActorTest {
/*
Preparation for these three Release tests is involved.
The ServiceManager must not only be set up correctly, but must be given a TaskResolver.
The AvatarService is started and that starts CorpseRemovalActor, an essential part of this test.
The CorpseRemovalActor needs that TaskResolver created by the ServiceManager;
but, another independent TaskResolver will be needed for manual parts of the test.
(The ServiceManager's TaskResolver can be "borrowed" but that requires writing code to intercept it.)
The ServiceManager must be set up correctly.
The Zone needs to be set up and initialized properly with a ZoneActor.
The ZoneActor builds the GUID Actor and the ZonePopulationActor.

5
src/main/resources/akka.conf
View file

@ -46,11 +46,6 @@ akka.actor.deployment {
dispatcher = galaxy-service
}
# Isolate tasks
"/service/taskResolver*" {
dispatcher = task-dispatcher
}
# Bottleneck (dedicated thread)
"/service/cluster" {
dispatcher = interstellar-cluster-service

8
src/main/resources/guid-pools/c1.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 937,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/c2.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 1615,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/c3.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 1128,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/c4.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 904,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/c5.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 635,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/c6.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 908,
"Selector": "specific"
}
]

74
src/main/resources/guid-pools/default.json Normal file
View file

@ -0,0 +1,74 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 3000,
"Selector": "specific"
},
{
"Name": "players",
"Start": 3001,
"Max": 4500,
"Selector": "random"
},
{
"Name": "lockers",
"Start": 4501,
"Max": 5000,
"Selector": "random"
},
{
"Name": "tools",
"Start": 5001,
"Max": 9500,
"Selector": "random"
},
{
"Name": "ammo",
"Start": 9501,
"Max": 23000,
"Selector": "random"
},
{
"Name": "kits",
"Start": 23001,
"Max": 36500,
"Selector": "random"
},
{
"Name": "items",
"Start": 36501,
"Max": 39500,
"Selector": "random"
},
{
"Name": "projectiles",
"Start": 40100,
"Max": 40149,
"Selector": "specific"
},
{
"Name": "locker-contents",
"Start": 40150,
"Max": 40450,
"Selector": "specific"
},
{
"Name": "vehicles",
"Start": 45001,
"Max": 47000,
"Selector": "random"
},
{
"Name": "terminals",
"Start": 47001,
"Max": 48000,
"Selector": "random"
},
{
"Name": "deployables",
"Start": 48001,
"Max": 64000,
"Selector": "random"
}
]

8
src/main/resources/guid-pools/home1.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 1161,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/home2.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 1096,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/home3.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 1074,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/i1.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 778,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/i2.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 918,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/i3.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 699,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/i4.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 318,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/z1.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 2088,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/z10.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 2657,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/z2.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 2515,
"Selector": "specific"
}
]

44
src/main/resources/guid-pools/z3.json Normal file
View file

@ -0,0 +1,44 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 3732,
"Selector": "specific"
},
{
"Name": "players",
"Start": 4001,
"Max": 5500,
"Selector": "random"
},
{
"Name": "lockers",
"Start": 5501,
"Max": 6000,
"Selector": "random"
},
{
"Name": "tools",
"Start": 6001,
"Max": 10500,
"Selector": "random"
},
{
"Name": "ammo",
"Start": 10501,
"Max": 24000,
"Selector": "random"
},
{
"Name": "kits",
"Start": 24001,
"Max": 37500,
"Selector": "random"
},
{
"Name": "items",
"Start": 37501,
"Max": 40099,
"Selector": "random"
}
]

44
src/main/resources/guid-pools/z4.json Normal file
View file

@ -0,0 +1,44 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 3076,
"Selector": "specific"
},
{
"Name": "players",
"Start": 3101,
"Max": 4600,
"Selector": "random"
},
{
"Name": "lockers",
"Start": 4601,
"Max": 5100,
"Selector": "random"
},
{
"Name": "tools",
"Start": 5101,
"Max": 9600,
"Selector": "random"
},
{
"Name": "ammo",
"Start": 9601,
"Max": 23100,
"Selector": "random"
},
{
"Name": "kits",
"Start": 23101,
"Max": 36600,
"Selector": "random"
},
{
"Name": "items",
"Start": 36601,
"Max": 39600,
"Selector": "random"
}
]

8
src/main/resources/guid-pools/z5.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 2112,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/z6.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 2422,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/z7.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 2816,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/z8.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 2139,
"Selector": "specific"
}
]

8
src/main/resources/guid-pools/z9.json Normal file
View file

@ -0,0 +1,8 @@
[
{
"Name": "environment",
"Start": 0,
"Max": 2921,
"Selector": "specific"
}
]

436
src/main/scala/net/psforever/actors/session/SessionActor.scala
View file

@ -16,7 +16,7 @@ import net.psforever.objects.definition._
import net.psforever.objects.definition.converter.{CorpseConverter, DestroyedVehicleConverter}
import net.psforever.objects.entity.{SimpleWorldEntity, WorldEntity}
import net.psforever.objects.equipment._
import net.psforever.objects.guid.{GUIDTask, Task, TaskResolver}
import net.psforever.objects.guid._
import net.psforever.objects.inventory.{Container, InventoryItem}
import net.psforever.objects.locker.LockerContainer
import net.psforever.objects.serverobject.affinity.FactionAffinity
@ -1049,11 +1049,11 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
//!!only dispatched to SessionActor as cleanup if the target deployable was never fully introduced
case Zone.Deployable.IsDismissed(obj: TurretDeployable) =>
continent.tasks ! GUIDTask.UnregisterDeployableTurret(obj)(continent.GUID)
TaskWorkflow.execute(GUIDTask.unregisterDeployableTurret(continent.GUID, obj))
//!!only dispatched to SessionActor as cleanup if the target deployable was never fully introduced
case Zone.Deployable.IsDismissed(obj) =>
continent.tasks ! GUIDTask.UnregisterObjectTask(obj)(continent.GUID)
TaskWorkflow.execute(GUIDTask.unregisterObject(continent.GUID, obj))
case ICS.ZonesResponse(zones) =>
zones.foreach { zone =>
@ -1156,9 +1156,9 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
player.avatar = avatar
interstellarFerry match {
case Some(vehicle) if vehicle.PassengerInSeat(player).contains(0) =>
continent.tasks ! RegisterDrivenVehicle(vehicle, player)
TaskWorkflow.execute(registerDrivenVehicle(vehicle, player))
case _ =>
continent.tasks ! RegisterNewAvatar(player)
TaskWorkflow.execute(registerNewAvatar(player))
}
case NewPlayerLoaded(tplayer) =>
@ -1997,13 +1997,13 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
case (_, guid) => sendResponse(ObjectDeleteMessage(guid, 0))
}
//functionally delete
delete.foreach { case (obj, _) => continent.tasks ! GUIDTask.UnregisterEquipment(obj)(continent.GUID) }
delete.foreach { case (obj, _) => TaskWorkflow.execute(GUIDTask.unregisterEquipment(continent.GUID, obj)) }
//redraw
if (maxhand) {
continent.tasks ! HoldNewEquipmentUp(player)(
TaskWorkflow.execute(HoldNewEquipmentUp(player)(
Tool(GlobalDefinitions.MAXArms(subtype, player.Faction)),
0
)
))
}
//draw free hand
player.FreeHand.Equipment match {
@ -2075,14 +2075,14 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
(old_holsters ++ old_inventory).foreach {
case (obj, guid) =>
sendResponse(ObjectDeleteMessage(guid, 0))
continent.tasks ! GUIDTask.UnregisterEquipment(obj)(continent.GUID)
TaskWorkflow.execute(GUIDTask.unregisterEquipment(continent.GUID, obj))
}
//redraw
if (maxhand) {
continent.tasks ! HoldNewEquipmentUp(player)(
TaskWorkflow.execute(HoldNewEquipmentUp(player)(
Tool(GlobalDefinitions.MAXArms(subtype, player.Faction)),
0
)
))
}
ApplyPurchaseTimersBeforePackingLoadout(player, player, holsters ++ inventory)
DropLeftovers(player)(drops)
@ -2166,7 +2166,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
if (Avatar.purchaseCooldowns.contains(item.obj.Definition)) {
avatarActor ! AvatarActor.UpdatePurchaseTime(item.obj.Definition)
}
continent.tasks ! PutLoadoutEquipmentInInventory(target)(item.obj, item.start)
TaskWorkflow.execute(PutLoadoutEquipmentInInventory(target)(item.obj, item.start))
}
}
}
@ -2574,11 +2574,11 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
sendResponse(ItemTransactionResultMessage(msg.terminal_guid, TransactionType.Buy, false))
case None =>
avatarActor ! AvatarActor.UpdatePurchaseTime(item.Definition)
continent.tasks ! BuyNewEquipmentPutInInventory(
TaskWorkflow.execute(BuyNewEquipmentPutInInventory(
continent.GUID(tplayer.VehicleSeated) match { case Some(v : Vehicle) => v; case _ => player },
tplayer,
msg.terminal_guid
)(item)
)(item))
}
case Terminal.SellEquipment() =>
@ -2637,7 +2637,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
entry.obj.Faction = tplayer.Faction
vTrunk.InsertQuickly(entry.start, entry.obj)
})
continent.tasks ! RegisterVehicleFromSpawnPad(vehicle, pad, term)
TaskWorkflow.execute(registerVehicleFromSpawnPad(vehicle, pad, term))
sendResponse(ItemTransactionResultMessage(msg.terminal_guid, TransactionType.Buy, true))
case _ =>
log.error(
@ -2921,7 +2921,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
(old_weapons ++ old_inventory).foreach {
case (obj, eguid) =>
sendResponse(ObjectDeleteMessage(eguid, 0))
continent.tasks ! GUIDTask.UnregisterEquipment(obj)(continent.GUID)
TaskWorkflow.execute(GUIDTask.unregisterEquipment(continent.GUID, obj))
}
ApplyPurchaseTimersBeforePackingLoadout(player, vehicle, added_weapons ++ new_inventory)
} else if (accessedContainer.contains(target)) {
@ -4406,7 +4406,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
continent.id,
AvatarAction.ProjectileExplodes(player.GUID, obj.GUID, obj)
)
continent.tasks ! UnregisterProjectile(obj)
TaskWorkflow.execute(unregisterProjectile(obj))
}
}
@ -4965,13 +4965,13 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
dObj.Orientation = orient
dObj.Faction = player.Faction
dObj.AssignOwnership(player)
val tasking: TaskResolver.GiveTask = dObj match {
val tasking: TaskBundle = dObj match {
case turret: TurretDeployable =>
GUIDTask.RegisterDeployableTurret(turret)(continent.GUID)
GUIDTask.registerDeployableTurret(continent.GUID, turret)
case _ =>
GUIDTask.RegisterObjectTask(dObj)(continent.GUID)
GUIDTask.registerObject(continent.GUID, dObj)
}
continent.tasks ! CallBackForTask(tasking, continent.Deployables, Zone.Deployable.BuildByOwner(dObj, player, obj))
TaskWorkflow.execute(CallBackForTask(tasking, continent.Deployables, Zone.Deployable.BuildByOwner(dObj, player, obj)))
case Some(obj) =>
log.warn(s"DeployObject: what is $obj, ${player.Name}? It's not a construction tool!")
@ -5724,35 +5724,22 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
* as if that player is only just being introduced.
* `Players` are complex objects that contain a variety of other register-able objects and each of these objects much be handled.
* @param tplayer the avatar `Player`
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
private def RegisterNewAvatar(tplayer: Player): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private def registerNewAvatar(tplayer: Player): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
private val localPlayer = tplayer
private val localAnnounce = self
override def Description: String = s"register new player avatar ${localPlayer.Name}"
override def description(): String = s"register new player avatar ${localPlayer.Name}"
override def isComplete: Task.Resolution.Value = {
if (localPlayer.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
log.trace(s"Player ${localPlayer.Name} is newly registered")
resolver ! Success(this)
localAnnounce ! NewPlayerLoaded(localPlayer) //alerts WorldSessionActor
}
override def onFailure(ex: Throwable): Unit = {
localAnnounce ! PlayerFailedToLoad(localPlayer) //alerts SessionActor
def action(): Future[Any] = {
localAnnounce ! NewPlayerLoaded(localPlayer)
Future(true)
}
},
List(GUIDTask.RegisterAvatar(tplayer)(continent.GUID))
List(GUIDTask.registerAvatar(continent.GUID, tplayer))
)
}
@ -5761,35 +5748,22 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
* as if that player was already introduced and is just being renewed.
* `Players` are complex objects that contain a variety of other register-able objects and each of these objects much be handled.
* @param tplayer the avatar `Player`
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
private def RegisterAvatar(tplayer: Player): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private def registerAvatar(tplayer: Player): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
private val localPlayer = tplayer
private val localAnnounce = self
override def Description: String = s"register player avatar ${localPlayer.Name}"
override def description(): String = s"register player avatar ${localPlayer.Name}"
override def isComplete: Task.Resolution.Value = {
if (localPlayer.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
log.trace(s"Player $localPlayer is registered")
resolver ! Success(this)
localAnnounce ! PlayerLoaded(localPlayer) //alerts WorldSessionActor
}
override def onFailure(ex: Throwable): Unit = {
localAnnounce ! PlayerFailedToLoad(localPlayer) //alerts WorldSessionActor
def action(): Future[Any] = {
localAnnounce ! PlayerLoaded(localPlayer)
Future(true)
}
},
List(GUIDTask.RegisterPlayer(tplayer)(continent.GUID))
List(GUIDTask.registerPlayer(continent.GUID, tplayer))
)
}
@ -5798,29 +5772,21 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
* Use this function to renew the globally unique identifiers on a vehicle that has already been added to the scene once.
* @param vehicle the `Vehicle` object
* @see `RegisterVehicleFromSpawnPad`
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def RegisterVehicle(vehicle: Vehicle): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private def registerVehicle(vehicle: Vehicle): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
private val localVehicle = vehicle
private val localAnnounce = self
override def Description: String = s"register a ${localVehicle.Definition.Name}"
override def description(): String = s"register a ${localVehicle.Definition.Name}"
override def isComplete: Task.Resolution.Value = {
if (localVehicle.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
log.trace(s"Vehicle $localVehicle is registered")
resolver ! Success(this)
def action(): Future[Any] = {
Future(true)
}
},
List(GUIDTask.RegisterVehicle(vehicle)(continent.GUID))
List(GUIDTask.registerVehicle(continent.GUID, vehicle))
)
}
@ -5839,43 +5805,34 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
* and the user who is the driver (second param) is properly seated
* but the said driver does not know about the vehicle through his usual convention - `VehicleSeated` - yet.
* @see `GlobalDefinitions.droppod`
* @see `GUIDTask.RegisterObjectTask`
* @see `GUIDTask.registerObject`
* @see `interstellarFerry`
* @see `Player.VehicleSeated`
* @see `PlayerLoaded`
* @see `TaskResolver.GiveTask`
* @see `TaskBundle`
* @see `Vehicles.Own`
* @param vehicle the unregistered droppod
* @param tplayer the player using the droppod for instant action;
* should already be the driver of the droppod
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def RegisterDroppod(vehicle: Vehicle, tplayer: Player): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private def registerDroppod(vehicle: Vehicle, tplayer: Player): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
private val localDriver = tplayer
private val localVehicle = vehicle
private val localAnnounce = self
override def Description: String = s"register a ${localVehicle.Definition.Name} manned by ${localDriver.Name}"
override def description(): String = s"register a ${localVehicle.Definition.Name} manned by ${localDriver.Name}"
override def isComplete: Task.Resolution.Value = {
if (localVehicle.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
log.trace(s"Vehicle $localVehicle is registered")
def action(): Future[Any] = {
localDriver.VehicleSeated = localVehicle.GUID
Vehicles.Own(localVehicle, localDriver)
localAnnounce ! PlayerLoaded(localDriver)
resolver ! Success(this)
Future(true)
}
},
List(GUIDTask.RegisterObjectTask(vehicle)(continent.GUID))
List(GUIDTask.registerObject(continent.GUID, vehicle))
)
}
@ -5887,65 +5844,44 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
* the vehicle is being brought into existence from scratch and was never a member of any `Zone`.
* @param obj the `Vehicle` object
* @see `RegisterVehicle`
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def RegisterVehicleFromSpawnPad(obj: Vehicle, pad: VehicleSpawnPad, terminal: Terminal): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private val localVehicle = obj
private def registerVehicleFromSpawnPad(vehicle: Vehicle, pad: VehicleSpawnPad, terminal: Terminal): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
private val localVehicle = vehicle
private val localPad = pad.Actor
private val localTerminal = terminal
private val localPlayer = player
override def Description: String = s"register a ${localVehicle.Definition.Name} for spawn pad"
override def description(): String = s"register a ${localVehicle.Definition.Name} for spawn pad"
override def isComplete: Task.Resolution.Value = {
if (localVehicle.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
def action(): Future[Any] = {
localPad ! VehicleSpawnPad.VehicleOrder(localPlayer, localVehicle, localTerminal)
resolver ! Success(this)
Future(true)
}
},
List(RegisterVehicle(obj))
List(registerVehicle(vehicle))
)
}
def RegisterDrivenVehicle(obj: Vehicle, driver: Player): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private val localVehicle = obj
private def registerDrivenVehicle(vehicle: Vehicle, driver: Player): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
private val localVehicle = vehicle
private val localDriver = driver
private val localAnnounce = self
override def Description: String = s"register a ${localVehicle.Definition.Name} driven by ${localDriver.Name}"
override def description(): String = s"register a ${localVehicle.Definition.Name} driven by ${localDriver.Name}"
override def isComplete: Task.Resolution.Value = {
if (localVehicle.HasGUID && localDriver.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
log.trace(s"${localDriver.Name} 's vehicle ${localVehicle.Definition.Name} is registered")
def action(): Future[Any] = {
localDriver.VehicleSeated = localVehicle.GUID
Vehicles.Own(localVehicle, localDriver)
localAnnounce ! NewPlayerLoaded(localDriver) //alerts WorldSessionActor
resolver ! Success(this)
}
override def onFailure(ex: Throwable): Unit = {
localAnnounce ! PlayerFailedToLoad(localDriver) //alerts SessionActor
localAnnounce ! NewPlayerLoaded(localDriver)
Future(true)
}
},
List(GUIDTask.RegisterAvatar(driver)(continent.GUID), GUIDTask.RegisterVehicle(obj)(continent.GUID))
List(GUIDTask.registerAvatar(continent.GUID, driver), GUIDTask.registerVehicle(continent.GUID, vehicle))
)
}
@ -5954,55 +5890,39 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
* After the projectile is registered to the curent zone's global unique identifier system,
* all connected clients save for the one that registered it will be informed about the projectile's "creation."
* @param obj the projectile to be registered
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def RegisterProjectile(obj: Projectile): TaskResolver.GiveTask = {
val definition = obj.Definition
TaskResolver.GiveTask(
new Task() {
private def registerProjectile(obj: Projectile): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
private val globalProjectile = obj
private val localAnnounce = self
override def Description: String = s"register a ${globalProjectile.profile.Name}"
override def description(): String = s"register a ${globalProjectile.profile.Name}"
override def isComplete: Task.Resolution.Value = {
if (globalProjectile.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
def action(): Future[Any] = {
localAnnounce ! LoadedRemoteProjectile(globalProjectile.GUID, Some(globalProjectile))
resolver ! Success(this)
Future(true)
}
},
List(GUIDTask.RegisterObjectTask(obj)(continent.GUID))
List(GUIDTask.registerObject(continent.GUID, obj))
)
}
def UnregisterDrivenVehicle(obj: Vehicle, driver: Player): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private val localVehicle = obj
private val localDriver = driver
private def unregisterDrivenVehicle(vehicle: Vehicle, driver: Player): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
private val localVehicle = vehicle
private val localDriver = driver
private val localAnnounce = self
override def Description: String = s"unregister a ${localVehicle.Definition.Name} driven by ${localDriver.Name}"
override def description(): String = s"unregister a ${localVehicle.Definition.Name} driven by ${localDriver.Name}"
override def isComplete: Task.Resolution.Value = {
if (!localVehicle.HasGUID && !localDriver.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
resolver ! Success(this)
def action(): Future[Any] = {
Future(true)
}
},
List(GUIDTask.UnregisterAvatar(driver)(continent.GUID), GUIDTask.UnregisterVehicle(obj)(continent.GUID))
List(GUIDTask.unregisterAvatar(continent.GUID, driver), GUIDTask.unregisterVehicle(continent.GUID, vehicle))
)
}
@ -6011,52 +5931,42 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
* After the projectile is unregistered from the curent zone's global unique identifier system,
* all connected clients save for the one that registered it will be informed about the projectile's "destruction."
* @param obj the projectile to be unregistered
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def UnregisterProjectile(obj: Projectile): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private def unregisterProjectile(obj: Projectile): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
private val globalProjectile = obj
private val localAnnounce = continent.AvatarEvents
private val localAnnounce = self
private val localMsg = AvatarServiceMessage(continent.id, AvatarAction.ObjectDelete(player.GUID, obj.GUID, 2))
override def Description: String = s"unregister a ${globalProjectile.profile.Name}"
override def description(): String = s"unregister a ${globalProjectile.profile.Name}"
override def isComplete: Task.Resolution.Value = {
if (!globalProjectile.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
def action(): Future[Any] = {
localAnnounce ! localMsg
resolver ! Success(this)
Future(true)
}
},
List(GUIDTask.UnregisterObjectTask(obj)(continent.GUID))
List(GUIDTask.unregisterObject(continent.GUID, obj))
)
}
/**
* If the projectile object is unregistered, register it.
* If the projectile object is already registered, unregister it and then register it again.
* @see `RegisterProjectile(Projectile)`
* @see `UnregisterProjectile(Projectile)`
* @see `registerProjectile(Projectile)`
* @see `unregisterProjectile(Projectile)`
* @param obj the projectile to be registered (a second time?)
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def ReregisterProjectile(obj: Projectile): TaskResolver.GiveTask = {
val reg = RegisterProjectile(obj)
def reregisterProjectile(obj: Projectile): TaskBundle = {
val reg = registerProjectile(obj)
if (obj.HasGUID) {
TaskResolver.GiveTask(
reg.task,
List(
TaskResolver.GiveTask(
reg.subs(0).task,
List(UnregisterProjectile(obj))
)
TaskBundle(
reg.mainTask,
TaskBundle(
reg.subTasks(0).mainTask,
unregisterProjectile(obj)
)
)
} else {
@ -6371,13 +6281,13 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
case veh: Vehicle => ModifyAmmunitionInVehicle(veh)
case _ => ModifyAmmunition(obj)
}
val stowNewFunc: Equipment => TaskResolver.GiveTask = PutNewEquipmentInInventoryOrDrop(obj)
val stowFunc: Equipment => Future[Any] = PutEquipmentInInventoryOrDrop(obj)
val stowNewFunc: Equipment => TaskBundle = PutNewEquipmentInInventoryOrDrop(obj)
val stowFunc: Equipment => Future[Any] = PutEquipmentInInventoryOrDrop(obj)
xs.foreach(item => {
obj.Inventory -= item.start
sendResponse(ObjectDeleteMessage(item.obj.GUID, 0))
continent.tasks ! GUIDTask.UnregisterObjectTask(item.obj)(continent.GUID)
TaskWorkflow.execute(GUIDTask.unregisterObject(continent.GUID, item.obj))
})
//box will be the replacement ammo; give it the discovered magazine and load it into the weapon
@ -6426,7 +6336,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
s"PerformToolAmmoChange: ${player.Name} takes ${originalBoxCapacity - splitReloadAmmo} from a box of $originalBoxCapacity $requestedAmmoType ammo"
)
val boxForInventory = AmmoBox(box.Definition, splitReloadAmmo)
continent.tasks ! stowNewFunc(boxForInventory)
TaskWorkflow.execute(stowNewFunc(boxForInventory))
fullMagazine
}
sendResponse(
@ -6471,10 +6381,10 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
case Nil | List(_) => ; //done (the former case is technically not possible)
case _ :: toUpdate =>
modifyFunc(previousBox, 0) //update to changed capacity value
toUpdate.foreach(box => { continent.tasks ! stowNewFunc(box) })
toUpdate.foreach(box => { TaskWorkflow.execute(stowNewFunc(box)) })
}
} else {
continent.tasks ! GUIDTask.UnregisterObjectTask(previousBox)(continent.GUID)
TaskWorkflow.execute(GUIDTask.unregisterObject(continent.GUID, previousBox))
}
}
}
@ -6496,32 +6406,6 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
zone.Ground.tell(Zone.Ground.DropItem(item, obj.Position, Vector3.z(obj.Orientation.z)), obj.Actor)
}
/**
* Register an `Equipment` item and then drop it on the ground.
* @see `NormalItemDrop`
* @param obj a `Container` object that represents where the item will be dropped;
* curried for callback
* @param zone the continent in which the item is being dropped;
* curried for callback
* @param item the item
*/
def NewItemDrop(obj: PlanetSideServerObject with Container, zone: Zone)(item: Equipment): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private val localItem = item
private val localFunc: Equipment => Unit = NormalItemDrop(obj, zone)
override def Description: String = s"dropping a new ${localItem.Definition.Name} on the ground"
def Execute(resolver: ActorRef): Unit = {
localFunc(localItem)
resolver ! Success(this)
}
},
List(GUIDTask.RegisterEquipment(item)(zone.GUID))
)
}
/**
* After a weapon has finished shooting, determine if it needs to be sorted in a special way.
* @param tool a weapon
@ -7274,7 +7158,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
* @see `AvatarAction.Release`
* @see `AvatarServiceMessage`
* @see `FriskDeadBody`
* @see `GUIDTask.UnregisterPlayer`
* @see `GUIDTask.unregisterPlayer`
* @see `ObjectDeleteMessage`
* @see `WellLootedDeadBody`
* @see `Zone.Corpse.Add`
@ -7291,7 +7175,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
zone.Population ! Zone.Population.Release(avatar)
sendResponse(ObjectDeleteMessage(pguid, 0))
zone.AvatarEvents ! AvatarServiceMessage(zone.id, AvatarAction.ObjectDelete(pguid, pguid, 0))
zone.tasks ! GUIDTask.UnregisterPlayer(tplayer)(zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterPlayer(zone.GUID, tplayer))
}
}
@ -7788,7 +7672,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
projectile.quality(quality)
} else if (projectile.tool_def.Size == EquipmentSize.Melee) {
//melee
val quality = player.avatar.implants.flatten.find { entry => entry.definition == GlobalDefinitions.melee_booster } match {
val quality = player.avatar.implants.flatten.find { entry => entry.definition.implantType == ImplantType.MeleeBooster } match {
case Some(booster) if booster.active && player.avatar.stamina > 9 =>
avatarActor ! AvatarActor.ConsumeStamina(10)
ProjectileQuality.Modified(25f)
@ -8210,7 +8094,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
if (!zoneReload && zoneId == continent.id) {
if (player.isBackpack) { // important! test the actor-wide player ref, not the parameter
// respawning from unregistered player
continent.tasks ! RegisterAvatar(targetPlayer)
TaskWorkflow.execute(registerAvatar(targetPlayer))
} else {
// move existing player; this is the one case where the original GUID is retained by the player
self ! PlayerLoaded(targetPlayer)
@ -8220,15 +8104,15 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
val original = player
if (player.isBackpack) {
session = session.copy(player = targetPlayer)
taskThenZoneChange(
GUIDTask.UnregisterObjectTask(original.avatar.locker)(continent.GUID),
TaskWorkflow.execute(taskThenZoneChange(
GUIDTask.unregisterObject(continent.GUID, original.avatar.locker),
ICS.FindZone(_.id == zoneId, context.self)
)
))
} else if (player.HasGUID) {
taskThenZoneChange(
GUIDTask.UnregisterAvatar(original)(continent.GUID),
TaskWorkflow.execute(taskThenZoneChange(
GUIDTask.unregisterAvatar(continent.GUID, original),
ICS.FindZone(_.id == zoneId, context.self)
)
))
} else {
cluster ! ICS.FindZone(_.id == zoneId, context.self)
}
@ -8317,7 +8201,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
if (!zoneReload && zoneId == continent.id) {
if (vehicle.Definition == GlobalDefinitions.droppod) {
//instant action droppod in the same zone
continent.tasks ! RegisterDroppod(vehicle, player)
TaskWorkflow.execute(registerDroppod(vehicle, player))
} else {
//transferring a vehicle between spawn points (warp gates) in the same zone
self ! PlayerLoaded(player)
@ -8325,10 +8209,10 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
} else if (vehicle.Definition == GlobalDefinitions.droppod) {
LoadZoneCommonTransferActivity()
player.Continent = zoneId //forward-set the continent id to perform a test
taskThenZoneChange(
GUIDTask.UnregisterAvatar(player)(continent.GUID),
TaskWorkflow.execute(taskThenZoneChange(
GUIDTask.unregisterAvatar(continent.GUID, player),
ICS.FindZone(_.id == zoneId, context.self)
)
))
} else {
UnaccessContainer(vehicle)
LoadZoneCommonTransferActivity()
@ -8347,10 +8231,10 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
}
//unregister vehicle and driver whole + GiveWorld
continent.Transport ! Zone.Vehicle.Despawn(vehicle)
taskThenZoneChange(
UnregisterDrivenVehicle(vehicle, player),
TaskWorkflow.execute(taskThenZoneChange(
unregisterDrivenVehicle(vehicle, player),
ICS.FindZone(_.id == zoneId, context.self)
)
))
}
}
@ -8369,7 +8253,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
* A reference to the top-level ferrying vehicle's former globally unique identifier has been retained for this purpose.
* This vehicle can be deleted for everyone if no more work can be detected.
*
* @see `GUIDTask.UnregisterPlayer`
* @see `GUIDTask.unregisterPlayer`
* @see `LoadZoneCommonTransferActivity`
* @see `Vehicles.AllGatedOccupantsInSameZone`
* @see `PlayerLoaded`
@ -8393,10 +8277,10 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
val continentId = continent.id
interstellarFerryTopLevelGUID = None
taskThenZoneChange(
GUIDTask.UnregisterAvatar(player)(continent.GUID),
TaskWorkflow.execute(taskThenZoneChange(
GUIDTask.unregisterAvatar(continent.GUID, player),
ICS.FindZone(_.id == zoneId, context.self)
)
))
}
}
@ -8439,20 +8323,24 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
/** Before changing zones, perform the following task (which can be a nesting of subtasks). */
def taskThenZoneChange(
task: TaskResolver.GiveTask,
zoneMessage: ICS.FindZone
): Unit = {
continent.tasks ! TaskResolver.GiveTask(
new Task() {
override def isComplete: Task.Resolution.Value = task.task.isComplete
task: TaskBundle,
zoneMessage: ICS.FindZone
): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
val localAvatar = avatar
val localZone = continent
val localCluster = cluster
def Execute(resolver: ActorRef): Unit = {
continent.Population ! Zone.Population.Leave(avatar)
override def description() : String = s"doing ${task.description()} before transferring zones"
def action(): Future[Any] = {
continent.Population ! Zone.Population.Leave(localAvatar)
cluster ! zoneMessage
resolver ! Success(this)
Future(true)
}
},
List(task)
task
)
}
@ -8474,7 +8362,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
avatarActor ! AvatarActor.SetVehicle(None)
}
RemoveBoomerTriggersFromInventory().foreach(obj => {
continent.tasks ! GUIDTask.UnregisterObjectTask(obj)(continent.GUID)
TaskWorkflow.execute(GUIDTask.unregisterObject(continent.GUID, obj))
})
Deployables.Disown(continent, avatar, self)
drawDeloyableIcon = RedrawDeployableIcons //important for when SetCurrentAvatar initializes the UI next zone
@ -8896,7 +8784,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
continent.id,
AvatarAction.ProjectileExplodes(player.GUID, projectile_guid, projectile)
)
continent.tasks ! UnregisterProjectile(projectile)
TaskWorkflow.execute(unregisterProjectile(projectile))
projectiles(local_index) match {
case Some(obj) if !obj.isResolved => obj.Miss()
case _ => ;
@ -8933,7 +8821,7 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
tplayer.VehicleSeated = None
zone.Population ! Zone.Population.Release(avatar)
sendResponse(ObjectDeleteMessage(tplayer.GUID, 0))
zone.tasks ! GUIDTask.UnregisterPlayer(tplayer)(zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterPlayer(zone.GUID, tplayer))
}
}
@ -9144,15 +9032,15 @@ class SessionActor(middlewareActor: typed.ActorRef[MiddlewareActor.Command], con
log.trace(
s"WeaponFireMessage: ${player.Name}'s ${projectile_info.Name} is a remote projectile"
)
continent.tasks ! (if (projectile.HasGUID) {
if (projectile.HasGUID) {
continent.AvatarEvents ! AvatarServiceMessage(
continent.id,
AvatarAction.ProjectileExplodes(player.GUID, projectile.GUID, projectile)
)
ReregisterProjectile(projectile)
TaskWorkflow.execute(reregisterProjectile(projectile))
} else {
RegisterProjectile(projectile)
})
TaskWorkflow.execute(registerProjectile(projectile))
}
}
projectilesToCleanUp(projectileIndex) = false

219
src/main/scala/net/psforever/login/WorldSession.scala
View file

@ -4,7 +4,7 @@ import akka.actor.ActorRef
import akka.pattern.{AskTimeoutException, ask}
import akka.util.Timeout
import net.psforever.objects.equipment.{Ammo, Equipment}
import net.psforever.objects.guid.{GUIDTask, Task, TaskResolver}
import net.psforever.objects.guid._
import net.psforever.objects.inventory.{Container, InventoryItem}
import net.psforever.objects.locker.LockerContainer
import net.psforever.objects.serverobject.PlanetSideServerObject
@ -73,32 +73,29 @@ object WorldSession {
* Equipment will go wherever it fits in containing object, or be dropped if it fits nowhere.
* Item swapping during the placement is not allowed.
* @see `ChangeAmmoMessage`
* @see `GUIDTask.RegisterEquipment`
* @see `GUIDTask.registerEquipment`
* @see `PutEquipmentInInventoryOrDrop`
* @see `Task`
* @see `TaskResolver.GiveTask`
* @see `TaskBundle`
* @param obj the container
* @param item the item being manipulated
* @return a `TaskResolver` object
* @return a `TaskBundle` object
*/
def PutNewEquipmentInInventorySlot(
obj: PlanetSideServerObject with Container
)(item: Equipment, slot: Int): TaskResolver.GiveTask = {
)(item: Equipment, slot: Int): TaskBundle = {
val localZone = obj.Zone
TaskResolver.GiveTask(
new Task() {
TaskBundle(
new StraightforwardTask() {
private val localContainer = obj
private val localItem = item
private val localSlot = slot
override def isComplete: Task.Resolution.Value = Task.Resolution.Success
def Execute(resolver: ActorRef): Unit = {
def action(): Future[Any] = {
PutEquipmentInInventorySlot(localContainer)(localItem, localSlot)
resolver ! Success(this)
}
},
List(GUIDTask.RegisterEquipment(item)(localZone.GUID))
GUIDTask.registerEquipment(localZone.GUID, item)
)
}
@ -108,31 +105,28 @@ object WorldSession {
* Equipment will go wherever it fits in containing object, or be dropped if it fits nowhere.
* Item swapping during the placement is not allowed.
* @see `ChangeAmmoMessage`
* @see `GUIDTask.RegisterEquipment`
* @see `GUIDTask.registerEquipment`
* @see `PutEquipmentInInventoryOrDrop`
* @see `Task`
* @see `TaskResolver.GiveTask`
* @see `TaskBundle`
* @param obj the container
* @param item the item being manipulated
* @return a `TaskResolver` object
* @return a `TaskBundle` object
*/
def PutNewEquipmentInInventoryOrDrop(
obj: PlanetSideServerObject with Container
)(item: Equipment): TaskResolver.GiveTask = {
)(item: Equipment): TaskBundle = {
val localZone = obj.Zone
TaskResolver.GiveTask(
new Task() {
TaskBundle(
new StraightforwardTask() {
private val localContainer = obj
private val localItem = item
override def isComplete: Task.Resolution.Value = Task.Resolution.Success
def Execute(resolver: ActorRef): Unit = {
def action(): Future[Any] = {
PutEquipmentInInventoryOrDrop(localContainer)(localItem)
resolver ! Success(this)
}
},
List(GUIDTask.RegisterEquipment(item)(localZone.GUID))
GUIDTask.registerEquipment(localZone.GUID, item)
)
}
@ -149,7 +143,7 @@ object WorldSession {
* @see `Containable.PutItemAway`
* @see `Future.onComplete`
* @see `Future.recover`
* @see `GUIDTask.UnregisterEquipment`
* @see `GUIDTask.unregisterEquipment`
* @see `tell`
* @see `Zone.AvatarEvents`
* @param obj the container
@ -165,7 +159,7 @@ object WorldSession {
val result = ask(localContainer.Actor, Containable.PutItemInSlotOnly(localItem, slot))
result.onComplete {
case Failure(_) | Success(_: Containable.CanNotPutItemInSlot) =>
localContainer.Zone.tasks ! GUIDTask.UnregisterEquipment(localItem)(localContainer.Zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterEquipment(localContainer.Zone.GUID, localItem))
case _ => ;
}
result
@ -177,43 +171,33 @@ object WorldSession {
* This request will (probably) be coincidental with a number of other such requests based on that loadout
* so items must be rigidly placed else cascade into a chaostic order.
* Item swapping during the placement is not allowed.
* @see `GUIDTask.RegisterEquipment`
* @see `GUIDTask.registerEquipment`
* @see `PutEquipmentInInventorySlot`
* @see `Task`
* @see `TaskResolver.GiveTask`
* @see `TaskBundle`
* @param obj the container
* @param item the item being manipulated
* @param slot where the item will be placed in the container
* @return a `TaskResolver` object
* @return a `TaskBundle` object
*/
def PutLoadoutEquipmentInInventory(
obj: PlanetSideServerObject with Container
)(item: Equipment, slot: Int): TaskResolver.GiveTask = {
)(item: Equipment, slot: Int): TaskBundle = {
val localZone = obj.Zone
TaskResolver.GiveTask(
new Task() {
TaskBundle(
new StraightforwardTask() {
private val localContainer = obj
private val localItem = item
private val localSlot = slot
private val localFunc: (Equipment, Int) => Future[Any] = PutEquipmentInInventorySlot(obj)
override def Timeout: Long = 1000
override def description(): String = s"PutEquipmentInInventorySlot - ${localItem.Definition.Name}"
override def isComplete: Task.Resolution.Value = {
if (localItem.HasGUID && localContainer.Find(localItem).nonEmpty)
Task.Resolution.Success
else
Task.Resolution.Incomplete
}
override def Description: String = s"PutEquipmentInInventorySlot - ${localItem.Definition.Name}"
def Execute(resolver: ActorRef): Unit = {
def action(): Future[Any] = {
localFunc(localItem, localSlot)
resolver ! Success(this)
}
},
List(GUIDTask.RegisterEquipment(item)(localZone.GUID))
GUIDTask.registerEquipment(localZone.GUID, item)
)
}
@ -227,8 +211,8 @@ object WorldSession {
* @see `ask`
* @see `Containable.CanNotPutItemInSlot`
* @see `Containable.PutItemInSlotOnly`
* @see `GUIDTask.RegisterEquipment`
* @see `GUIDTask.UnregisterEquipment`
* @see `GUIDTask.registerEquipment`
* @see `GUIDTask.unregisterEquipment`
* @see `Future.onComplete`
* @see `PutEquipmentInInventorySlot`
* @see `TerminalMessageOnTimeout`
@ -236,31 +220,22 @@ object WorldSession {
* @param player na
* @param term na
* @param item the item being manipulated
* @return a `TaskResolver` object
* @return a `TaskBundle` object
*/
def BuyNewEquipmentPutInInventory(
obj: PlanetSideServerObject with Container,
player: Player,
term: PlanetSideGUID
)(item: Equipment): TaskResolver.GiveTask = {
)(item: Equipment): TaskBundle = {
val localZone = obj.Zone
TaskResolver.GiveTask(
new Task() {
TaskBundle(
new StraightforwardTask() {
private val localContainer = obj
private val localItem = item
private val localPlayer = player
private val localTermMsg: Boolean => Unit = TerminalResult(term, localPlayer, TransactionType.Buy)
override def Timeout: Long = 1000
override def isComplete: Task.Resolution.Value = {
if (localItem.HasGUID && localContainer.Find(localItem).nonEmpty)
Task.Resolution.Success
else
Task.Resolution.Incomplete
}
def Execute(resolver: ActorRef): Unit = {
def action(): Future[Any] = {
TerminalMessageOnTimeout(
ask(localContainer.Actor, Containable.PutItemAway(localItem)),
localTermMsg
@ -279,16 +254,16 @@ object WorldSession {
localTermMsg(true)
}
} else {
localContainer.Zone.tasks ! GUIDTask.UnregisterEquipment(localItem)(localContainer.Zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterEquipment(localContainer.Zone.GUID, localItem))
localTermMsg(false)
}
case _ =>
localTermMsg(true)
}
resolver ! Success(this)
Future(true)
}
},
List(GUIDTask.RegisterEquipment(item)(localZone.GUID))
GUIDTask.registerEquipment(localZone.GUID, item)
)
}
@ -306,44 +281,35 @@ object WorldSession {
* @see `AvatarAction.SendResponse`
* @see `Containable.CanNotPutItemInSlot`
* @see `Containable.PutItemInSlotOnly`
* @see `GUIDTask.RegisterEquipment`
* @see `GUIDTask.UnregisterEquipment`
* @see `GUIDTask.registerEquipment`
* @see `GUIDTask.unregisterEquipment`
* @see `Future.onComplete`
* @see `ObjectHeldMessage`
* @see `Player.DrawnSlot`
* @see `Player.LastDrawnSlot`
* @see `Service.defaultPlayerGUID`
* @see `TaskResolver.GiveTask`
* @see `TaskBundle`
* @see `Zone.AvatarEvents`
* @param player the player whose visible slot will be equipped and drawn
* @param item the item to equip
* @param slot the slot in which the item will be equipped
* @return a `TaskResolver` object
* @return a `TaskBundle` object
*/
def HoldNewEquipmentUp(player: Player)(item: Equipment, slot: Int): TaskResolver.GiveTask = {
def HoldNewEquipmentUp(player: Player)(item: Equipment, slot: Int): TaskBundle = {
if (player.VisibleSlots.contains(slot)) {
val localZone = player.Zone
TaskResolver.GiveTask(
new Task() {
TaskBundle(
new StraightforwardTask() {
private val localPlayer = player
private val localGUID = player.GUID
private val localItem = item
private val localSlot = slot
override def Timeout: Long = 1000
override def isComplete: Task.Resolution.Value = {
if (localPlayer.DrawnSlot == localSlot)
Task.Resolution.Success
else
Task.Resolution.Incomplete
}
def Execute(resolver: ActorRef): Unit = {
def action(): Future[Any] = {
ask(localPlayer.Actor, Containable.PutItemInSlotOnly(localItem, localSlot))
.onComplete {
case Failure(_) | Success(_: Containable.CanNotPutItemInSlot) =>
localPlayer.Zone.tasks ! GUIDTask.UnregisterEquipment(localItem)(localZone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterEquipment(localZone.GUID, localItem))
case _ =>
if (localPlayer.DrawnSlot != Player.HandsDownSlot) {
localPlayer.DrawnSlot = Player.HandsDownSlot
@ -365,10 +331,10 @@ object WorldSession {
AvatarAction.SendResponse(Service.defaultPlayerGUID, ObjectHeldMessage(localGUID, localSlot, false))
)
}
resolver ! Success(this)
Future(this)
}
},
List(GUIDTask.RegisterEquipment(item)(localZone.GUID))
GUIDTask.registerEquipment(localZone.GUID, item)
)
} else {
//TODO log.error
@ -460,7 +426,7 @@ object WorldSession {
* @see `Containable.RemoveItemFromSlot`
* @see `Future.onComplete`
* @see `Future.recover`
* @see `GUIDTask.UnregisterEquipment`
* @see `GUIDTask.unregisterEquipment`
* @see `Zone.AvatarEvents`
* @param obj the container to search
* @param item the item to find and remove from the container
@ -474,7 +440,7 @@ object WorldSession {
val result = ask(localContainer.Actor, Containable.RemoveItemFromSlot(localItem))
result.onComplete {
case Success(Containable.ItemFromSlot(_, Some(_), Some(_))) =>
localContainer.Zone.tasks ! GUIDTask.UnregisterEquipment(localItem)(localContainer.Zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterEquipment(localContainer.Zone.GUID, localItem))
case _ =>
}
result
@ -492,7 +458,7 @@ object WorldSession {
* @see `Containable.RemoveItemFromSlot`
* @see `Future.onComplete`
* @see `Future.recover`
* @see `GUIDTask.UnregisterEquipment`
* @see `GUIDTask.unregisterEquipment`
* @see `RemoveOldEquipmentFromInventory`
* @see `TerminalMessageOnTimeout`
* @see `TerminalResult`
@ -517,7 +483,7 @@ object WorldSession {
)
result.onComplete {
case Success(Containable.ItemFromSlot(_, Some(item), Some(_))) =>
localContainer.Zone.tasks ! GUIDTask.UnregisterEquipment(item)(localContainer.Zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterEquipment(localContainer.Zone.GUID, item))
localTermMsg(true)
case _ =>
localTermMsg(false)
@ -538,7 +504,7 @@ object WorldSession {
* @see `LockerContainer`
* @see `RemoveEquipmentFromLockerContainer`
* @see `StowEquipmentInLockerContainer`
* @see `TaskResolver`
* @see `TaskBundle`
* @param toChannel broadcast channel name for a manual packet callback
* @param source the container in which the item is to be removed
* @param destination the container into which the item is to be placed
@ -573,14 +539,14 @@ object WorldSession {
* @see `Container`
* @see `Equipment`
* @see `GridInventory.CheckCollisionsVar`
* @see `GUIDTask.RegisterEquipment`
* @see `GUIDTask.UnregisterEquipment`
* @see `GUIDTask.registerEquipment`
* @see `GUIDTask.unregisterEquipment`
* @see `IdentifiableEntity.Invalidate`
* @see `LockerContainer`
* @see `Service`
* @see `Task`
* @see `TaskResolver`
* @see `TaskResolver.GiveTask`
* @see `TaskBundle`
* @see `TaskBundle`
* @see `Zone.AvatarEvents`
* @param toChannel broadcast channel name for a manual packet callback
* @param source the container in which the item is to be removed
@ -610,7 +576,7 @@ object WorldSession {
(false, None)
}
if (performSwap) {
def moveItemTaskFunc(toSlot: Int): Task = new Task() {
def moveItemTaskFunc(toSlot: Int): Task = new StraightforwardTask() {
val localGUID = swapItemGUID //the swap item's original GUID, if any swap item
val localChannel = toChannel
val localSource = source
@ -621,21 +587,13 @@ object WorldSession {
val localMoveOnComplete: Try[Any] => Unit = {
case Success(Containable.ItemPutInSlot(_, _, _, Some(swapItem))) =>
//swapItem is not registered right now, we can not drop the item without re-registering it
localSource.Zone.tasks ! PutNewEquipmentInInventorySlot(localSource)(swapItem, localSrcSlot)
TaskWorkflow.execute(PutNewEquipmentInInventorySlot(localSource)(swapItem, localSrcSlot))
case _ => ;
}
override def Description: String = s"unregistering $localItem before stowing in $localDestination"
override def description(): String = s"unregistering $localItem before stowing in $localDestination"
override def isComplete: Task.Resolution.Value = {
if (localItem.HasGUID && localDestination.Find(localItem).contains(localDestSlot)) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
def action(): Future[Any] = {
localGUID match {
case Some(guid) =>
//see LockerContainerControl.RemoveItemFromSlotCallback
@ -647,15 +605,15 @@ object WorldSession {
}
val moveResult = ask(localDestination.Actor, Containable.PutItemInSlotOrAway(localItem, Some(localDestSlot)))
moveResult.onComplete(localMoveOnComplete)
resolver ! Success(this)
moveResult
}
}
val resultOnComplete: Try[Any] => Unit = {
case Success(Containable.ItemFromSlot(fromSource, Some(itemToMove), Some(fromSlot))) =>
destination.Zone.tasks ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
moveItemTaskFunc(fromSlot),
List(GUIDTask.UnregisterEquipment(itemToMove)(fromSource.Zone.GUID))
)
GUIDTask.unregisterEquipment(fromSource.Zone.GUID, itemToMove)
))
case _ => ;
}
val result = ask(source.Actor, Containable.RemoveItemFromSlot(item))
@ -673,14 +631,14 @@ object WorldSession {
* @see `Container`
* @see `Equipment`
* @see `GridInventory.CheckCollisionsVar`
* @see `GUIDTask.RegisterEquipment`
* @see `GUIDTask.UnregisterEquipment`
* @see `GUIDTask.registerEquipment`
* @see `GUIDTask.unregisterEquipment`
* @see `IdentifiableEntity.Invalidate`
* @see `LockerContainer`
* @see `Service`
* @see `Task`
* @see `TaskResolver`
* @see `TaskResolver.GiveTask`
* @see `TaskBundle`
* @see `TaskBundle`
* @see `Zone.AvatarEvents`
* @param toChannel broadcast channel name for a manual packet callback
* @param source the container in which the item is to be removed
@ -695,8 +653,8 @@ object WorldSession {
item: Equipment,
dest: Int
): Unit = {
destination.Zone.tasks ! TaskResolver.GiveTask(
new Task() {
TaskWorkflow.execute(TaskBundle(
new StraightforwardTask() {
val localGUID = item.GUID //original GUID
val localChannel = toChannel
val localSource = source
@ -717,25 +675,16 @@ object WorldSession {
case _ => ;
}
override def Description: String = s"registering $localItem in ${localDestination.Zone.id} before removing from $localSource"
override def description(): String = s"registering $localItem in ${localDestination.Zone.id} before removing from $localSource"
override def isComplete: Task.Resolution.Value = {
if (localItem.HasGUID && localDestination.Find(localItem).isEmpty) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
}
def Execute(resolver: ActorRef): Unit = {
def action(): Future[Any] = {
val zone = localSource.Zone
//see LockerContainerControl.RemoveItemFromSlotCallback
zone.AvatarEvents ! AvatarServiceMessage(localChannel, AvatarAction.ObjectDelete(Service.defaultPlayerGUID, localGUID))
localSource.Actor ! Containable.MoveItem(localDestination, localItem, localSlot)
resolver ! Success(this)
ask(localSource.Actor, Containable.MoveItem(localDestination, localItem, localSlot))
}
},
List(GUIDTask.RegisterEquipment(item)(destination.Zone.GUID))
GUIDTask.registerEquipment(destination.Zone.GUID, item))
)
}
@ -884,21 +833,21 @@ object WorldSession {
}
}
def CallBackForTask(task: TaskResolver.GiveTask, sendTo: ActorRef, pass: Any): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private val localDesc = task.task.Description
def CallBackForTask(task: TaskBundle, sendTo: ActorRef, pass: Any): TaskBundle = {
TaskBundle(
new StraightforwardTask() {
private val localDesc = task.description()
private val destination = sendTo
private val passMsg = pass
override def Description: String = s"callback for tasking $localDesc"
override def description(): String = s"callback for tasking $localDesc"
def Execute(resolver: ActorRef): Unit = {
def action() : Future[Any] = {
destination ! passMsg
resolver ! Success(this)
Future(this)
}
},
List(task)
task
)
}
}

4
src/main/scala/net/psforever/objects/BoomerDeployable.scala
View file

@ -4,7 +4,7 @@ package net.psforever.objects
import akka.actor.{ActorContext, Props}
import net.psforever.objects.ballistics.{PlayerSource, SourceEntry}
import net.psforever.objects.ce.{Deployable, DeployedItem}
import net.psforever.objects.guid.GUIDTask
import net.psforever.objects.guid.{GUIDTask, TaskWorkflow}
import net.psforever.objects.serverobject.{CommonMessages, PlanetSideServerObject}
import net.psforever.objects.vital.etc.TriggerUsedReason
import net.psforever.objects.vital.interaction.DamageInteraction
@ -99,7 +99,7 @@ class BoomerDeployableControl(mine: BoomerDeployable)
zone.id,
AvatarAction.ObjectDelete(Service.defaultPlayerGUID, trigger.GUID)
)
zone.tasks ! GUIDTask.UnregisterObjectTask(trigger)(zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterObject(zone.GUID, trigger))
case None => ;
}
}

7
src/main/scala/net/psforever/objects/GlobalDefinitions.scala
View file

@ -9,6 +9,7 @@ import net.psforever.objects.definition.converter._
import net.psforever.objects.equipment._
import net.psforever.objects.geometry.GeometryForm
import net.psforever.objects.inventory.InventoryTile
import net.psforever.objects.locker.LockerContainerDefinition
import net.psforever.objects.serverobject.aura.Aura
import net.psforever.objects.serverobject.doors.DoorDefinition
import net.psforever.objects.serverobject.generator.GeneratorDefinition
@ -426,11 +427,7 @@ object GlobalDefinitions {
Equipment (locker_container, kits, ammunition, weapons)
*/
import net.psforever.packet.game.objectcreate.ObjectClass
val locker_container = new EquipmentDefinition(456) {
Name = "locker_container"
Size = EquipmentSize.Inventory
Packet = new LockerContainerConverter()
}
val locker_container = new LockerContainerDefinition()
val medkit = KitDefinition(Kits.medkit)

4
src/main/scala/net/psforever/objects/Players.scala
View file

@ -7,7 +7,7 @@ import net.psforever.objects.avatar.PlayerControl
import net.psforever.objects.ce.Deployable
import net.psforever.objects.definition.ExoSuitDefinition
import net.psforever.objects.equipment.EquipmentSlot
import net.psforever.objects.guid.GUIDTask
import net.psforever.objects.guid.{GUIDTask, TaskWorkflow}
import net.psforever.objects.inventory.InventoryItem
import net.psforever.objects.loadouts.InfantryLoadout
import net.psforever.objects.zones.Zone
@ -341,7 +341,7 @@ object Players {
def commonDestroyConstructionItem(player: Player, tool: ConstructionItem, index: Int): Unit = {
val zone = player.Zone
if (safelyRemoveConstructionItemFromSlot(player, tool, index, "CommonDestroyConstructionItem")) {
zone.tasks ! GUIDTask.UnregisterEquipment(tool)(zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterEquipment(zone.GUID, tool))
}
}

4
src/main/scala/net/psforever/objects/TurretDeployable.scala
View file

@ -6,7 +6,7 @@ import net.psforever.objects.ce.{Deployable, DeployableBehavior, DeployedItem}
import net.psforever.objects.definition.DeployableDefinition
import net.psforever.objects.definition.converter.SmallTurretConverter
import net.psforever.objects.equipment.{JammableMountedWeapons, JammableUnit}
import net.psforever.objects.guid.GUIDTask
import net.psforever.objects.guid.{GUIDTask, TaskWorkflow}
import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.objects.serverobject.affinity.FactionAffinityBehavior
import net.psforever.objects.serverobject.damage.Damageable.Target
@ -132,6 +132,6 @@ class TurretControl(turret: TurretDeployable)
override def unregisterDeployable(obj: Deployable): Unit = {
val zone = obj.Zone
zone.tasks ! GUIDTask.UnregisterDeployableTurret(turret)(zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterDeployableTurret(zone.GUID, turret))
}
}

12
src/main/scala/net/psforever/objects/avatar/PlayerControl.scala
View file

@ -9,7 +9,7 @@ import net.psforever.objects.ballistics.PlayerSource
import net.psforever.objects.ce.Deployable
import net.psforever.objects.definition.DeployAnimation
import net.psforever.objects.equipment._
import net.psforever.objects.guid.GUIDTask
import net.psforever.objects.guid.{GUIDTask, TaskWorkflow}
import net.psforever.objects.inventory.{GridInventory, InventoryItem}
import net.psforever.objects.loadouts.Loadout
import net.psforever.objects.serverobject.aura.{Aura, AuraEffectBehavior}
@ -284,7 +284,7 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
val zone = player.Zone
avatarActor ! AvatarActor.UpdateUseTime(kdef)
player.Slot(slot).Equipment = None //remove from slot immediately; must exist on client for now
zone.tasks ! GUIDTask.UnregisterEquipment(kit)(zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterEquipment(zone.GUID, kit))
zone.AvatarEvents ! AvatarServiceMessage(
zone.id,
AvatarAction.PlanetsideAttributeToAll(player.GUID, attribute, value)
@ -482,17 +482,17 @@ class PlayerControl(player: Player, avatarActor: typed.ActorRef[AvatarActor.Comm
obj.Trigger = trigger
//TODO sufficiently delete the tool
zone.AvatarEvents ! AvatarServiceMessage(zone.id, AvatarAction.ObjectDelete(player.GUID, tool.GUID))
zone.tasks ! GUIDTask.UnregisterEquipment(tool)(zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterEquipment(zone.GUID, tool))
player.Find(tool) match {
case Some(index) if player.VisibleSlots.contains(index) =>
player.Slot(index).Equipment = None
zone.tasks ! HoldNewEquipmentUp(player)(trigger, index)
TaskWorkflow.execute(HoldNewEquipmentUp(player)(trigger, index))
case Some(index) =>
player.Slot(index).Equipment = None
zone.tasks ! PutNewEquipmentInInventoryOrDrop(player)(trigger)
TaskWorkflow.execute(PutNewEquipmentInInventoryOrDrop(player)(trigger))
case None =>
//don't know where boomer trigger "should" go
zone.tasks ! PutNewEquipmentInInventoryOrDrop(player)(trigger)
TaskWorkflow.execute(PutNewEquipmentInInventoryOrDrop(player)(trigger))
}
Players.buildCooldownReset(zone, player.Name, obj)
case _ => ;

4
src/main/scala/net/psforever/objects/ce/DeployableBehavior.scala
View file

@ -2,7 +2,7 @@
package net.psforever.objects.ce
import akka.actor.{Actor, ActorRef, Cancellable}
import net.psforever.objects.guid.GUIDTask
import net.psforever.objects.guid.{GUIDTask, TaskWorkflow}
import net.psforever.objects._
import net.psforever.objects.definition.DeployAnimation
import net.psforever.objects.zones.Zone
@ -280,7 +280,7 @@ trait DeployableBehavior {
*/
def unregisterDeployable(obj: Deployable): Unit = {
val zone = obj.Zone
zone.tasks ! GUIDTask.UnregisterObjectTask(obj)(zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterObject(zone.GUID, obj))
}
/**

10
src/main/scala/net/psforever/objects/definition/AmmoBoxDefinition.scala
View file

@ -2,17 +2,17 @@
package net.psforever.objects.definition
import net.psforever.objects.definition.converter.AmmoBoxConverter
import net.psforever.objects.equipment.Ammo
import net.psforever.objects.equipment.{Ammo, EquipmentSize}
class AmmoBoxDefinition(objectId: Int) extends EquipmentDefinition(objectId) {
import net.psforever.objects.equipment.EquipmentSize
Name = "ammo_box"
Size = EquipmentSize.Inventory
Packet = AmmoBoxDefinition.converter
private val ammoType: Ammo.Value = Ammo(objectId) //let throw NoSuchElementException
private var capacity: Int = 1
var repairAmount: Float = 0
registerAs = "ammo"
Name = "ammo box"
Size = EquipmentSize.Inventory
Packet = AmmoBoxDefinition.converter
def AmmoType: Ammo.Value = ammoType

1
src/main/scala/net/psforever/objects/definition/AvatarDefinition.scala
View file

@ -14,6 +14,7 @@ class AvatarDefinition(objectId: Int) extends ObjectDefinition(objectId) with Vi
Avatars(objectId) //let throw NoSuchElementException
Packet = AvatarDefinition.converter
Geometry = GeometryForm.representPlayerByCylinder(radius = 1.6f)
registerAs = "players"
}
object AvatarDefinition {

1
src/main/scala/net/psforever/objects/definition/ConstructionItemDefinition.scala
View file

@ -12,6 +12,7 @@ class ConstructionItemDefinition(objectId: Int) extends EquipmentDefinition(obje
CItem(objectId) //let throw NoSuchElementException
private val modes: ListBuffer[ConstructionFireMode] = ListBuffer()
Packet = new ACEConverter
registerAs = "items"
def Modes: ListBuffer[ConstructionFireMode] = modes
}

1
src/main/scala/net/psforever/objects/definition/DeployableDefinition.scala
View file

@ -59,6 +59,7 @@ abstract class DeployableDefinition(objectId: Int)
DamageUsing = DamageCalculations.AgainstVehicle
ResistUsing = NoResistanceSelection
Packet = new SmallDeployableConverter
registerAs = "deployables"
def Item: DeployedItem.Value = item
}

1
src/main/scala/net/psforever/objects/definition/KitDefinition.scala
View file

@ -16,6 +16,7 @@ class KitDefinition(objectId: Int) extends EquipmentDefinition(objectId) {
Tile = InventoryTile.Tile42
Name = "kit"
Packet = KitDefinition.converter
registerAs = "kits"
}
object KitDefinition {

3
src/main/scala/net/psforever/objects/definition/ObjectDefinition.scala
View file

@ -21,10 +21,11 @@ import net.psforever.types.OxygenState
* @param objectId the object's identifier number
*/
abstract class ObjectDefinition(private val objectId: Int) extends BasicDefinition {
var registerAs: String = "generic"
/** a data converter for this type of object */
protected var packet: PacketConverter = new ObjectCreateConverter[PlanetSideGameObject]() {}
Name = "object definition"
Name = "object_definition"
/**
* Get the conversion object.

1
src/main/scala/net/psforever/objects/definition/ProjectileDefinition.scala
View file

@ -60,6 +60,7 @@ class ProjectileDefinition(objectId: Int)
private var finalVelocity: Float = 0f
Name = "projectile"
Modifiers = DistanceDegrade
registerAs = "projectiles"
def ProjectileType: Projectiles.Value = projectileType

3
src/main/scala/net/psforever/objects/definition/SimpleItemDefinition.scala
View file

@ -6,8 +6,9 @@ import net.psforever.objects.equipment.SItem
class SimpleItemDefinition(objectId: Int) extends EquipmentDefinition(objectId) {
import net.psforever.objects.equipment.EquipmentSize
SItem(objectId) //let throw NoSuchElementException
Name = "tool"
Name = "simple_item"
Size = EquipmentSize.Pistol //all items
registerAs = "items"
}
object SimpleItemDefinition {

1
src/main/scala/net/psforever/objects/definition/ToolDefinition.scala
View file

@ -18,6 +18,7 @@ class ToolDefinition(objectId: Int) extends EquipmentDefinition(objectId) {
private var defaultFireModeIndex: Option[Int] = None
Name = "tool"
Packet = ToolDefinition.converter
registerAs = "tools"
def AmmoTypes: mutable.ListBuffer[AmmoBoxDefinition] = ammoTypes

1
src/main/scala/net/psforever/objects/definition/VehicleDefinition.scala
View file

@ -61,6 +61,7 @@ class VehicleDefinition(objectId: Int)
Model = VehicleResolutions.calculate
RepairDistance = 10
RepairRestoresAt = 1
registerAs = "vehicles"
def MaxShields: Int = maxShields

16
src/main/scala/net/psforever/objects/guid/AvailabilityPolicy.scala
View file

@ -1,16 +0,0 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.guid
/**
* The availability of individual GUIDs is maintained by the given policy.
*/
object AvailabilityPolicy extends Enumeration {
type Type = Value
/**
* An `AVAILABLE` GUID is ready and waiting to be `LEASED` for use.
* A `LEASED` GUID has been issued and is currently being used.
* A `RESTRICTED` GUID can never be freed. It is allowed, however, to be assigned once as if it were `LEASED`.
*/
val Available, Leased, Restricted = Value
}

437
src/main/scala/net/psforever/objects/guid/GUIDTask.scala
View file

@ -1,7 +1,7 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.guid
import akka.actor.ActorRef
import akka.util.Timeout
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.equipment.{Equipment, EquipmentSlot}
import net.psforever.objects._
@ -10,6 +10,8 @@ import net.psforever.objects.locker.{LockerContainer, LockerEquipment}
import net.psforever.objects.serverobject.turret.WeaponTurret
import scala.annotation.tailrec
import scala.concurrent.duration._
import scala.concurrent.Future
/**
* The basic compiled tasks for assigning (registering) and revoking (unregistering) globally unique identifiers.<br>
@ -22,43 +24,63 @@ import scala.annotation.tailrec
* It will get passed from the more complicated functions down into the less complicated functions,
* until it has found the basic number assignment functionality.<br>
* <br>
* All functions produce a `TaskResolver.GiveTask` container object
* or a list of `TaskResolver.GiveTask` container objects that is expected to be used by a `TaskResolver` `Actor`.
* All functions produce a `TaskBundle` container object
* or a list of `TaskBundle` container objects that is expected to be used by a `TaskBundle` container.
* These "task containers" can also be unpackaged into their component tasks, sorted into other containers,
* and combined with other tasks to enact more complicated sequences of operations.
* Almost all tasks have an explicit registering and an unregistering activity defined for it.
*/
object GUIDTask {
private implicit val timeout = Timeout(2.seconds)
//registration tasking
protected case class RegisterObjectTask(
guid: UniqueNumberOps,
obj: IdentifiableEntity,
pool: String
) extends Task {
def action(): Future[Any] = {
guid.Register(obj, pool)
}
def undo(): Unit = {
guid.Unregister(obj)
}
def isSuccessful() : Boolean = obj.HasGUID
override def description(): String = s"register $obj to $pool"
}
def RegisterObjectTask(guid: UniqueNumberOps, obj: IdentifiableEntity): RegisterObjectTask = obj match {
case o: PlanetSideGameObject => RegisterObjectTask(guid, o)
case _ => RegisterObjectTask(guid, obj, "generic")
}
def RegisterObjectTask(guid: UniqueNumberOps, obj: PlanetSideGameObject): RegisterObjectTask =
RegisterObjectTask(guid, obj, obj.Definition.registerAs)
/**
* Construct tasking that registers an object with a globally unique identifier selected from a pool of numbers.<br>
* <br>
* Construct tasking that registers an object with a globally unique identifier selected from a pool of numbers.
* Regardless of the complexity of the object provided to this function, only the current depth will be assigned a GUID.
* This is the most basic operation that all objects that can be assigned a GUID must perform.
* @param obj the object being registered
* @param guid implicit reference to a unique number system
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def RegisterObjectTask(obj: IdentifiableEntity)(implicit guid: ActorRef): TaskResolver.GiveTask = {
TaskResolver.GiveTask(new Task() {
private val localObject = obj
private val localAccessor = guid
def registerObject(guid: UniqueNumberOps, obj: IdentifiableEntity): TaskBundle =
TaskBundle(RegisterObjectTask(guid, obj, "generic"))
override def Description: String = s"register $localObject"
override def isComplete: Task.Resolution.Value =
if (localObject.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
def Execute(resolver: ActorRef): Unit = {
import net.psforever.objects.guid.actor.Register
localAccessor ! Register(localObject, "dynamic", resolver) //TODO pool should not be hardcoded
}
})
}
/**
* Construct tasking that registers an object with a globally unique identifier selected from a specific pool of numbers.
* Regardless of the complexity of the object provided to this function, only the current depth will be assigned a GUID.
* @param obj the object being registered
* @param guid implicit reference to a unique number system
* @return a `TaskBundle` message
*/
def registerObject(guid: UniqueNumberOps, obj: PlanetSideGameObject): TaskBundle =
TaskBundle(RegisterObjectTask(guid, obj, obj.Definition.registerAs))
/**
* Construct tasking that registers an object with a globally unique identifier selected from a pool of numbers, as a `Tool`.<br>
@ -74,41 +96,14 @@ object GUIDTask {
* else use a more general function to differentiate between simple and complex objects.
* @param obj the `Tool` object being registered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.RegisterEquipment`
* @return a `TaskResolver.GiveTask` message
* @see `GUIDTask.registerEquipment`
* @return a `TaskBundle` message
*/
def RegisterTool(obj: Tool)(implicit guid: ActorRef): TaskResolver.GiveTask = {
val ammoTasks: List[TaskResolver.GiveTask] =
(0 until obj.MaxAmmoSlot).map(ammoIndex => RegisterObjectTask(obj.AmmoSlots(ammoIndex).Box)).toList
TaskResolver.GiveTask(RegisterObjectTask(obj).task, ammoTasks)
}
/**
* Construct tasking that registers a `LockerContainer` object
* with a globally unique identifier selected from a pool of numbers.
* @param obj the object being registered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.UnregisterLocker`
* @return a `TaskResolver.GiveTask` message
*/
def RegisterLocker(obj: LockerContainer)(implicit guid: ActorRef): TaskResolver.GiveTask = {
TaskResolver.GiveTask(RegisterObjectTask(obj).task, RegisterInventory(obj))
}
def RegisterLocker(obj: LockerEquipment)(implicit guid: ActorRef): TaskResolver.GiveTask = {
TaskResolver.GiveTask(RegisterObjectTask(obj).task, RegisterInventory(obj))
}
/**
* Construct tasking that registers the objects that are within the given container's inventory
* with a globally unique identifier selected from a pool of numbers for each object.
* @param container the storage unit in which objects can be found
* @param guid implicit reference to a unique number system
* @see `GUID.UnregisterInventory`<br>
* `Container`
* @return a list of `TaskResolver.GiveTask` messages
*/
def RegisterInventory(container: Container)(implicit guid: ActorRef): List[TaskResolver.GiveTask] = {
container.Inventory.Items.map(entry => { RegisterEquipment(entry.obj) })
def registerTool(guid: UniqueNumberOps, obj: Tool): TaskBundle = {
TaskBundle(
RegisterObjectTask(guid, obj),
(0 until obj.MaxAmmoSlot).map(ammoIndex => registerObject(guid, obj.AmmoSlots(ammoIndex).Box))
)
}
/**
@ -125,17 +120,52 @@ object GUIDTask {
* The type will be sorted and the object will be handled according to its complexity level.
* @param obj the `Equipment` object being registered
* @param guid implicit reference to a unique number system
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def RegisterEquipment(obj: Equipment)(implicit guid: ActorRef): TaskResolver.GiveTask = {
def registerEquipment(guid: UniqueNumberOps, obj: Equipment): TaskBundle = {
obj match {
case tool: Tool =>
RegisterTool(tool)
case _ =>
RegisterObjectTask(obj)
case tool: Tool => registerTool(guid, tool)
case _ => registerObject(guid, obj)
}
}
/**
* Construct tasking that registers the objects that are within the given container's inventory
* with a globally unique identifier selected from a pool of numbers for each object.
* @param container the storage unit in which objects can be found
* @param guid implicit reference to a unique number system
* @see `GUIDTask.unregisterInventory`<br>
* `Container`
* @return a list of `TaskBundle` messages
*/
def registerInventory(guid: UniqueNumberOps, container: Container): List[TaskBundle] = {
container.Inventory.Items.map{ entry => registerEquipment(guid, entry.obj) }
}
/**
* Construct tasking that registers a `LockerContainer` object
* with a globally unique identifier selected from a pool of numbers.
* @param obj the object being registered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.unregisterLocker`
* @return a `TaskBundle` message
*/
def registerLocker(guid: UniqueNumberOps, obj: LockerContainer): TaskBundle = {
TaskBundle(RegisterObjectTask(guid, obj), registerInventory(guid, obj))
}
/**
* Construct tasking that registers a `LockerContainer` object
* with a globally unique identifier selected from a pool of numbers.
* @param obj the object being registered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.unregisterLocker`
* @return a `TaskBundle` message
*/
def registerLocker(guid: UniqueNumberOps, obj: LockerEquipment): TaskBundle = {
TaskBundle(RegisterObjectTask(guid, obj), registerInventory(guid, obj))
}
/**
* Construct tasking that registers an object with a globally unique identifier selected from a pool of numbers, as a `Player`.<br>
* <br>
@ -150,13 +180,13 @@ object GUIDTask {
* a task built of lesser registration tasks and supporting tasks should be written instead.
* @param tplayer the `Player` object being registered
* @param guid implicit reference to a unique number system
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def RegisterAvatar(tplayer: Player)(implicit guid: ActorRef): TaskResolver.GiveTask = {
val holsterTasks = VisibleSlotTaskBuilding(tplayer.Holsters(), RegisterEquipment)
val lockerTask = List(RegisterObjectTask(tplayer.avatar.locker))
val inventoryTasks = RegisterInventory(tplayer)
TaskResolver.GiveTask(RegisterObjectTask(tplayer).task, holsterTasks ++ lockerTask ++ inventoryTasks)
def registerAvatar(guid: UniqueNumberOps, tplayer: Player): TaskBundle = {
val holsterTasks = visibleSlotTaskBuilding(guid, tplayer.Holsters(), registerEquipment)
val lockerTask = List(registerObject(guid, tplayer.avatar.locker))
val inventoryTasks = registerInventory(guid, tplayer)
TaskBundle(RegisterObjectTask(guid, tplayer), holsterTasks ++ lockerTask ++ inventoryTasks)
}
/**
@ -165,12 +195,12 @@ object GUIDTask {
* Similar to `RegisterAvatar` but the locker components are skipped.
* @param tplayer the `Player` object being registered
* @param guid implicit reference to a unique number system
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def RegisterPlayer(tplayer: Player)(implicit guid: ActorRef): TaskResolver.GiveTask = {
val holsterTasks = VisibleSlotTaskBuilding(tplayer.Holsters(), RegisterEquipment)
val inventoryTasks = RegisterInventory(tplayer)
TaskResolver.GiveTask(GUIDTask.RegisterObjectTask(tplayer)(guid).task, holsterTasks ++ inventoryTasks)
def registerPlayer(guid: UniqueNumberOps, tplayer: Player): TaskBundle = {
val holsterTasks = visibleSlotTaskBuilding(guid, tplayer.Holsters(), registerEquipment)
val inventoryTasks = registerInventory(guid, tplayer)
TaskBundle(RegisterObjectTask(guid, tplayer), holsterTasks ++ inventoryTasks)
}
/**
@ -188,25 +218,39 @@ object GUIDTask {
* a task built of lesser registration tasks and supporting tasks should be written instead.
* @param vehicle the `Vehicle` object being registered
* @param guid implicit reference to a unique number system
* @return a `TaskResolver.GiveTask` message
* @return a `TaskBundle` message
*/
def RegisterVehicle(vehicle: Vehicle)(implicit guid: ActorRef): TaskResolver.GiveTask = {
val weaponTasks = VisibleSlotTaskBuilding(vehicle.Weapons.values, RegisterEquipment)
def registerVehicle(guid: UniqueNumberOps, vehicle: Vehicle): TaskBundle = {
val weaponTasks = visibleSlotTaskBuilding(guid, vehicle.Weapons.values, registerEquipment)
val utilTasks =
Vehicle.EquipmentUtilities(vehicle.Utilities).values.map(util => { RegisterObjectTask(util()) }).toList
val inventoryTasks = RegisterInventory(vehicle)
TaskResolver.GiveTask(RegisterObjectTask(vehicle).task, weaponTasks ++ utilTasks ++ inventoryTasks)
Vehicle.EquipmentUtilities(vehicle.Utilities).values.map(util => { registerObject(guid, util()) }).toList
val inventoryTasks = registerInventory(guid, vehicle)
TaskBundle(RegisterObjectTask(guid, vehicle), weaponTasks ++ utilTasks ++ inventoryTasks)
}
def RegisterDeployableTurret(
obj: PlanetSideGameObject with WeaponTurret
)(implicit guid: ActorRef): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
RegisterObjectTask(obj).task,
VisibleSlotTaskBuilding(obj.Weapons.values, GUIDTask.RegisterEquipment) ++ RegisterInventory(obj)
def registerDeployableTurret(guid: UniqueNumberOps, obj: PlanetSideGameObject with WeaponTurret): TaskBundle = {
TaskBundle(
RegisterObjectTask(guid, obj),
visibleSlotTaskBuilding(guid, obj.Weapons.values, registerEquipment) ++ registerInventory(guid, obj)
)
}
//unregistration tasking
protected case class UnregisterObjectTask(
guid: UniqueNumberOps,
obj: IdentifiableEntity
) extends Task {
def action(): Future[Any] = {
guid.Unregister(obj)
}
def undo(): Unit = RegisterObjectTask(guid, obj)
def isSuccessful() : Boolean = !obj.HasGUID
override def description(): String = s"unregister $obj"
}
/**
* Construct tasking that unregisters an object from a globally unique identifier system.<br>
* <br>
@ -214,73 +258,10 @@ object GUIDTask {
* It is the most basic operation that all objects that can have their GUIDs revoked must perform.
* @param obj the object being unregistered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.RegisterObjectTask`
* @return a `TaskResolver.GiveTask` message
* @see `GUIDTask.registerObjectTask`
* @return a `TaskBundle` message
*/
def UnregisterObjectTask(obj: IdentifiableEntity)(implicit guid: ActorRef): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private val localObject = obj
private val localAccessor = guid
override def Description: String = s"unregister $localObject"
override def isComplete: Task.Resolution.Value =
if (!localObject.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
def Execute(resolver: ActorRef): Unit = {
import net.psforever.objects.guid.actor.Unregister
localAccessor ! Unregister(localObject, resolver)
}
}
)
}
/**
* Construct tasking that unregisters a `Tool` object from a globally unique identifier system.<br>
* <br>
* This task performs an operation that reverses the effect of `RegisterTool`.
* @param obj the `Tool` object being unregistered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.RegisterTool`
* @return a `TaskResolver.GiveTask` message
*/
def UnregisterTool(obj: Tool)(implicit guid: ActorRef): TaskResolver.GiveTask = {
val ammoTasks: List[TaskResolver.GiveTask] =
(0 until obj.MaxAmmoSlot).map(ammoIndex => UnregisterObjectTask(obj.AmmoSlots(ammoIndex).Box)).toList
TaskResolver.GiveTask(UnregisterObjectTask(obj).task, ammoTasks)
}
/**
* Construct tasking that unregisters a `LockerContainer` object from a globally unique identifier system.
* @param obj the object being unregistered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.RegisterLocker`
* @return a `TaskResolver.GiveTask` message
*/
def UnregisterLocker(obj: LockerContainer)(implicit guid: ActorRef): TaskResolver.GiveTask = {
TaskResolver.GiveTask(UnregisterObjectTask(obj).task, UnregisterInventory(obj))
}
def UnregisterLocker(obj: LockerEquipment)(implicit guid: ActorRef): TaskResolver.GiveTask = {
TaskResolver.GiveTask(RegisterObjectTask(obj).task, RegisterInventory(obj))
}
/**
* Construct tasking that unregisters the objects that are within the given container's inventory
* from a globally unique identifier system.
* @param container the storage unit in which objects can be found
* @param guid implicit reference to a unique number system
* @see `GUIDTask.RegisterInventory`<br>
* `Container`
* @return a list of `TaskResolver.GiveTask` messages
*/
def UnregisterInventory(container: Container)(implicit guid: ActorRef): List[TaskResolver.GiveTask] = {
container.Inventory.Items.map(entry => { UnregisterEquipment(entry.obj) })
}
def unregisterObject(guid: UniqueNumberOps, obj: IdentifiableEntity): TaskBundle = TaskBundle(UnregisterObjectTask(guid, obj))
/**
* Construct tasking that unregisters an object from a globally unique identifier system
@ -289,32 +270,88 @@ object GUIDTask {
* This task performs an operation that reverses the effect of `RegisterEquipment`.
* @param obj the `Equipment` object being unregistered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.RegisterEquipment`
* @return a `TaskResolver.GiveTask` message
* @see `GUIDTask.registerEquipment`
* @return a `TaskBundle` message
*/
def UnregisterEquipment(obj: Equipment)(implicit guid: ActorRef): TaskResolver.GiveTask = {
def unregisterTool(guid: UniqueNumberOps, obj: Tool): TaskBundle = {
TaskBundle(
UnregisterObjectTask(guid, obj),
(0 until obj.MaxAmmoSlot).map(ammoIndex => unregisterObject(guid, obj.AmmoSlots(ammoIndex).Box))
)
}
/**
* Construct tasking that registers an object with a globally unique identifier selected from a pool of numbers,
* after determining whether the object is complex (`Tool` or `Locker`) or is simple.<br>
* <br>
* The objects in this case are specifically `Equipment`, a subclass of the basic register-able `IdentifiableEntity`.
* About five subclasses of `Equipment` exist, but they decompose into two groups - "complex objects" and "simple objects."
* "Simple objects" are most groups of `Equipment` and just their own GUID to be registered.
* "Complex objects" are just the `Tool` category of `Equipment`.
* They have internal objects that must also have their GUID's registered to function.<br>
* <br>
* Using this function when passing unknown `Equipment` is recommended.
* The type will be sorted and the object will be handled according to its complexity level.
* @param obj the `Equipment` object being registered
* @param guid implicit reference to a unique number system
* @return a `TaskBundle` message
*/
def unregisterEquipment(guid: UniqueNumberOps, obj: Equipment): TaskBundle = {
obj match {
case tool: Tool =>
UnregisterTool(tool)
case _ =>
UnregisterObjectTask(obj)
case tool: Tool => unregisterTool(guid, tool)
case _ => unregisterObject(guid, obj)
}
}
/**
* Construct tasking that unregisters the objects that are within the given container's inventory
* from a globally unique identifier system.
* @param container the storage unit in which objects can be found
* @param guid implicit reference to a unique number system
* @see `GUIDTask.registerInventory`<br>
* `Container`
* @return a list of `TaskBundle` messages
*/
def unregisterInventory(guid: UniqueNumberOps, container: Container): List[TaskBundle] = {
container.Inventory.Items.map{ entry => unregisterEquipment(guid, entry.obj) }
}
/**
* Construct tasking that unregisters a `LockerContainer` object from a globally unique identifier system.
* @param obj the object being unregistered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.registerLocker`
* @return a `TaskBundle` message
*/
def unregisterLocker(guid: UniqueNumberOps, obj: LockerContainer): TaskBundle = {
TaskBundle(UnregisterObjectTask(guid, obj), unregisterInventory(guid, obj))
}
/**
* Construct tasking that unregisters a `LockerContainer` object from a globally unique identifier system.
* @param obj the object being unregistered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.registerLocker`
* @return a `TaskBundle` message
*/
def unregisterLocker(guid: UniqueNumberOps, obj: LockerEquipment): TaskBundle = {
TaskBundle(UnregisterObjectTask(guid, obj), unregisterInventory(guid, obj))
}
/**
* Construct tasking that unregisters a `Player` object from a globally unique identifier system.<br>
* <br>
* This task performs an operation that reverses the effect of `RegisterAvatar`.
* @param tplayer the `Player` object being unregistered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.RegisterAvatar`
* @return a `TaskResolver.GiveTask` message
* @see `GUIDTask.registerAvatar`
* @return a `TaskBundle` message
*/
def UnregisterAvatar(tplayer: Player)(implicit guid: ActorRef): TaskResolver.GiveTask = {
val holsterTasks = VisibleSlotTaskBuilding(tplayer.Holsters(), UnregisterEquipment)
val lockerTask = List(UnregisterObjectTask(tplayer.avatar.locker))
val inventoryTasks = UnregisterInventory(tplayer)
TaskResolver.GiveTask(UnregisterObjectTask(tplayer).task, holsterTasks ++ lockerTask ++ inventoryTasks)
def unregisterAvatar(guid: UniqueNumberOps, tplayer: Player): TaskBundle = {
val holsterTasks = visibleSlotTaskBuilding(guid, tplayer.Holsters(), unregisterEquipment)
val lockerTask = List(unregisterObject(guid, tplayer.avatar.locker))
val inventoryTasks = unregisterInventory(guid, tplayer)
TaskBundle(UnregisterObjectTask(guid, tplayer), holsterTasks ++ lockerTask ++ inventoryTasks)
}
/**
@ -324,13 +361,13 @@ object GUIDTask {
* This task performs an operation that reverses the effect of `RegisterPlayer`.
* @param tplayer the `Player` object being unregistered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.RegisterAvatar`
* @return a `TaskResolver.GiveTask` message
* @see `GUIDTask.registerAvatar`
* @return a `TaskBundle` message
*/
def UnregisterPlayer(tplayer: Player)(implicit guid: ActorRef): TaskResolver.GiveTask = {
val holsterTasks = VisibleSlotTaskBuilding(tplayer.Holsters(), UnregisterEquipment)
val inventoryTasks = UnregisterInventory(tplayer)
TaskResolver.GiveTask(GUIDTask.UnregisterObjectTask(tplayer).task, holsterTasks ++ inventoryTasks)
def unregisterPlayer(guid: UniqueNumberOps, tplayer: Player): TaskBundle = {
val holsterTasks = visibleSlotTaskBuilding(guid, tplayer.Holsters(), unregisterEquipment)
val inventoryTasks = unregisterInventory(guid, tplayer)
TaskBundle(UnregisterObjectTask(guid, tplayer), holsterTasks ++ inventoryTasks)
}
/**
@ -339,26 +376,25 @@ object GUIDTask {
* This task performs an operation that reverses the effect of `RegisterVehicle`.
* @param vehicle the `Vehicle` object being unregistered
* @param guid implicit reference to a unique number system
* @see `GUIDTask.RegisterVehicle`
* @return a `TaskResolver.GiveTask` message
* @see `GUIDTask.registerVehicle`
* @return a `TaskBundle` message
*/
def UnregisterVehicle(vehicle: Vehicle)(implicit guid: ActorRef): TaskResolver.GiveTask = {
val weaponTasks = VisibleSlotTaskBuilding(vehicle.Weapons.values, UnregisterEquipment)
def unregisterVehicle(guid: UniqueNumberOps, vehicle: Vehicle): TaskBundle = {
val weaponTasks = visibleSlotTaskBuilding(guid, vehicle.Weapons.values, unregisterEquipment)
val utilTasks =
Vehicle.EquipmentUtilities(vehicle.Utilities).values.map(util => { UnregisterObjectTask(util()) }).toList
val inventoryTasks = UnregisterInventory(vehicle)
TaskResolver.GiveTask(UnregisterObjectTask(vehicle).task, weaponTasks ++ utilTasks ++ inventoryTasks)
Vehicle.EquipmentUtilities(vehicle.Utilities).values.map(util => { unregisterObject(guid, util()) }).toList
val inventoryTasks = unregisterInventory(guid, vehicle)
TaskBundle(UnregisterObjectTask(guid, vehicle), weaponTasks ++ utilTasks ++ inventoryTasks)
}
def UnregisterDeployableTurret(
obj: PlanetSideGameObject with WeaponTurret
)(implicit guid: ActorRef): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
UnregisterObjectTask(obj).task,
VisibleSlotTaskBuilding(obj.Weapons.values, GUIDTask.UnregisterEquipment) ++ UnregisterInventory(obj)
def unregisterDeployableTurret(guid: UniqueNumberOps, obj: PlanetSideGameObject with WeaponTurret): TaskBundle = {
TaskBundle(
UnregisterObjectTask(guid, obj),
visibleSlotTaskBuilding(guid, obj.Weapons.values, unregisterEquipment) ++ unregisterInventory(guid, obj)
)
}
//support
/**
* Construct tasking that allocates work upon encountered `Equipment` objects
* in reference to a globally unique identifier system of a pool of numbers.
@ -367,12 +403,14 @@ object GUIDTask {
* @param func the function used to build tasking from any discovered `Equipment`;
* strictly either `RegisterEquipment` or `UnregisterEquipment`
* @param guid implicit reference to a unique number system
* @return a list of `TaskResolver.GiveTask` messages
* @return a list of `TaskBundle` messages
*/
def VisibleSlotTaskBuilding(list: Iterable[EquipmentSlot], func: Equipment => TaskResolver.GiveTask)(implicit
guid: ActorRef
): List[TaskResolver.GiveTask] = {
recursiveVisibleSlotTaskBuilding(list.iterator, func)
private def visibleSlotTaskBuilding(
guid: UniqueNumberOps,
list: Iterable[EquipmentSlot],
func: (UniqueNumberOps, Equipment) => TaskBundle
): List[TaskBundle] = {
recursiveVisibleSlotTaskBuilding(guid, list.iterator, func)
}
/**
@ -386,18 +424,17 @@ object GUIDTask {
* @return a `List` of `Equipment` tasking
*/
@tailrec private def recursiveVisibleSlotTaskBuilding(
iter: Iterator[EquipmentSlot],
func: Equipment => TaskResolver.GiveTask,
list: List[TaskResolver.GiveTask] = Nil
)(implicit guid: ActorRef): List[TaskResolver.GiveTask] = {
guid: UniqueNumberOps,
iter: Iterator[EquipmentSlot],
func: (UniqueNumberOps, Equipment) => TaskBundle,
list: List[TaskBundle] = Nil
): List[TaskBundle] = {
if (!iter.hasNext) {
list
} else {
iter.next().Equipment match {
case Some(item) =>
recursiveVisibleSlotTaskBuilding(iter, func, list :+ func(item))
case None =>
recursiveVisibleSlotTaskBuilding(iter, func, list)
case Some(item) => recursiveVisibleSlotTaskBuilding(guid, iter, func, list :+ func(guid, item))
case None => recursiveVisibleSlotTaskBuilding(guid, iter, func, list)
}
}
}

11
src/main/scala/net/psforever/objects/guid/NumberPoolHub.scala
View file

@ -2,7 +2,7 @@
package net.psforever.objects.guid
import net.psforever.objects.entity.{IdentifiableEntity, NoGUIDException}
import net.psforever.objects.guid.key.LoanedKey
import net.psforever.objects.guid.key.{AvailabilityPolicy, LoanedKey}
import net.psforever.objects.guid.pool.{ExclusivePool, GenericPool, NumberPool}
import net.psforever.objects.guid.source.NumberSource
import net.psforever.types.PlanetSideGUID
@ -24,10 +24,7 @@ class NumberPoolHub(private val source: NumberSource) {
import scala.collection.mutable
private val hash: mutable.HashMap[String, NumberPool] = mutable.HashMap[String, NumberPool]()
private val bigpool: mutable.LongMap[String] = mutable.LongMap[String]()
hash += "generic" -> new GenericPool(bigpool, source.size)
source.finalizeRestrictions.foreach(i =>
bigpool += i.toLong -> ""
) //these numbers can never be pooled; the source can no longer restrict numbers
hash += "generic" -> GenericPool(bigpool, source.size, poolName = "generic")
/**
* Given a globally unique identifier, return any object registered to it.<br>
@ -327,7 +324,7 @@ class NumberPoolHub(private val source: NumberSource) {
* @param number the number whose assignment is requested
* @return an object that has been registered
*/
def latterPartRegister(obj: IdentifiableEntity, number: Int): Try[IdentifiableEntity] = {
private[guid] def latterPartRegister(obj: IdentifiableEntity, number: Int): Try[IdentifiableEntity] = {
register_GetMonitorFromSource(number) match {
case Success(monitor) =>
monitor.Object = obj
@ -459,7 +456,7 @@ class NumberPoolHub(private val source: NumberSource) {
* @param number the number to return.
* @return any object previously using this number
*/
def latterPartUnregister(number: Int): Option[IdentifiableEntity] = source.returnNumber(number)
private[guid] def latterPartUnregister(number: Int): Option[IdentifiableEntity] = source.returnNumber(number)
/**
* Determines if the object is registered.<br>

27
src/main/scala/net/psforever/objects/guid/Task.scala
View file

@ -1,27 +0,0 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.guid
import akka.actor.ActorRef
trait Task {
def Description: String = "write_descriptive_task_message"
def Execute(resolver: ActorRef): Unit
def isComplete: Task.Resolution.Value = Task.Resolution.Incomplete
def Timeout: Long = 200L //milliseconds
def onSuccess(): Unit = {}
def onFailure(ex: Throwable): Unit = {}
def onTimeout(ex: Throwable): Unit = onFailure(ex)
def onAbort(ex: Throwable): Unit = {}
def Cleanup(): Unit = {}
}
object Task {
def TimeNow: Long = {
System.nanoTime()
//java.time.Instant.now().getEpochSecond
}
object Resolution extends Enumeration {
val Success, Incomplete, Failure = Value
}
}

507
src/main/scala/net/psforever/objects/guid/TaskResolver.scala
View file

@ -1,507 +0,0 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.guid
import java.util.concurrent.TimeoutException
import akka.actor.{Actor, ActorRef, Cancellable}
import akka.routing.Broadcast
import net.psforever.objects.Default
import scala.annotation.tailrec
import scala.collection.mutable.ListBuffer
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}
class TaskResolver() extends Actor {
/** list of all work currently managed by this resolver */
private val tasks: ListBuffer[TaskResolver.TaskEntry] = new ListBuffer[TaskResolver.TaskEntry]
/** scheduled termination of tardy managed work */
private var timeoutCleanup: Cancellable = Default.Cancellable
/** logging utilities; default to tracing */
private[this] val log = org.log4s.getLogger
private def trace(msg: String) = log.trace(msg)
/**
* Deal with any tasks that are still enqueued with this expiring `TaskResolver`.
*/
override def aroundPostStop() = {
/*
First, eliminate all timed-out tasks.
Secondly, deal with all tasks that have reported "success" but have not yet been handled.
Finally, all other remaining tasks should be treated as if they had failed.
*/
timeoutCleanup.cancel()
TimeoutCleanup()
tasks.filter(entry => entry.task.isComplete == Task.Resolution.Success).foreach(entry => OnSuccess(entry.task))
val ex: Throwable = new Exception(s"a task is being stopped")
tasks.foreach(entry => {
OnFailure(entry.task, ex)
})
super.aroundPostStop()
}
def receive: Receive = {
case TaskResolver.GiveTask(aTask, Nil) =>
GiveTask(aTask)
case TaskResolver.GiveTask(aTask, subtasks) =>
QueueSubtasks(aTask, subtasks)
case TaskResolver.GiveSubtask(aTask, subtasks, resolver) =>
QueueSubtasks(aTask, subtasks, resolver)
case TaskResolver.CompletedSubtask(obj) => //inter-resolver calls
ExecuteNewTasks(obj)
case Success(obj: Task) => //inter-resolver calls
OnSuccess(obj)
case Success | Success(_) => //success redirected from called event
OnSuccess()
case TaskResolver.Failure(obj, ex) => //inter-resolver calls
OnFailure(obj, ex)
case Failure(ex) => //failure redirected from called event
OnFailure(ex)
case TaskResolver.AbortTask(task, ex) =>
OnAbort(task, ex)
case TaskResolver.TimeoutCleanup() =>
TimeoutCleanup()
case msg =>
log.warn(s"$self received an unexpected message $msg from ${sender()}")
}
/**
* Accept simple work and perform it.
* @param aTask the work to be completed
*/
private def GiveTask(aTask: Task): Unit = {
val entry: TaskResolver.TaskEntry = TaskResolver.TaskEntry(aTask)
tasks += entry
trace(s"enqueue and start task ${aTask.Description}")
entry.Execute(self)
StartTimeoutCheck()
}
/**
* Start the periodic checks for a task that has run for too long (timed-out), unless those checks are already running.
*/
private def StartTimeoutCheck(): Unit = {
if (timeoutCleanup.isCancelled) {
timeoutCleanup = context.system.scheduler.scheduleWithFixedDelay(
500 milliseconds,
500 milliseconds,
self,
TaskResolver.TimeoutCleanup()
)
}
}
/**
* Accept complicated work and divide it into a main task and tasks that must be handled before the main task.
* Do not start the main task until all of the aforementioned "sub-tasks" are completed.<br>
* <br>
* Sub-tasks can be nested many times.
* All immediate sub-tasks count as the primary sub-tasks for the current main task.
* Each pair of main task and sub-tasks, for every sub-task discovered, is passed on to another `TaskResolver` for completion.
* The parent of this `TaskResolver` is the router logic for all brethren `TaskResolver` `Actors`.
* @param task the work to be completed
* @param subtasks other work that needs to be completed first
* @param resolver the `TaskResolver` that distributed this work, thus determining that this work is a sub-task;
* by default, no one, as the work is identified as a main task
*/
private def QueueSubtasks(
task: Task,
subtasks: List[TaskResolver.GiveTask],
resolver: ActorRef = ActorRef.noSender
): Unit = {
val entry: TaskResolver.TaskEntry = TaskResolver.TaskEntry(task, subtasks.map(task => task.task), resolver)
tasks += entry
trace(s"enqueue task ${task.Description}")
if (subtasks.isEmpty) { //a leaf in terms of task dependency; so, not dependent on any other work
trace(s"start task ${task.Description}")
entry.Execute(self)
} else {
trace(s"enqueuing ${subtasks.length} substask(s) belonging to ${task.Description}")
subtasks.foreach({ subtask =>
context.parent ! TaskResolver.GiveSubtask(
subtask.task,
subtask.subs,
self
) //route back to submit subtask to pool
})
}
StartTimeoutCheck()
}
/**
* Perform these checks when a task has reported successful completion to this TaskResolver.
* Every task and subtask will be checked, starting from the end of the list of queued entries
* and only the first discovered one will be used.
*/
private def OnSuccess(): Unit = {
//by reversing the List, we find the most outstanding Task with the completion state
TaskResolver.filterCompletion(tasks.indices.reverseIterator, tasks.toList, Task.Resolution.Success) match {
case Some(index) =>
GeneralOnSuccess(index)
case None => ;
}
}
/**
* Perform these checks when a task has reported successful completion to this TaskResolver.
* @param task a `Task` object
*/
private def OnSuccess(task: Task): Unit = {
//find specific task and dequeue
TaskResolver.findTask(tasks.iterator, task) match {
case Some(index) =>
GeneralOnSuccess(index)
case None => ;
}
}
/**
* Perform these checks when a task has reported successful completion to this TaskResolver.
* This is what actually happens upon completion.
* @param index the `TaskEntry` index
*/
private def GeneralOnSuccess(index: Int): Unit = {
val entry = tasks(index)
entry.task.onSuccess()
trace(s"success with task ${entry.task.Description}")
if (entry.supertaskRef != ActorRef.noSender) {
entry.supertaskRef ! TaskResolver.CompletedSubtask(
entry.task
) //alert our dependent task's resolver that we have completed
}
TaskCleanup(index)
}
/**
* Scan across a group of sub-tasks and determine if the associated main `Task` may execute.
* All of the sub-tasks must report a `Success` completion status before the main work can begin.
* @param subtask a `Task` that is a subtask of some parent task in this resolver's group
*/
private def ExecuteNewTasks(subtask: Task): Unit = {
TaskResolver.findTaskWithSubtask(tasks.iterator, subtask) match {
case Some(index) =>
val entry = tasks(index)
if (TaskResolver.filterCompletionMatch(entry.subtasks.iterator, Task.Resolution.Success)) {
trace(s"start new task ${entry.task.Description}")
entry.Execute(self)
StartTimeoutCheck()
}
case None => ;
}
}
/**
* Perform these checks when a task has reported failure to this `TaskResolver`.
* Since the `Failure(Throwable)` can not be associated with a specific task,
* every task and subtask will be checked, starting from the end of the list of queued entries,
* and only the first discovered one will be used.
* Consequently, the specific `Throwable` that contains the error message may have nothing to do with the failed task.
* @param ex a `Throwable` that reports what happened to the task
*/
private def OnFailure(ex: Throwable): Unit = {
//by reversing the List, we find the most outstanding Task with the completion state
TaskResolver.filterCompletion(tasks.indices.reverseIterator, tasks.toList, Task.Resolution.Failure) match {
case Some(index) =>
GeneralOnFailure(index, ex)
case None => ;
}
}
/**
* Perform these checks when a task has reported failure to this `TaskResolver`.
* @param subtask the task that had reported failure from some other resolver
* @param ex a `Throwable` that reports what happened to the task
*/
private def OnFailure(subtask: Task, ex: Throwable): Unit = {
TaskResolver.findTaskWithSubtask(tasks.iterator, subtask) match {
case Some(index) =>
GeneralOnFailure(index, ex)
case None => ;
}
}
/**
* Perform these checks when a task has reported failure to this `TaskResolver`.
* This is what actually happens upon completion.
* @param index the `TaskEntry` index
* @param ex a `Throwable` that reports what happened to the task
*/
private def GeneralOnFailure(index: Int, ex: Throwable): Unit = {
val entry = tasks(index)
val task = entry.task
trace(s"failure with task ${task.Description}")
task.onAbort(ex)
task.onFailure(ex)
if (entry.supertaskRef != ActorRef.noSender) {
entry.supertaskRef ! TaskResolver.Failure(task, ex) //alert our superior task's resolver we have completed
}
FaultSubtasks(entry)
TaskCleanup(index)
}
/**
* Instruct all subtasks of a given `Task` to fail.
* @param entry the target parent entry (that has failed)
*/
private def FaultSubtasks(entry: TaskResolver.TaskEntry): Unit = {
val ex: Throwable = new Exception(s"a task ${entry.task} had a subtask that failed")
entry.subtasks.foreach(subtask => {
context.parent ! Broadcast(TaskResolver.Failure(subtask, ex)) //we have no clue where this subtask was hosted
})
}
/**
* If a specific `Task` is governed by this `TaskResolver`, find its index and dispose of it and its known sub-tasks.
* @param task the work to be found
* @param ex a `Throwable` that reports what happened to the work
*/
private def OnAbort(task: Task, ex: Throwable): Unit = {
TaskResolver.findTask(tasks.iterator, task) match {
case Some(index) =>
PropagateAbort(index, ex)
TaskCleanup(index)
case None => ;
}
}
/**
* If a specific `Task` is governed by this `TaskResolver`, dispose of it and its known sub-tasks.
* @param index the index of the discovered work
* @param ex a `Throwable` that reports what happened to the work
*/
private def PropagateAbort(index: Int, ex: Throwable): Unit = {
tasks(index).subtasks.foreach({ subtask =>
if (subtask.isComplete == Task.Resolution.Success) {
trace(s"aborting task ${subtask.Description}")
subtask.onAbort(ex)
}
context.parent ! Broadcast(TaskResolver.AbortTask(subtask, ex))
})
}
/**
* Find all tasks that have been running for too long and declare them as timed-out.
* Run periodically, as long as work is being performed.
*/
private def TimeoutCleanup(): Unit = {
TaskResolver
.filterTimeout(tasks.indices.reverseIterator, tasks.toList, Task.TimeNow)
.foreach({ index =>
val ex: Throwable = new TimeoutException(s"a task ${tasks(index).task} has timed out")
tasks(index).task.onTimeout(ex)
PropagateAbort(index, ex)
})
}
/**
* Remove a `Task` that has reported completion.
* @param index an index of work in the `List` of `Task`s
*/
private def TaskCleanup(index: Int): Unit = {
tasks(index).task.Cleanup()
tasks.remove(index)
if (tasks.isEmpty) {
timeoutCleanup.cancel()
}
}
}
object TaskResolver {
/**
* Give this `TaskResolver` simple work to be performed.
* @param task the work to be completed
* @param subs other work that needs to be completed first
*/
final case class GiveTask(task: Task, subs: List[GiveTask] = Nil)
/**
* Pass around complex work to be performed.
* @param task the work to be completed
* @param subs other work that needs to be completed first
* @param resolver the `TaskResolver` that will handle work that depends on the outcome of this work
*/
private final case class GiveSubtask(task: Task, subs: List[GiveTask], resolver: ActorRef)
/**
* Run a scheduled timed-out `Task` check.
*/
private final case class TimeoutCleanup()
/**
* A specific kind of `Failure` that reports on which specific `Task` has reported failure.
* @param obj a task object
* @param ex information about what went wrong
*/
private final case class Failure(obj: Task, ex: Throwable)
/**
* A specific kind of `Success` that reports on which specific `Task` has reported Success where that `Task` was some other `Task`'s subtask.
* @param obj a task object
*/
private final case class CompletedSubtask(obj: Task)
/**
* A `Broadcast` message designed to find and remove a particular task from this series of routed `Actors`.
* @param task the work to be removed
* @param ex an explanation why the work is being aborted
*/
private final case class AbortTask(task: Task, ex: Throwable)
/**
* Storage unit for a specific unit of work, plus extra information.
* @param task the work to be completed
* @param subtasks other work that needs to be completed first
* //@param isASubtask whether this work is intermediary or the last in a dependency chain
* @param supertaskRef the `TaskResolver` that will handle work that depends on the outcome of this work
*/
private final case class TaskEntry(
task: Task,
subtasks: List[Task] = Nil,
supertaskRef: ActorRef = ActorRef.noSender
) {
private var start: Long = 0L
private var isExecuting: Boolean = false
def Start: Long = start
def Executing: Boolean = isExecuting
/**
* Only execute each task once.
* @param ref the `TaskResolver` currently handling this `Task`/`TaskEntry`
*/
def Execute(ref: ActorRef): Unit = {
if (!isExecuting) {
isExecuting = true
start = Task.TimeNow
task.Execute(ref)
}
}
}
/**
* Scan across a group of tasks to determine which ones match the target completion status.
* @param iter an `Iterator` of enqueued `TaskEntry` indices
* @param resolution the target completion status
* @return the first valid index when `TaskEntry` has its primary `Task` matching the completion status
*/
@tailrec private def filterCompletion(
iter: Iterator[Int],
tasks: List[TaskEntry],
resolution: Task.Resolution.Value
): Option[Int] = {
if (!iter.hasNext) {
None
} else {
val index: Int = iter.next()
if (tasks(index).task.isComplete == resolution) {
Some(index)
} else {
filterCompletion(iter, tasks, resolution)
}
}
}
/**
* Scan across a group of sub-tasks to determine if they all match the target completion status.
* @param iter an `Iterator` of enqueued sub-tasks
* @param resolution the target completion status
* @return `true`, if all tasks match the complete status;
* `false`, otherwise
*/
@tailrec private def filterCompletionMatch(iter: Iterator[Task], resolution: Task.Resolution.Value): Boolean = {
if (!iter.hasNext) {
true
} else {
if (iter.next().isComplete == resolution) {
filterCompletionMatch(iter, resolution)
} else {
false
}
}
}
/**
* Find the indices of all enqueued work that has timed-out.
* @param iter an `Iterator` of enqueued `TaskEntry` indices
* @param now the current time in milliseconds
* @param indexList a persistent `List` of indices
* @return the `List` of all valid `Task` indices
*/
@tailrec private def filterTimeout(
iter: Iterator[Int],
tasks: List[TaskEntry],
now: Long,
indexList: List[Int] = Nil
): List[Int] = {
if (!iter.hasNext) {
indexList
} else {
val index: Int = iter.next()
val taskEntry = tasks(index)
if (
taskEntry.Executing && taskEntry.task.isComplete == Task.Resolution.Incomplete && now - taskEntry.Start > taskEntry.task.Timeout
) {
filterTimeout(iter, tasks, now, indexList :+ index)
} else {
filterTimeout(iter, tasks, now, indexList)
}
}
}
/**
* Find the index of the targeted `Task`, if it is enqueued here.
* @param iter an `Iterator` of entries
* @param target a target `Task`
* @param index the current index in the aforementioned `List`;
* defaults to 0
* @return the index of the discovered task, or `None`
*/
@tailrec private def findTask(iter: Iterator[TaskEntry], target: Task, index: Int = 0): Option[Int] = {
if (!iter.hasNext) {
None
} else {
if (iter.next().task == target) {
Some(index)
} else {
findTask(iter, target, index + 1)
}
}
}
/**
* Find the index of the targeted `Task`, if it is enqueued here, given a specific "subtask" of that `Task`.
* @param iter an `Iterator` of entries
* @param target a target subtask
* @param index the current index in the aforementioned `List`;
* defaults to 0
* @return the index of the discovered task, or `None`
*/
@tailrec private def findTaskWithSubtask(iter: Iterator[TaskEntry], target: Task, index: Int = 0): Option[Int] = {
if (!iter.hasNext) {
None
} else {
val tEntry = iter.next()
if (tEntry.subtasks.contains(target)) {
Some(index)
} else {
findTaskWithSubtask(iter, target, index + 1)
}
}
}
}

215
src/main/scala/net/psforever/objects/guid/TaskWorkflow.scala Normal file
View file

@ -0,0 +1,215 @@
// Copyright (c) 2021 PSForever
package net.psforever.objects.guid
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.{Future, Promise}
import scala.util.{Failure, Success}
/**
* Parts of the task resolution lifecycle.
*/
sealed trait TaskBehaviors {
/** What the task is supposed to accomplish. */
def action(): Future[Any]
/** A reversal of 'what the task is supposed to accomplish'. */
def undo(): Unit
/** Has the task been successfully completed? */
def isSuccessful(): Boolean
/** Describe this task's actions. */
def description(): String = getClass.getSimpleName
}
/**
* A primary unit of work in a workflow.
*/
trait Task
extends TaskBehaviors {
/** A careful determination if the task can be attempted.
* @see `Task.action`
*/
private[guid] def performAction(): Future[Any] = {
if (!isSuccessful()) {
action()
} else {
Future(Failure(new TaskNotExecutedException(task = this)))
}
}
/** A careful determination if the task needs to be undone.
* @see `Task.undo`
*/
private[guid] def performUndo(): Unit = {
if (isSuccessful()) undo() else ()
}
}
/**
* A primary unit of work in a workflow that is set up to execute and never be taken back.
* Good for top-level tasking that only reports on the success of work carried out by subtasks.
*/
trait StraightforwardTask
extends Task {
def undo(): Unit = { /* blank */ }
def isSuccessful(): Boolean = false /* always primed to be executed */
}
/**
* The packaging of a more complicated unit of work in a workflow
* in which one task relies on the successful completion of other tasks.
* @param mainTask the primary task
* @param subTasks tasks that are necessary to complete before starting on the primary one
*/
final case class TaskBundle(mainTask: Task, subTasks: Seq[TaskBundle])
extends TaskBehaviors {
/** Attempt 'what the [primary] task is supposed to accomplish'. */
def action(): Future[Any] = mainTask.performAction()
/** Attempt a reversal of what the all the connected tasks are 'supposed to accomplish'. */
def undo() : Unit = {
mainTask.performUndo()
subTasks.foreach { _.undo() }
}
/** A hierarchical analysis of whether `the task been successfully completed`. */
def isSuccessful(): Boolean = mainTask.isSuccessful() && subTasks.forall { _.isSuccessful() }
override def description(): String = {
val subCount: String = if (subTasks.nonEmpty) s" (${subTasks.size} subtasks)" else ""
s"${mainTask.description()}$subCount"
}
}
object TaskBundle {
/**
* The packaging of a unit of work in a workflow.
* @param task the task
*/
def apply(task: Task): TaskBundle = TaskBundle(task, List())
/**
* The packaging of a unit of work in a workflow
* and a single task required to be completed first.
* @param task the primary task
* @param subTask the task that must be completed before the primary task
*/
def apply(task: Task, subTask: Task): TaskBundle = TaskBundle(task, TaskBundle(subTask))
/**
* The packaging of a unit of work in a workflow
* and the task(s) required to be completed first.
* @param task the primary task
* @param subTask the task(s) that must be completed before the primary task
*/
def apply(task: Task, subTask: TaskBundle): TaskBundle = TaskBundle(task, Seq(subTask))
}
class TaskNotExecutedException(task: TaskBehaviors, msg: String) extends Exception(msg) {
def this(task: Task) = {
this(task, s"task '${task.description()}' was not successful")
}
def this(task: TaskBundle) = {
this(task, s"task ${task.description()} was not successful")
}
}
object TaskWorkflow {
/**
* The entry into the task workflow resolution process.
* @param taskTree the packaged tasks that need to be completed
* @return the anticipation of a task to be completed
*/
def execute(taskTree: TaskBundle): Future[Any] = {
evaluateTaskAndSubs(taskTree)
}
private def evaluateTaskAndSubs(task: TaskBundle): Future[Any] = {
val promise = Promise[Any]()
val (result, subResults) = composeTaskAndSubs(task)
result.onComplete { _ =>
if (matchOnFutureFailure(result)) {
//every subtask that has already succeeded must be undone
subResults
.zip(task.subTasks)
.collect { case (a, b) if matchOnFutureSuccess(a) => b }
.foreach { _.undo() }
}
promise.completeWith(result)
}
promise.future
}
private def composeTaskAndSubs(task: TaskBundle): (Future[Any], Seq[Future[Any]]) = {
val promise = Promise[Any]()
val composedSubs = task.subTasks.map(evaluateTaskAndSubs)
composedSubs match {
case Nil =>
//no subtasks; just execute the main task
promise.completeWith(task.action())
case list =>
var unassignedCompletion: Boolean = true //shared mutex
//wait for subtasks to complete
list.foreach { result =>
result.onComplete { _ =>
unassignedCompletion.synchronized {
if (unassignedCompletion && composedSubs.forall(matchOnFutureCompletion)) {
unassignedCompletion = false
if (composedSubs.forall(matchOnFutureSuccess)) {
//if all subtasks passed, execute the main task
promise.completeWith(task.action())
} else {
//if some subtasks did not succeed, pass on wrapped failure
promise.completeWith(Future(Failure(new TaskNotExecutedException(task))))
}
}
}
}
}
}
(promise.future, composedSubs)
}
/**
* Does this anticipation of a task report having completed?
* @param f the anticipation
* @return whether it has been completed (passed or failed)
*/
def matchOnFutureCompletion(f: Future[Any]): Boolean = {
/*
if 'matchOnFutureCompletion(FUTURE) == false' then 'matchOnFutureSuccess(FUTURE) == matchOnFutureFailure(FUTURE)'
if 'matchOnFutureCompletion(FUTURE) == true' then 'matchOnFutureSuccess(FUTURE) != matchOnFutureFailure(FUTURE)'
*/
f.value match {
case Some(_) => true
case None => false
}
}
/**
* Does this anticipation of a task report having succeeded?
* The only true success is one where there is no `Failure` and no `Exception`.
* @param f the anticipation
* @return whether it has succeeded
*/
def matchOnFutureSuccess(f: Future[Any]): Boolean = {
f.value match {
case Some(Success(_: Exception)) => false
case Some(Success(Failure(_))) => false
case Some(Success(_)) => true
case _ => false
}
}
/**
* Does this anticipation of a task report having failed?
* Having not yet completed does not count as a failure.
* @param f the anticipation
* @return whether it has failed
*/
def matchOnFutureFailure(f: Future[Any]): Boolean = {
f.value match {
case Some(Failure(_)) => true
case Some(Success(_: Exception)) => true
case Some(Success(Failure(_))) => true
case _ => false
}
}
}

454
src/main/scala/net/psforever/objects/guid/UniqueNumberOps.scala Normal file
View file

@ -0,0 +1,454 @@
// Copyright (c) 2017-2021 PSForever
package net.psforever.objects.guid
import akka.actor.{Actor, ActorContext, ActorRef, Props}
import akka.pattern.{AskTimeoutException, ask}
import akka.util.Timeout
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.uns.{
AlreadyRegisteredEntity,
AlreadyUnregisteredEntity,
NumberPoolActor,
RegisteredEntity,
UnregisteredEntity
}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._
import scala.concurrent.{Future, Promise}
import scala.util.{Failure, Success}
/**
* Wrap around converted `NumberPool`s and synchronize a portion of the number registration process
* as a part of the global unique identifier (GUID, UID) number system (UNS, "unique number system").
* The ultimate goal is to manage a coherent group of unique identifiers for a given "region".
* Both parts of the UID system sit atop the `Zone` for easy external access.
* The plain part - the `NumberPoolHub` here - is used for low-priority requests
* such as checking for existing associations.<br>
* <br>
* A four part process is used for object registration tasks.
* First, the requested `NumberPool` is located among the list of known `NumberPool`s.
* Second, an asynchronous request is sent to that pool to retrieve a number.
* (Only any number. Only a failing case allows for selection of a specific number.)
* Third, the asynchronous request returns and the original information about the request is recovered.
* Fourth, both sides of the contract are completed by the object being assigned the number and
* the underlying "number source" is made to remember an association between the object and the number.
* Short circuits and recoveries as available on all steps though reporting is split between logging and callbacks.
* The process of removing the association between a number and object (unregistering) is a similar four part process.<br>
* <br>
* The important relationship between this `Actor` and the `Map` of `NumberPoolActors` is as a "gate."
* A single `Map` is constructed and shared between multiple entry points to the UID system where requests are messaged.
* Multiple entry points send messages to the same `NumberPool`.
* That `NumberPool` deals with the messages one at a time and sends reply to each entry point that communicated with it.
* This process is almost as fast as the process of the `NumberPool` selecting a number.
* (At least, both should be fast.)
* @param guid the supporting datatype for the unique number distribution
* @param poolActors a mapping created from the `NumberPool`s, to achieve synchronized access
*/
class UniqueNumberOps(
private val guid: NumberPoolHub,
private val poolActors: Map[String, ActorRef]
) {
/** The timeout used by all number pool `ask` messaging */
private implicit val timeout = UniqueNumberOps.timeout
/**
* The entry point for the entity GUID registration process.
* A special check is made first to determine if the entity is already registered, and if so to where.
* If the entity is not registered, then the process continues.
* @param obj the entity to be assigned a GUID
* @param poolName the pool from which the entity wants a GUID to be selected
* @return the anticipation of this activity being completed
*/
def Register(
obj: IdentifiableEntity,
poolName: String
): Future[Any] = {
val result: Promise[Any] = Promise()
if (obj.HasGUID) {
alreadyRegisteredTo(obj, poolName) match {
case Some(pname) =>
result.success(AlreadyRegisteredEntity(RegisteredEntity(obj, pname, guid, obj.GUID.guid)))
case None =>
result.failure(new RegisteredToWrongPlaceException(obj, obj.GUID.guid))
}
} else {
result.completeWith(registrationProcess(obj, poolName))
}
result.future
}
/**
* The entry point for the entity GUID unregistration process.
* A special check is made first to determine where, if at all, the entity is registered.
* Obviously, if the entity is not registered somewhere within purview of this UNS, the process can not continue.
* If the entity's registration number pool is found, then the process continues.
* @param obj the entity to be unassigned its GUID
* @return the anticipation of this activity being completed
*/
def Unregister(obj: IdentifiableEntity): Future[Any] = {
val result: Promise[Any] = Promise()
if (obj.HasGUID) {
val number = obj.GUID.guid
guid.WhichPool(number) match {
case Some(pname) =>
result.completeWith(unregistrationProcess(obj, number, pname))
case None =>
result.failure(new RegisteredToWrongPlaceException(obj, number))
}
} else {
UniqueNumberOps.log.warn(s"$obj is already unregistered")
result.success(Future(AlreadyUnregisteredEntity(UnregisteredEntity(obj, "", guid, -1))))
}
result.future
}
/**
* A step of the entity GUID registration process.
* Pass control through to the next step.
* @see `registrationProcess(IdentifiableEntity, NumberPoolHub, Map[String, ActorRef], String)`
* @param obj the entity to be assigned a GUID
* @param poolName the pool to which the object is trying to register
* @return the anticipation of this activity being completed
*/
private def registrationProcess(
obj: IdentifiableEntity,
poolName: String
): Future[Any] = {
registrationProcess(obj, guid, poolActors, poolName)
}
/**
* A step of the entity GUID registration process.
* Send a message to the `NumberPool` to request a number.
* If a number is received, continue with a successful registration process.
* If no number is received, or some other issue occurs, attempt to recover from the error and report it.
* This method is designed to be recursive as it is also utilized for the recovery attempt
* and must pass all of the necessary information on to that next attempt.
* @param obj the entity to be assigned a GUID
* @param hub the supporting datatype for the unique number distribution
* @param pools a mapping created from the `NumberPool`s, to achieve synchronized access
* @param poolName the pool to which the object is trying to register
* @return the anticipation of this activity being completed
*/
private def registrationProcess(
obj: IdentifiableEntity,
hub: NumberPoolHub,
pools: Map[String, ActorRef],
poolName: String
): Future[Any] = {
val promisingResult: Promise[Any] = Promise()
pools.get(poolName) match {
case Some(pool) =>
//cache
val localPromise = promisingResult
val localTarget = obj
val localUns = hub
val localPools = pools
val localPoolName = poolName
val localPool = pool
val result = ask(pool, NumberPoolActor.GetAnyNumber())(timeout)
result.onComplete {
case Success(NumberPoolActor.GiveNumber(number)) =>
UniqueNumberOps.processRegisterResult(
localPromise,
localTarget,
localUns,
localPoolName,
localPool,
number
)
case Success(NumberPoolActor.NoNumber(ex)) =>
registrationProcessRetry(localPromise, ex, localTarget, localUns, localPools, localPoolName)
case msg =>
UniqueNumberOps.log.warn(s"unexpected message during $localTarget's registration process - $msg")
}
result.recover {
case ex: AskTimeoutException =>
localPromise.failure(new RegisteringException(msg = s"did not register entity $localTarget in time", ex))
}
case None =>
//do not log
val ex = new Exception(s"can not find pool $poolName")
registrationProcessRetry(promisingResult, ex, obj, guid, pools, poolName)
}
promisingResult.future
}
/**
* na
* @param promise the ongoing promise to be fulfilled for the future
* @param exception an issue that has arrisen, forcing the retry attempt
* @param obj the entity to be assigned a GUID
* @param hub the supporting datatype for the unique number distribution
* @param pools a mapping created from the `NumberPool`s, to achieve synchronized access
* @param poolName the pool to which the object is trying to register
*/
def registrationProcessRetry(
promise: Promise[Any],
exception: Throwable,
obj: IdentifiableEntity,
hub: NumberPoolHub,
pools: Map[String, ActorRef],
poolName: String
): Unit = {
if (poolName.equals("generic")) {
promise.failure(new RegisteringException(msg = s"did not register entity $obj", exception))
} else {
org.log4s.getLogger("UniqueNumberOps").warn(s"${exception.getLocalizedMessage()} - $poolName")
promise.completeWith(registrationProcess(obj, guid, pools, poolName = "generic"))
}
}
/**
* A step of the entity GUID unregistration process.
* Pass control through to the next step.
* @see `unregistrationProcess(IdentifiableEntity, NumberPoolHub, Map[String, ActorRef], Int, String)`
* @param obj the entity to be unassigned its GUID
* @param number the number that was previously drawn from the specified `NumberPool`
* @param poolName the pool to which the number will try to be returned
* @return the anticipation of this activity being completed
*/
private def unregistrationProcess(
obj: IdentifiableEntity,
number: Int,
poolName: String
): Future[Any] = {
unregistrationProcess(obj, guid, poolActors, number, poolName)
}
/**
* A step of the entity GUID unregistration process.
* ...
* @param obj the entity to be unassigned its GUID
* @param hub the supporting datatype for the unique number distribution
* @param pools a mapping created from the `NumberPool`s, to achieve synchronized access
* @param number the number that was previously drawn from the specified `NumberPool`
* @param poolName the pool to which the number will try to be returned
* @return the anticipation of this activity being completed
*/
private def unregistrationProcess(
obj: IdentifiableEntity,
hub: NumberPoolHub,
pools: Map[String, ActorRef],
number: Int,
poolName: String
): Future[Any] = {
val promisingResult: Promise[Any] = Promise()
pools.get(poolName) match {
case Some(pool) =>
//cache
val localPromise = promisingResult
val localTarget = obj
val localUns = hub
val localPoolName = poolName
val localPool = pool
val localNumber = number
val result = ask(pool, NumberPoolActor.ReturnNumber(number))
result.onComplete {
case Success(NumberPoolActor.ReturnNumberResult(_, None)) =>
UniqueNumberOps.processUnregisterResult(
localPromise,
localTarget,
localUns,
localPoolName,
localPool,
localNumber
)
case Success(NumberPoolActor.ReturnNumberResult(_, Some(ex))) => //if there is a problem when returning the number
localPromise.failure { new UnregisteringException(msg = s"could not unregister $localTarget with number $localNumber", ex) }
case msg =>
UniqueNumberOps.log.warn(s"unexpected message $msg during $localTarget's unregistration process")
}
result.recover {
case ex: AskTimeoutException =>
localPromise.failure { new UnregisteringException(msg = s"did not unregister entity $localTarget in time", ex) }
}
case None =>
//do not log; use callback
promisingResult.failure { new UnregisteringException(msg = s"can not find pool $poolName; $obj was not unregistered") }
}
promisingResult.future
}
/**
* Generate a relevant logging message for an object that is trying to register to this UNS
* but is actually already registered to this UNS.
* Also take note if the entity is (probably) not registered to this UNS.
* @param obj the object that was trying to register
* @param poolName the pool to which the object was trying to register
* @return the pool name to which the entity is registered, if it can be discovered
*/
private def alreadyRegisteredTo(obj: IdentifiableEntity, poolName: String): Option[String] = {
val (msg, determinedName) =
guid.WhichPool(obj) match {
case out @ Some(pname) =>
if (poolName.equals(pname)) {
(s"to pool $poolName", Some(poolName))
} else {
(s"but to different pool $pname", out)
}
case None =>
("but not to any pool known to this system", None)
}
UniqueNumberOps.log.warn(s"$obj already registered $msg")
determinedName
}
}
object UniqueNumberOps {
private val log = org.log4s.getLogger
private implicit val timeout = Timeout(2.seconds)
/**
* Final step of the object registration process.
* This step completes the registration by asking the `NumberPoolHub` to sort out its `NumberSource`.
* @param promise the ongoing promise to be fulfilled for the future
* @param obj the entity to be assigned a GUID
* @param guid the supporting datatype for the unique number distribution
* @param poolName the name of the pool to which the object is trying to register
* @param pool the pool to which the object is trying to register
* @param number the number that was drawn
*/
private def processRegisterResult(
promise: Promise[Any],
obj: IdentifiableEntity,
guid: NumberPoolHub,
poolName: String,
pool: ActorRef,
number: Int
): Unit = {
guid.latterPartRegister(obj, number) match {
case Success(_) =>
promise.success(RegisteredEntity(obj, poolName, guid, number))
case Failure(ex) =>
//do not log; use callback
returnNumberNoCallback(number, pool) //recovery?
promise.failure(ex)
}
}
/**
* A step of the object unregistration process.
* This step completes revoking of the object's registration by consulting the `NumberSource`.
* @param promise the ongoing promise to be fulfilled for the future
* @param obj the entity to be unassigned its GUID
* @param guid the supporting datatype for the unique number distribution
* @param poolName the name of pool to which the number will try to be returned
* @param pool the pool to which the number will try to be returned
* @param number the number that was previously drawn from the specified `NumberPool`
*/
private def processUnregisterResult(
promise: Promise[Any],
obj: IdentifiableEntity,
guid: NumberPoolHub,
poolName: String,
pool: ActorRef,
number: Int
): Unit = {
guid.latterPartUnregister(number) match {
case Some(_) =>
obj.Invalidate()
promise.success(UnregisteredEntity(obj, poolName, guid, number))
case None =>
//do not log
requestSpecificNumberNoCallback(number, pool) //recovery?
promise.failure(new UnregisteringException(msg = s"failed to unregister $obj from number $number; this may be a critical error"))
}
}
/**
* Access a specific `NumberPool` in a way that doesn't propagate a callback and reset one of its numbers.
* The `ask` pattern catches any reply message and ensures nothing happens because of it.
* @param number the number that was drawn from a `NumberPool`
* @param pool the `NumberPool` from which the `number` was drawn
*/
private def returnNumberNoCallback(number: Int, pool: ActorRef): Unit = {
val result = ask(pool, NumberPoolActor.ReturnNumber(number))
result.onComplete { _ => ; }
result.recover { case _ => ; }
}
/**
* Access a specific `NumberPool` in a way that doesn't propagate a callback and claim one of its numbers.
* The `ask` pattern catches any reply message and ensures nothing happens because of it.
* @param number the number to be drawn from a `NumberPool`
* @param pool the `NumberPool` from which the `number` is to be drawn
*/
private def requestSpecificNumberNoCallback(number: Int, pool: ActorRef): Unit = {
val result = ask(pool, NumberPoolActor.GetSpecificNumber(number))
result.onComplete { _ => ; }
result.recover { case _ => ; }
}
}
class RegisteringException(msg: String) extends Exception(msg) {
def this(msg: String, cause: Throwable) = {
this(msg)
initCause(cause)
}
}
class UnregisteringException(msg: String) extends Exception(msg) {
def this(msg: String, cause: Throwable) = {
this(msg)
initCause(cause)
}
}
/**
* The entity was registered, but not to the target UNS.
* Rookie mistake.
* @param obj the entity to be assigned a GUID
* @param number the name associated with this entity
*/
class RegisteredToWrongPlaceException(obj: IdentifiableEntity, number: Int)
extends RuntimeException(s"$obj registered to number $number that is not part of a known or local number pool") {
def this(obj: IdentifiableEntity, number: Int, cause: Throwable) = {
this(obj, number)
initCause(cause)
}
}
/**
* A class for spawning `Actor`s to manage the number pools and
* create a number system operations class to access those pools within the context of registering and unregistering.
* This `Actor` persists to maintain the number pool `Actor`s.
* Note the `final` do-nothing `receive` method.
* This `Actor` should do __nothing__ through message passing.
* @see `UniqueNumberOps`
* @param hub the number pool management class
* @param poolActorConversionFunc the number pool management class
*/
class UniqueNumberSetup(
hub: NumberPoolHub,
poolActorConversionFunc: (ActorContext, NumberPoolHub) => Map[String, ActorRef]
) extends Actor {
init()
final def receive: Receive = { case _ => ; }
def init(): UniqueNumberOps = {
new UniqueNumberOps(hub, poolActorConversionFunc(context, hub))
}
}
object UniqueNumberSetup {
/**
* Transform `NumberPool`s into `NumberPoolActor`s and pair them with their name.
* @param poolSource where the raw `NumberPools` are located
* @param context used to create the `NumberPoolActor` instances
* @return a `Map` of the pool names to the `ActorRef` created from the `NumberPool`
*/
def AllocateNumberPoolActors(context: ActorContext, poolSource: NumberPoolHub): Map[String, ActorRef] = {
poolSource.Pools
.map { case (pname, pool) => (pname, context.actorOf(Props(classOf[NumberPoolActor], pool), pname)) }
.toMap
}
}

86
src/main/scala/net/psforever/objects/guid/actor/Register.scala
View file

@ -1,86 +0,0 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.guid.actor
import akka.actor.ActorRef
import net.psforever.objects.entity.IdentifiableEntity
/**
* A message for accepting object-number registration requests.<br>
* <br>
* The callback is actually an `ActorRef` to which a `RegisterSuccess` message or a `RegisterFailure` message is sent.
* This is as opposed to what a "callback" is normally - a function.
* @param obj the mandatory object
* @param name the optional name of the number pool to which this object is registered
* @param number the optional number pre-selected for registering this object
* @param callback the optional custom callback for the messages from the success or failure conditions
*/
final case class Register(
obj: IdentifiableEntity,
name: Option[String],
number: Option[Int],
callback: Option[ActorRef]
)
object Register {
/**
* Overloaded constructor, accepting just the object.
* @param obj the object to be registered
* @return a `Register` object
*/
def apply(obj: IdentifiableEntity): Register = {
new Register(obj, None, None, None)
}
/**
* Overloaded constructor, accepting the object and a callback.
* @param obj the object to be registered
* @param callback the custom callback for the messages from the success or failure conditions
* @return a `Register` object
*/
def apply(obj: IdentifiableEntity, callback: ActorRef): Register = {
new Register(obj, None, None, Some(callback))
}
/**
* Overloaded constructor, accepting an object and a pre-selected number.
* @param obj the object to be registered
* @param number the pre-selected number
* @return a `Register` object
*/
def apply(obj: IdentifiableEntity, number: Int): Register = {
new Register(obj, None, Some(number), None)
}
/**
* Overloaded constructor, accepting an object, a pre-selected number, and a callback.
* @param obj the object to be registered
* @param number the pre-selected number
* @param callback the custom callback for the messages from the success or failure conditions
* @return a `Register` object
*/
def apply(obj: IdentifiableEntity, number: Int, callback: ActorRef): Register = {
new Register(obj, None, Some(number), Some(callback))
}
/**
* Overloaded constructor, accepting an object and a number pool.
* @param obj the object to be registered
* @param name the number pool name
* @return a `Register` object
*/
def apply(obj: IdentifiableEntity, name: String): Register = {
new Register(obj, Some(name), None, None)
}
/**
* Overloaded constructor, accepting an object, a number pool, and a callback.
* @param obj the object to be registered
* @param name the number pool name
* @param callback the custom callback for the messages from the success or failure conditions
* @return a `Register` object
*/
def apply(obj: IdentifiableEntity, name: String, callback: ActorRef): Register = {
new Register(obj, Some(name), None, Some(callback))
}
}

348
src/main/scala/net/psforever/objects/guid/actor/UniqueNumberSystem.scala
View file

@ -1,348 +0,0 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.guid.actor
import akka.actor.{Actor, ActorContext, ActorRef, Props}
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.NumberPoolHub
import scala.util.{Failure, Success}
/**
* An `Actor` that wraps around converted `NumberPool`s and synchronizes a portion of the number registration process.
* The ultimate goal is to manage a coherent group of unique identifiers for a given "region" (`Zone`).
* Both parts of the UID system sit atop the `Zone` for easy external access.
* The plain part - the `NumberPoolHub` here - is used for low-priority requests such as checking for existing associations.
* This `Actor` is the involved portion that paces registration and unregistration.<br>
* <br>
* A four part process is used for object registration tasks.
* First, the requested `NumberPool` is located among the list of known `NumberPool`s.
* Second, an asynchronous request is sent to that pool to retrieve a number.
* (Only any number. Only a failing case allows for selection of a specific number.)
* Third, the asynchronous request returns and the original information about the request is recovered.
* Fourth, both sides of the contract are completed by the object being assigned the number and
* the underlying "number source" is made to remember an association between the object and the number.
* Short circuits and recoveries as available on all steps though reporting is split between logging and callbacks.
* The process of removing the association between a number and object (unregistering) is a similar four part process.<br>
* <br>
* The important relationship between this `Actor` and the `Map` of `NumberPoolActors` is an "gate."
* A single `Map` is constructed and shared between multiple entry points to the UID system where requests are messaged.
* Multiple entry points send messages to the same `NumberPool`.
* That `NumberPool` deals with the messages one at a time and sends reply to each entry point that communicated with it.
* This process is almost as fast as the process of the `NumberPool` selecting a number.
* (At least, both should be fast.)
* @param guid the `NumberPoolHub` that is partially manipulated by this `Actor`
* @param poolActors a common mapping created from the `NumberPool`s in `guid`;
* there is currently no check for this condition save for requests failing
*/
class UniqueNumberSystem(private val guid: NumberPoolHub, private val poolActors: Map[String, ActorRef]) extends Actor {
/** Information about Register and Unregister requests that persists between messages to a specific `NumberPool`. */
private val requestQueue: collection.mutable.LongMap[UniqueNumberSystem.GUIDRequest] =
new collection.mutable.LongMap()
/** The current value for the next request entry's index. */
private var index: Long = Long.MinValue
private[this] val log = org.log4s.getLogger
def receive: Receive = {
case Register(obj, Some(pname), None, call) =>
val callback = call.getOrElse(sender())
if (obj.HasGUID) {
AlreadyRegistered(obj, pname)
callback ! Success(obj)
} else {
val id: Long = index
index += 1
requestQueue += id -> UniqueNumberSystem.GUIDRequest(obj, pname, callback)
RegistrationProcess(pname, id)
}
//this message is automatically sent by NumberPoolActor
case NumberPoolActor.GiveNumber(number, id) =>
id match {
case Some(nid: Long) =>
RegistrationProcess(requestQueue.remove(nid), number, nid)
case _ =>
log.warn(s"received a number but there is no request to process it; returning number to pool")
NoCallbackReturnNumber(number) //recovery?
//no callback is possible
}
//this message is automatically sent by NumberPoolActor
case NumberPoolActor.NoNumber(ex, id) =>
id match {
case Some(nid: Long) =>
requestQueue.remove(nid) match {
case Some(entry) =>
entry.replyTo ! Failure(ex) //ONLY callback that is possible
case None => ;
log.warn(
s"failed number request and no record of number request - $ex"
) //neither a successful request nor an entry of making the request
}
case None => ;
log.warn(
s"failed number request and no record of number request - $ex"
) //neither a successful request nor an entry of making the request
case _ => ;
log.warn(s"unrecognized request $id accompanying a failed number request - $ex")
}
case Unregister(obj, call) =>
val callback = call.getOrElse(sender())
try {
val number = obj.GUID.guid
guid.WhichPool(number) match {
case Some(pname) =>
val id: Long = index
index += 1
requestQueue += id -> UniqueNumberSystem.GUIDRequest(obj, pname, callback)
UnregistrationProcess(pname, number, id)
case None =>
callback ! Failure(new Exception(s"the GUID of object $obj - $number - is not a part of this number pool"))
}
} catch {
case _: Exception =>
log.warn(s"$obj is already unregistered")
callback ! Success(obj)
}
//this message is automatically sent by NumberPoolActor
case NumberPoolActor.ReturnNumberResult(number, None, id) =>
id match {
case Some(nid: Long) =>
UnregistrationProcess(requestQueue.remove(nid), number, nid)
case _ =>
log.error(s"returned a number but there is no request to process it; recovering the number from pool")
NoCallbackGetSpecificNumber(number) //recovery?
//no callback is possible
}
//this message is automatically sent by NumberPoolActor
case NumberPoolActor.ReturnNumberResult(number, Some(ex), id) => //if there is a problem when returning the number
id match {
case Some(nid: Long) =>
requestQueue.remove(nid) match {
case Some(entry) =>
entry.replyTo ! Failure(new Exception(s"for ${entry.target} with number $number, ${ex.getMessage}"))
case None => ;
log.error(s"could not find original request $nid that caused error $ex, but pool was ${sender()}")
//no callback is possible
}
case _ => ;
log.error(s"could not find original request $id that caused error $ex, but pool was ${sender()}")
//no callback is possible
}
case msg =>
log.warn(s"unexpected message received - $msg")
}
/**
* A step of the object registration process.
* Send a message to the `NumberPool` to request a number back.
* @param poolName the pool to which the object is trying to register
* @param id a potential identifier to associate this request
*/
private def RegistrationProcess(poolName: String, id: Long): Unit = {
poolActors.get(poolName) match {
case Some(pool) =>
pool ! NumberPoolActor.GetAnyNumber(Some(id))
case None =>
//do not log; use callback
requestQueue.remove(id).get.replyTo ! Failure(
new Exception(s"can not find pool $poolName; nothing was registered")
)
}
}
/**
* A step of the object registration process.
* If there is a successful request object to be found, continue the registration request.
* @param request the original request data
* @param number the number that was drawn from a `NumberPool`
*/
private def RegistrationProcess(request: Option[UniqueNumberSystem.GUIDRequest], number: Int, id: Long): Unit = {
request match {
case Some(entry) =>
processRegisterResult(entry, number)
case None =>
log.error(s"returned a number but the rest of the request is missing (id:$id)")
if (id != Long.MinValue) { //check to ignore endless loop of error-catching
log.warn("returning number to pool")
NoCallbackReturnNumber(number) //recovery?
//no callback is possible
}
}
}
/**
* A step of the object registration process.
* This step completes the registration by asking the `NumberPoolHub` to sort out its `NumberSource`.
* @param entry the original request data
* @param number the number to use
*/
private def processRegisterResult(entry: UniqueNumberSystem.GUIDRequest, number: Int): Unit = {
val obj = entry.target
guid.latterPartRegister(obj, number) match {
case Success(_) =>
entry.replyTo ! Success(obj)
case Failure(ex) =>
//do not log; use callback
NoCallbackReturnNumber(number, entry.targetPool) //recovery?
entry.replyTo ! Failure(ex)
}
}
/**
* A step of the object unregistration process.
* Send a message to the `NumberPool` to restore the availability of one of its numbers.
* @param poolName the pool to which the number will try to be returned
* @param number the number that was previously drawn from the specified `NumberPool`
* @param id a potential identifier to associate this request
*/
private def UnregistrationProcess(poolName: String, number: Int, id: Long): Unit = {
poolActors.get(poolName) match {
case Some(pool) =>
pool ! NumberPoolActor.ReturnNumber(number, Some(id))
case None =>
//do not log; use callback
requestQueue.remove(id).get.replyTo ! Failure(
new Exception(s"can not find pool $poolName; nothing was de-registered")
)
}
}
/**
* A step of the object unregistration process.
* If there is a successful request object to be found, continue the registration request.
* @param request the original request data
* @param number the number that was drawn from the `NumberPool`
*/
private def UnregistrationProcess(request: Option[UniqueNumberSystem.GUIDRequest], number: Int, id: Long): Unit = {
request match {
case Some(entry) =>
processUnregisterResult(entry, number)
case None =>
log.error(s"returned a number but the rest of the request is missing (id:$id)")
if (id != Long.MinValue) { //check to ignore endless loop of error-catching
log.error("recovering the number from pool")
NoCallbackGetSpecificNumber(number) //recovery?
//no callback is possible
}
}
}
/**
* A step of the object unregistration process.
* This step completes revoking of the object's registration by consulting the `NumberSource`.
* @param entry the original request data
* @param number the number to use
*/
private def processUnregisterResult(entry: UniqueNumberSystem.GUIDRequest, number: Int): Unit = {
val obj = entry.target
guid.latterPartUnregister(number) match {
case Some(_) =>
obj.Invalidate()
entry.replyTo ! Success(obj)
case None =>
//do not log; use callback
NoCallbackGetSpecificNumber(number, entry.targetPool) //recovery?
entry.replyTo ! Failure(new Exception(s"failed to unregister a number; this may be a critical error"))
}
}
/**
* Generate a relevant logging message for an object that is trying to register is actually already registered.
* @param obj the object that was trying to register
* @param poolName the pool to which the object was trying to register
*/
private def AlreadyRegistered(obj: IdentifiableEntity, poolName: String): Unit = {
val msg =
guid.WhichPool(obj) match {
case Some(pname) =>
if (poolName.equals(pname)) {
s"to pool $poolName"
} else {
s"but to different pool $pname"
}
case None =>
"but not to any pool known to this system"
}
log.warn(s"$obj already registered $msg")
}
/**
* Access a specific `NumberPool` in a way that doesn't invoke a callback and reset one of its numbers.
* @param number the number that was drawn from a `NumberPool`
*/
private def NoCallbackReturnNumber(number: Int): Unit = {
guid.WhichPool(number) match {
case Some(pname) =>
NoCallbackReturnNumber(number, pname)
case None =>
log.error(s"critical: tried to return number $number but could not find containing pool")
}
}
/**
* Access a specific `NumberPool` in a way that doesn't invoke a callback and reset one of its numbers.
* To avoid fully processing the callback, an id of `Long.MinValue` is used to short circuit the routine.
* @param number the number that was drawn from a `NumberPool`
* @param poolName the `NumberPool` from which the `number` was drawn
* @see `UniqueNumberSystem.UnregistrationProcess(Option[GUIDRequest], Int, Int)`
*/
private def NoCallbackReturnNumber(number: Int, poolName: String): Unit = {
poolActors(poolName) ! NumberPoolActor.ReturnNumber(number, Some(Long.MinValue))
}
/**
* Access a specific `NumberPool` in a way that doesn't invoke a callback and claim one of its numbers.
* @param number the number to be drawn from a `NumberPool`
*/
private def NoCallbackGetSpecificNumber(number: Int): Unit = {
guid.WhichPool(number) match {
case Some(pname) =>
NoCallbackGetSpecificNumber(number, pname)
case None =>
log.error(s"critical: tried to re-register number $number but could not find containing pool")
}
}
/**
* Access a specific `NumberPool` in a way that doesn't invoke a callback and claim one of its numbers.
* To avoid fully processing the callback, an id of `Long.MinValue` is used to short circuit the routine.
* @param number the number to be drawn from a `NumberPool`
* @param poolName the `NumberPool` from which the `number` is to be drawn
* @see `UniqueNumberSystem.RegistrationProcess(Option[GUIDRequest], Int, Int)`
*/
private def NoCallbackGetSpecificNumber(number: Int, poolName: String): Unit = {
poolActors(poolName) ! NumberPoolActor.GetSpecificNumber(number, Some(Long.MinValue))
}
}
object UniqueNumberSystem {
/**
* Persistent record of the important information between the time fo request and the time of reply.
* @param target the object
* @param targetPool the name of the `NumberPool` being used
* @param replyTo the callback `ActorRef`
*/
private final case class GUIDRequest(target: IdentifiableEntity, targetPool: String, replyTo: ActorRef)
/**
* Transform `NumberPool`s into `NumberPoolActor`s and pair them with their name.
* @param poolSource where the raw `NumberPools` are located
* @param context used to create the `NumberPoolActor` instances
* @return a `Map` of the pool names to the `ActorRef` created from the `NumberPool`
*/
def AllocateNumberPoolActors(poolSource: NumberPoolHub)(implicit context: ActorContext): Map[String, ActorRef] = {
poolSource.Pools
.map({
case ((pname, pool)) =>
pname -> context.actorOf(Props(classOf[NumberPoolActor], pool), pname)
})
.toMap
}
}

23
src/main/scala/net/psforever/objects/guid/actor/Unregister.scala
View file

@ -1,23 +0,0 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.guid.actor
import akka.actor.ActorRef
import net.psforever.objects.entity.IdentifiableEntity
/**
* A message for accepting object-number unregistration requests.
* When given to a number pool (`NumberPoolAccessorActor`), that `Actor` assumes itself to have the object.
* When given to a hub object (`NumberPoolHubActor`), it will attempt to determine which pool currently has the object.<br>
* <br>
* The callback is actually an `ActorRef` to which a `RegisterSuccess` message or a `RegisterFailure` message is sent.
* This is as opposed to what a "callback" is normally - a function.
* @param obj the mandatory object
* @param callback the optional custom callback for the messages from the success or failure conditions
*/
final case class Unregister(obj: IdentifiableEntity, callback: Option[ActorRef] = None)
object Unregister {
def apply(obj: IdentifiableEntity, callback: ActorRef): Unregister = {
Unregister(obj, Some(callback))
}
}

19
src/main/scala/net/psforever/objects/guid/key/AvailabilityPolicy.scala Normal file
View file

@ -0,0 +1,19 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.guid.key
/**
* The availability of individual global unique identifier (GUID) keys is maintained by the given policy.
*/
sealed trait AvailabilityPolicy
object AvailabilityPolicy {
/**An `Available` key is ready and waiting to be `Leased` for use. */
case object Available extends AvailabilityPolicy
/** A `Leased` key has been issued and is currently being used for some purpose.*/
case object Leased extends AvailabilityPolicy
/** A `Dangling` key ia a unique sort of key that has been `Leased` but has not yet been applied for any specific purpose.
* As a policy, it should be used as a status to check but should not be designated on any key. */
case object Dangling extends AvailabilityPolicy
}

7
src/main/scala/net/psforever/objects/guid/key/LoanedKey.scala
View file

@ -2,7 +2,6 @@
package net.psforever.objects.guid.key
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.AvailabilityPolicy
/**
* The only indirect public access a queued number monitor object (`Key`) is allowed.
@ -12,7 +11,7 @@ import net.psforever.objects.guid.AvailabilityPolicy
class LoanedKey(private val guid: Int, private val key: Monitor) {
def GUID: Int = guid
def Policy: AvailabilityPolicy.Value = key.policy
def Policy: AvailabilityPolicy = key.policy
def Object: Option[IdentifiableEntity] = key.obj
@ -29,9 +28,7 @@ class LoanedKey(private val guid: Int, private val key: Monitor) {
* @return `true`, if the assignment worked; `false`, otherwise
*/
def Object_=(obj: Option[IdentifiableEntity]): Option[IdentifiableEntity] = {
if (
key.policy == AvailabilityPolicy.Leased || (key.policy == AvailabilityPolicy.Restricted && key.obj.isEmpty)
) {
if (key.policy == AvailabilityPolicy.Leased) {
if (key.obj.isDefined) {
key.obj.get.Invalidate()
key.obj = None

3
src/main/scala/net/psforever/objects/guid/key/Monitor.scala
View file

@ -2,10 +2,9 @@
package net.psforever.objects.guid.key
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.AvailabilityPolicy
trait Monitor {
var policy: AvailabilityPolicy.Value
var policy: AvailabilityPolicy
var obj: Option[IdentifiableEntity]
}

4
src/main/scala/net/psforever/objects/guid/key/SecureKey.scala
View file

@ -1,8 +1,6 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.guid.key
import net.psforever.objects.guid.AvailabilityPolicy
/**
* An unmodifiable reference to an active number monitor object (`Key`).
* @param guid the number (globally unique identifier)
@ -11,7 +9,7 @@ import net.psforever.objects.guid.AvailabilityPolicy
final class SecureKey(private val guid: Int, private val key: Monitor) {
def GUID: Int = guid
def Policy: AvailabilityPolicy.Value = key.policy
def Policy: AvailabilityPolicy = key.policy
import net.psforever.objects.entity.IdentifiableEntity
def Object: Option[IdentifiableEntity] = key.obj

69
src/main/scala/net/psforever/objects/guid/pool/GenericPool.scala
View file

@ -6,8 +6,13 @@ import net.psforever.objects.guid.selector.{NumberSelector, SpecificSelector}
import scala.collection.mutable
import scala.util.{Failure, Success, Try}
class GenericPool(private val hub: mutable.LongMap[String], private val max: Int) extends NumberPool {
val numbers: mutable.ListBuffer[Int] = mutable.ListBuffer[Int]()
class GenericPool(
private val hub: mutable.LongMap[String],
private val max: Int,
private val poolName: String,
private val selectionFunc: (List[Long], Int) => Int
) extends NumberPool {
private val numbers: mutable.ListBuffer[Int] = mutable.ListBuffer[Int]()
private val selector: SpecificSelector = new SpecificSelector
selector.SelectionIndex = -1
@ -17,22 +22,26 @@ class GenericPool(private val hub: mutable.LongMap[String], private val max: Int
def Selector: NumberSelector = selector
def Selector_=(slctr: NumberSelector): Unit = {} //intentionally blank
def Selector_=(slctr: NumberSelector): Unit = { /* intentionally blank */ }
def Get(): Try[Int] = {
val specific = selector.SelectionIndex
selector.SelectionIndex = -1 //clear
if (specific == -1) {
val number = GenericPool.rand(hub.keys.toList, max)
hub += number.toLong -> "generic"
numbers += number
Success(number)
val number = selectionFunc(hub.keys.toList, max)
if (number > -1) {
hub += number.toLong -> poolName
numbers += number
Success(number)
} else {
Failure(new Exception("no numbers available in this pool"))
}
} else if (hub.get(specific).isEmpty) {
hub += specific.toLong -> "generic"
hub += specific.toLong -> poolName
numbers += specific
Success(specific)
} else {
Failure(new Exception("selector was not initialized properly, or no numbers available in the pool"))
Failure(new Exception("selector may not have been initialized properly"))
}
}
@ -49,6 +58,43 @@ class GenericPool(private val hub: mutable.LongMap[String], private val max: Int
}
object GenericPool {
/**
* Overloaded constructor that assigns a "numerical first discovery" function for number selection.
* @param hub na
* @param max na
* @param poolName na
* @return a `GenericPool` entity
*/
def apply(
hub: mutable.LongMap[String],
max: Int,
poolName: String
): GenericPool =
new GenericPool(hub, max, poolName, GenericPool.first)
/**
* Get some number that is not accounted for in any other fixed pool, making it available in this generic one.<br>
* <br>
* Returns the first number that is detected as available between two sorted numbers.
* @param list all of the non-repeating numbers to be compared
* @param domainSize how many numbers can be supported
* @return the next available number, or -1
*/
def first(list: List[Long], domainSize: Int): Int = {
if (list.size < domainSize) {
val sortedList: List[Long] = 0L +: list.sorted :+ domainSize
var index: Int = 0
val listLen = sortedList.length - 1
while(index < listLen && index < domainSize) {
val curr = sortedList(index + 1) - sortedList(index)
if (curr > 1) {
return sortedList(index).toInt + 1
}
index += 1
}
}
-1
}
/**
* Get some number that is not accounted for in any other fixed pool, making it available in this generic one.<br>
@ -63,7 +109,7 @@ object GenericPool {
* @param domainSize how many numbers can be supported
* @return midpoint of the largest distance between any two of the existing numbers, or -1
*/
private def rand(list: List[Long], domainSize: Int): Int = {
def rand(list: List[Long], domainSize: Int): Int = {
if (list.size < domainSize) {
//get a list of all assigned numbers with an appended min and max
val sortedList: List[Long] = -1L +: list.sorted :+ domainSize.toLong
@ -78,7 +124,8 @@ object GenericPool {
}
}
//find half of the distance between the two numbers with the greatest delta value
if (maxDelta > 1) { ((sortedList(maxDeltaIndex + 1) + sortedList(maxDeltaIndex)) / 2f).toInt }
if (maxDelta == 2) { sortedList(maxDeltaIndex).toInt + 1 }
else if (maxDelta > 1) { ((sortedList(maxDeltaIndex + 1) + sortedList(maxDeltaIndex)) / 2f).toInt }
else { -1 }
} else {
-1

5
src/main/scala/net/psforever/objects/guid/source/Key.scala
View file

@ -2,11 +2,10 @@
package net.psforever.objects.guid.source
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.AvailabilityPolicy
import net.psforever.objects.guid.key.Monitor
import net.psforever.objects.guid.key.{AvailabilityPolicy, Monitor}
private class Key extends Monitor {
var policy: AvailabilityPolicy.Value = AvailabilityPolicy.Available
var policy: AvailabilityPolicy = AvailabilityPolicy.Available
var obj: Option[IdentifiableEntity] = None
}

49
src/main/scala/net/psforever/objects/guid/source/MaxNumberSource.scala
View file

@ -2,8 +2,7 @@
package net.psforever.objects.guid.source
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.key.{LoanedKey, SecureKey}
import net.psforever.objects.guid.AvailabilityPolicy
import net.psforever.objects.guid.key.{AvailabilityPolicy, LoanedKey, SecureKey}
/**
* A `NumberSource` is considered a master "pool" of numbers from which all numbers are available to be drawn.
@ -18,13 +17,14 @@ class MaxNumberSource(val max: Int) extends NumberSource {
}
private val ary: Array[Key] = Array.ofDim[Key](max + 1)
(0 to max).foreach(x => { ary(x) = new Key })
private var allowRestrictions: Boolean = true
def size: Int = ary.length
def countAvailable: Int = ary.count(key => key.policy == AvailabilityPolicy.Available)
def countAvailable: Int = ary.count { _.policy == AvailabilityPolicy.Available }
def countUsed: Int = ary.count(_.policy != AvailabilityPolicy.Available)
def countUsed: Int = ary.count { _.policy == AvailabilityPolicy.Leased }
def countDangling: Int = ary.count { key => key.policy == AvailabilityPolicy.Leased && key.obj.isEmpty }
def test(number: Int): Boolean = -1 < number && number < size
@ -78,39 +78,14 @@ class MaxNumberSource(val max: Int) extends NumberSource {
out
}
/**
* Produce a modifiable wrapper for the `Monitor` for this number, only if the number has not been used.
* This wrapped `Monitor` can only be assigned once and the number may not be `returnNumber`ed to this source.
* @param number the number
* @return the wrapped `Monitor`
* @throws ArrayIndexOutOfBoundsException if the requested number is above or below the range
*/
def restrictNumber(number: Int): Option[LoanedKey] = {
ary.lift(number) match {
case Some(key: Key) if allowRestrictions && key.policy != AvailabilityPolicy.Restricted =>
key.policy = AvailabilityPolicy.Restricted
Some(new LoanedKey(number, key))
case _ =>
None
}
}
def finalizeRestrictions: List[Int] = {
allowRestrictions = false
ary.zipWithIndex.filter(entry => entry._1.policy == AvailabilityPolicy.Restricted).map(entry => entry._2).toList
}
def clear(): List[IdentifiableEntity] = {
val leased = ary.filter(_.policy != AvailabilityPolicy.Available)
leased collect { case key if key.obj.isEmpty =>
key.policy = AvailabilityPolicy.Available
}
leased.toList collect { case key if key.obj.nonEmpty =>
key.policy = AvailabilityPolicy.Available
val out = key.obj.get
key.obj = None
out
}
ary.foreach { _.policy = AvailabilityPolicy.Available }
ary.collect {
case key if key.obj.nonEmpty =>
val obj = key.obj.get
key.obj = None
obj
}.toList
}
}

40
src/main/scala/net/psforever/objects/guid/source/NumberSource.scala
View file

@ -2,7 +2,7 @@
package net.psforever.objects.guid.source
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.key.{LoanedKey, SecureKey}
import net.psforever.objects.guid.key.{AvailabilityPolicy, LoanedKey, SecureKey}
/**
* A `NumberSource` is considered a master "pool" of numbers from which all numbers are available to be drawn.
@ -30,6 +30,20 @@ trait NumberSource {
*/
def size: Int
/**
* Select the type of count desired based on the allocation policy of the key.
* @param policy the allocation policy
* @return the number of keys belonging to this policy
*/
def count(policy: AvailabilityPolicy): Int = {
policy match {
case AvailabilityPolicy.Available => countAvailable
case AvailabilityPolicy.Leased => countUsed
case AvailabilityPolicy.Dangling => countDangling
}
}
/**
* The count of numbers that can still be drawn.
* @return the count
@ -42,6 +56,13 @@ trait NumberSource {
*/
def countUsed: Int
/**
* The count of numbers that can not be drawn but have not yet been assigned to an entity.
* Could only ever be a non-zero count if the number of used keys is a non-zero count.
* @return the count
*/
def countDangling: Int
/**
* Is this number a member of this number source?
* @param number the number
@ -97,26 +118,9 @@ trait NumberSource {
*/
def returnNumber(number: Int): Option[IdentifiableEntity]
/**
* Produce a modifiable wrapper for the `Monitor` for this number, only if the number has not been used.
* This wrapped `Monitor` can only be assigned once and the number may not be `returnNumber`ed to this source.
* @param number the number
* @return the wrapped `Monitor`
*/
def restrictNumber(number: Int): Option[LoanedKey]
/**
* Numbers from this source may not longer be marked as `Restricted`.
* @return the `List` of all numbers that have been restricted
*/
def finalizeRestrictions: List[Int]
import net.psforever.objects.entity.IdentifiableEntity
/**
* Reset all number `Monitor`s so that their underlying number is not longer treated as assigned.
* Perform some level of housecleaning to ensure that all dependencies are resolved in some manner.
* This is the only way to free `Monitors` that are marked as `Restricted`.
* @return a `List` of assignments maintained by all the currently-used number `Monitors`
*/
def clear(): List[IdentifiableEntity]

43
src/main/scala/net/psforever/objects/guid/source/SpecificNumberSource.scala
View file

@ -2,8 +2,7 @@
package net.psforever.objects.guid.source
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.AvailabilityPolicy
import net.psforever.objects.guid.key.{LoanedKey, SecureKey}
import net.psforever.objects.guid.key.{AvailabilityPolicy, LoanedKey, SecureKey}
/**
* A `NumberSource` is considered a master "pool" of numbers from which all numbers are available to be drawn.
@ -27,9 +26,11 @@ class SpecificNumberSource(values: Iterable[Int]) extends NumberSource {
def size : Int = ary.size
def countAvailable : Int = ary.values.count(key => key.policy == AvailabilityPolicy.Available)
def countAvailable : Int = ary.values.count { _.policy == AvailabilityPolicy.Available }
def countUsed : Int = ary.values.count(_.policy != AvailabilityPolicy.Available)
def countUsed : Int = ary.values.count { _.policy == AvailabilityPolicy.Leased }
def countDangling: Int = ary.values.count { key => key.policy == AvailabilityPolicy.Leased && key.obj.isEmpty }
def test(number : Int) : Boolean = ary.get(number).nonEmpty
@ -74,34 +75,14 @@ class SpecificNumberSource(values: Iterable[Int]) extends NumberSource {
}
}
def restrictNumber(number : Int) : Option[LoanedKey] = {
ary.get(number) match {
case Some(key) if key.policy != AvailabilityPolicy.Restricted =>
key.policy = AvailabilityPolicy.Restricted
Some(new LoanedKey(number, key))
case _ =>
None
}
}
def finalizeRestrictions : List[Int] = {
ary
.filter { case (_, key : Key) => key.policy == AvailabilityPolicy.Restricted }
.keys
.toList
}
def clear(): List[IdentifiableEntity] = {
val leased = ary.values.filter(_.policy != AvailabilityPolicy.Available)
leased collect { case key if key.obj.isEmpty =>
key.policy = AvailabilityPolicy.Available
}
leased.toList collect { case key if key.obj.nonEmpty =>
key.policy = AvailabilityPolicy.Available
val out = key.obj.get
key.obj = None
out
}
ary.values.foreach { _.policy = AvailabilityPolicy.Available }
ary.values.collect {
case key if key.obj.nonEmpty =>
val obj = key.obj.get
key.obj = None
obj
}.toList
}
}

38
src/main/scala/net/psforever/objects/guid/actor/NumberPoolActor.scala → src/main/scala/net/psforever/objects/guid/uns/NumberPoolActor.scala
View file

@ -1,5 +1,5 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.guid.actor
package net.psforever.objects.guid.uns
import akka.actor.Actor
import net.psforever.objects.guid.pool.NumberPool
@ -21,27 +21,27 @@ class NumberPoolActor(pool: NumberPool) extends Actor {
private[this] val log = org.log4s.getLogger
def receive: Receive = {
case NumberPoolActor.GetAnyNumber(id) =>
case NumberPoolActor.GetAnyNumber() =>
sender() ! (pool.Get() match {
case Success(value) =>
NumberPoolActor.GiveNumber(value, id)
case Failure(ex) => ;
NumberPoolActor.NoNumber(ex, id)
NumberPoolActor.GiveNumber(value)
case Failure(ex) =>
NumberPoolActor.NoNumber(ex)
})
case NumberPoolActor.GetSpecificNumber(number, id) =>
case NumberPoolActor.GetSpecificNumber(number) =>
sender() ! (NumberPoolActor.GetSpecificNumber(pool, number) match {
case Success(value) =>
NumberPoolActor.GiveNumber(value, id)
NumberPoolActor.GiveNumber(value)
case Failure(ex) => ;
NumberPoolActor.NoNumber(ex, id)
NumberPoolActor.NoNumber(ex)
})
case NumberPoolActor.ReturnNumber(number, id) =>
case NumberPoolActor.ReturnNumber(number) =>
val result = pool.Return(number)
val ex: Option[Throwable] = if (!result) { Some(new Exception("number was not returned")) }
else { None }
sender() ! NumberPoolActor.ReturnNumberResult(number, ex, id)
sender() ! NumberPoolActor.ReturnNumberResult(number, ex)
case msg =>
log.warn(s"Received an unexpected message - ${msg.toString}")
@ -52,36 +52,36 @@ object NumberPoolActor {
/**
* A message to invoke the current `NumberSelector`'s functionality.
* @param id a potential identifier to associate this request
*/
final case class GetAnyNumber(id: Option[Any] = None)
final case class GetAnyNumber()
/**
* A message to invoke a `SpecificSelector` to acquire the specific `number`, if it is available in this pool.
* @param number the pre-selected number
* @param id a potential identifier to associate this request
*/
final case class GetSpecificNumber(number: Int, id: Option[Any] = None)
final case class GetSpecificNumber(number: Int)
/**
* A message to distribute the `number` that was drawn.
* @param number the pre-selected number
* @param id a potential identifier to associate this request
*/
final case class GiveNumber(number: Int, id: Option[Any] = None)
final case class GiveNumber(number: Int)
final case class NoNumber(ex: Throwable, id: Option[Any] = None)
final case class NoNumber(ex: Throwable)
/**
* A message to invoke the `returnNumber` functionality of the current `NumberSelector`.
* @param number the number
*/
final case class ReturnNumber(number: Int, id: Option[Any] = None)
final case class ReturnNumber(number: Int)
final case class ReturnNumberResult(number: Int, ex: Option[Throwable], id: Option[Any] = None)
final case class ReturnNumberResult(number: Int, ex: Option[Throwable])
/**
* Use the `SpecificSelector` on this pool to extract a specific object from the pool, if it is included and available.
* Getting a specific number involves creating the appropriate selector and swapping with the current selector.
* This process may involve re-formatting the underlying number pool array once for each selector.
* @see `NumberSelector.Format`
* @param pool the `NumberPool` to draw from
* @param number the number requested
* @return the number requested, or an error

14
src/main/scala/net/psforever/objects/guid/uns/RegisteredEntity.scala Normal file
View file

@ -0,0 +1,14 @@
// Copyright (c) 2021 PSForever
package net.psforever.objects.guid.uns
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.NumberPoolHub
final case class RegisteredEntity(
obj: IdentifiableEntity,
pool_name: String,
guid_system: NumberPoolHub,
number: Int
)
final case class AlreadyRegisteredEntity(msg: RegisteredEntity)

14
src/main/scala/net/psforever/objects/guid/uns/UnregisteredEntity.scala Normal file
View file

@ -0,0 +1,14 @@
// Copyright (c) 2021 PSForever
package net.psforever.objects.guid.uns
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.NumberPoolHub
final case class UnregisteredEntity(
obj: IdentifiableEntity,
pool_name: String,
guid_system: NumberPoolHub,
number: Int
)
final case class AlreadyUnregisteredEntity(msg: UnregisteredEntity)

17
src/main/scala/net/psforever/objects/locker/LockerContainerDefinition.scala Normal file
View file

@ -0,0 +1,17 @@
// Copyright (c) 2021 PSForever
package net.psforever.objects.locker
import net.psforever.objects.definition.EquipmentDefinition
import net.psforever.objects.definition.converter.LockerContainerConverter
import net.psforever.objects.equipment.EquipmentSize
class LockerContainerDefinition extends EquipmentDefinition(objectId = 456) {
Name = "locker_container"
Size = EquipmentSize.Inventory
Packet = LockerContainerDefinition.converter
registerAs = "lockers"
}
object LockerContainerDefinition {
val converter = new LockerContainerConverter()
}

4
src/main/scala/net/psforever/objects/serverobject/pad/VehicleSpawnControl.scala
View file

@ -4,7 +4,7 @@ package net.psforever.objects.serverobject.pad
import akka.actor.{Cancellable, Props}
import net.psforever.objects.avatar.SpecialCarry
import net.psforever.objects.entity.WorldEntity
import net.psforever.objects.guid.GUIDTask.UnregisterVehicle
import net.psforever.objects.guid.{GUIDTask, TaskWorkflow}
import net.psforever.objects.serverobject.affinity.{FactionAffinity, FactionAffinityBehavior}
import net.psforever.objects.serverobject.pad.process.{VehicleSpawnControlBase, VehicleSpawnControlConcealPlayer}
import net.psforever.objects.zones.{Zone, ZoneAware, Zoning}
@ -516,7 +516,7 @@ object VehicleSpawnControl {
if (zone.Vehicles.contains(vehicle)) { //already added to zone
vehicle.Actor ! Vehicle.Deconstruct(Some(0.seconds))
} else { //just registered to zone
zone.tasks ! UnregisterVehicle(vehicle)(zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterVehicle(zone.GUID, vehicle))
}
}
}

34
src/main/scala/net/psforever/objects/serverobject/shuttle/OrbitalShuttlePadControl.scala
View file

@ -2,7 +2,7 @@
package net.psforever.objects.serverobject.shuttle
import akka.actor.{Actor, ActorRef}
import net.psforever.objects.guid.{GUIDTask, Task, TaskResolver}
import net.psforever.objects.guid._
import net.psforever.objects.{Player, Vehicle}
import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.objects.serverobject.doors.Door
@ -14,7 +14,7 @@ import net.psforever.services.hart.{HartTimer, HartTimerActions}
import net.psforever.services.{Service, ServiceManager}
import net.psforever.types.ChatMessageType
import scala.util.Success
import scala.concurrent.Future
/**
* An `Actor` that handles messages being dispatched to a specific `OrbitalShuttlePad`.<br>
@ -114,7 +114,7 @@ class OrbitalShuttlePadControl(pad: OrbitalShuttlePad) extends Actor {
newShuttle.Position = position + Vector3(0, -8.25f, 0).Rz(pad.Orientation.z) //magic offset number
newShuttle.Orientation = pad.Orientation
newShuttle.Faction = pad.Faction
zone.tasks ! OrbitalShuttlePadControl.registerShuttle(zone, newShuttle, self)
TaskWorkflow.execute(OrbitalShuttlePadControl.registerShuttle(zone, newShuttle, self))
context.become(shuttleTime)
case _ => ;
@ -127,33 +127,23 @@ object OrbitalShuttlePadControl {
* @param zone the zone the shuttle and the pad will occupy
* @param shuttle the vehicle that will be the shuttle
* @param ref a reference to the control agency for the orbital shuttle pad
* @return a `TaskResolver.GiveTask` object
* @return a `TaskBundle` object
*/
def registerShuttle(zone: Zone, shuttle: Vehicle, ref: ActorRef): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
def registerShuttle(zone: Zone, shuttle: Vehicle, ref: ActorRef): TaskBundle = {
import scala.concurrent.ExecutionContext.Implicits.global
TaskBundle(
new StraightforwardTask() {
private val localZone = zone
private val localShuttle = shuttle
private val localSelf = ref
override def Description: String = s"register an orbital shuttle"
override def description(): String = s"register an orbital shuttle"
override def isComplete : Task.Resolution.Value = if (localShuttle.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
def Execute(resolver : ActorRef) : Unit = {
def action() : Future[Any] = {
localZone.Transport.tell(Zone.Vehicle.Spawn(localShuttle), localSelf)
resolver ! Success(true)
Future(this)
}
override def onFailure(ex : Throwable) : Unit = {
super.onFailure(ex)
localSelf ! Zone.Vehicle.CanNotSpawn(localZone, localShuttle, ex.getMessage)
}
}, List(GUIDTask.RegisterVehicle(shuttle)(zone.GUID))
}, GUIDTask.registerVehicle(zone.GUID, shuttle)
)
}

1
src/main/scala/net/psforever/objects/serverobject/terminals/TerminalDefinition.scala
View file

@ -13,6 +13,7 @@ import net.psforever.objects.serverobject.structures.AmenityDefinition
abstract class TerminalDefinition(objectId: Int) extends AmenityDefinition(objectId) {
Name = "terminal"
Packet = new TerminalConverter
registerAs = "terminals"
/**
* The unimplemented functionality for the entry function of form of activity

1
src/main/scala/net/psforever/objects/serverobject/tube/SpawnTubeDefinition.scala
View file

@ -12,6 +12,7 @@ import net.psforever.objects.serverobject.structures.{Amenity, AmenityDefinition
*/
class SpawnTubeDefinition(object_id: Int) extends AmenityDefinition(object_id) with SpawnPointDefinition {
Packet = new SpawnTubeConverter
registerAs = "terminals"
}
object SpawnTubeDefinition {

1
src/main/scala/net/psforever/objects/vehicles/Utility.scala
View file

@ -228,6 +228,7 @@ object Utility {
extends AmenityDefinition(DeployedItem.router_telepad_deployable.id)
with BaseDeployableDefinition {
Packet = new SmallDeployableConverter
registerAs = "terminals"
def Item: DeployedItem.Value = DeployedItem.router_telepad_deployable
}

4
src/main/scala/net/psforever/objects/vehicles/control/VehicleControl.scala
View file

@ -7,7 +7,7 @@ import net.psforever.objects._
import net.psforever.objects.ballistics.VehicleSource
import net.psforever.objects.entity.WorldEntity
import net.psforever.objects.equipment.{Equipment, EquipmentSlot, JammableMountedWeapons}
import net.psforever.objects.guid.GUIDTask
import net.psforever.objects.guid.{GUIDTask, TaskWorkflow}
import net.psforever.objects.inventory.{GridInventory, InventoryItem}
import net.psforever.objects.serverobject.{CommonMessages, PlanetSideServerObject}
import net.psforever.objects.serverobject.affinity.{FactionAffinity, FactionAffinityBehavior}
@ -407,7 +407,7 @@ class VehicleControl(vehicle: Vehicle)
CancelJammeredSound(vehicle)
CancelJammeredStatus(vehicle)
//unregister
zone.tasks ! GUIDTask.UnregisterVehicle(vehicle)(zone.GUID)
TaskWorkflow.execute(GUIDTask.unregisterVehicle(zone.GUID, vehicle))
//banished to the shadow realm
vehicle.Position = Vector3.Zero
//queue final deletion

112
src/main/scala/net/psforever/objects/zones/Zone.scala
View file

@ -2,16 +2,12 @@
package net.psforever.objects.zones
import akka.actor.{ActorContext, ActorRef, Props}
import akka.routing.RandomPool
import net.psforever.objects.{PlanetSideGameObject, _}
import net.psforever.objects.ballistics.{Projectile, SourceEntry}
import net.psforever.objects.ballistics.SourceEntry
import net.psforever.objects.ce.Deployable
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.equipment.Equipment
import net.psforever.objects.guid.{NumberPoolHub, TaskResolver}
import net.psforever.objects.guid.actor.UniqueNumberSystem
import net.psforever.objects.guid.{NumberPoolHub, UniqueNumberOps, UniqueNumberSetup}
import net.psforever.objects.guid.key.LoanedKey
import net.psforever.objects.guid.selector.RandomSelector
import net.psforever.objects.guid.source.MaxNumberSource
import net.psforever.objects.inventory.Container
import net.psforever.objects.serverobject.painbox.{Painbox, PainboxDefinition}
@ -39,6 +35,7 @@ import net.psforever.actors.session.AvatarActor
import net.psforever.actors.zone.ZoneActor
import net.psforever.objects.avatar.Avatar
import net.psforever.objects.geometry.d3.VolumetricGeometry
import net.psforever.objects.guid.pool.NumberPool
import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.objects.serverobject.affinity.FactionAffinity
import net.psforever.objects.serverobject.doors.Door
@ -79,14 +76,16 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
/** Governs general synchronized external requests. */
var actor: typed.ActorRef[ZoneActor.Command] = _
/** Actor that handles SOI related functionality, for example if a player is in a SOI */
/** Actor that handles SOI related functionality, for example if a player is in an SOI */
private var soi = Default.Actor
/** Used by the globally unique identifier system to coordinate requests. */
private var accessor: ActorRef = ActorRef.noSender
/** The basic support structure for the globally unique number system used by this `Zone`. */
private var guid: NumberPoolHub = new NumberPoolHub(new MaxNumberSource(65536))
/** The core of the unique number system, to which requests may be submitted.
* @see `UniqueNumberSys`
* @see `Zone.Init(ActorContext)`
*/
private[zones] var unops: UniqueNumberOps = _
/** The blockmap structure for partitioning entities and environmental aspects of the zone.
* For a standard 8912`^`2 map, each of the four hundred formal map grids is 445.6m long and wide.
@ -105,8 +104,6 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
/** Used by the `Zone` to coordinate `Equipment` dropping and collection requests. */
private var ground: ActorRef = Default.Actor
private var taskResolver: ActorRef = Default.Actor
/**
*/
private val constructions: ListBuffer[Deployable] = ListBuffer()
@ -177,7 +174,7 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
* First, the `Actor`-driven aspect of the globally unique identifier system for this `Zone` is finalized.
* Second, all supporting `Actor` agents are created, e.g., `ground`.
* Third, the `ZoneMap` server objects are loaded and constructed within that aforementioned system.
* To avoid being called more than once, there is a test whether the `accessor` for the globally unique identifier system has been changed.<br>
* To avoid being called more than once, there is a test whether the globally unique identifier system has been changed.<br>
* <br>
* Execution of this operation should be fail-safe.
* The chances of failure should be mitigated or skipped.
@ -187,15 +184,9 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
* @param context a reference to an `ActorContext` necessary for `Props`
*/
def init(implicit context: ActorContext): Unit = {
if (accessor == ActorRef.noSender) {
if (unops == null) {
SetupNumberPools()
taskResolver = CreateTaskResolvers(context)
accessor = context.actorOf(
RandomPool(25).props(
Props(classOf[UniqueNumberSystem], this.guid, UniqueNumberSystem.AllocateNumberPoolActors(this.guid))
),
s"zone-$id-uns"
)
context.actorOf(Props(classOf[UniqueNumberSys], this, this.guid), s"zone-$id-uns")
ground = context.actorOf(Props(classOf[ZoneGroundActor], this, equipmentOnGround), s"zone-$id-ground")
deployables = context.actorOf(Props(classOf[ZoneDeployableActor], this, constructions), s"zone-$id-deployables")
transport = context.actorOf(Props(classOf[ZoneVehicleActor], this, vehicles), s"zone-$id-vehicles")
@ -334,26 +325,7 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
}
}
def SetupNumberPools(): Unit = {
guid.AddPool("environment", (0 to 3000).toList) //TODO tailor to suit requirements of zone
//TODO unlump pools later; do not make any single pool too big
guid.AddPool("dynamic", (3001 to 10000).toList).Selector =
new RandomSelector //TODO all things will be registered here, for now
guid.AddPool("b", (10001 to 15000).toList).Selector = new RandomSelector
guid.AddPool("c", (15001 to 20000).toList).Selector = new RandomSelector
guid.AddPool("d", (20001 to 25000).toList).Selector = new RandomSelector
guid.AddPool("e", (25001 to 30000).toList).Selector = new RandomSelector
guid.AddPool("f", (30001 to 35000).toList).Selector = new RandomSelector
guid.AddPool("g", (35001 until 40100).toList).Selector = new RandomSelector
guid.AddPool("projectiles", (Projectile.baseUID until Projectile.rangeUID).toList)
guid.AddPool("locker-contents", (40150 until 40450).toList).Selector = new RandomSelector
//TODO disabled temporarily to lighten load times
//guid.AddPool("h", (40150 to 45000).toList).Selector = new RandomSelector
//guid.AddPool("i", (45001 to 50000).toList).Selector = new RandomSelector
//guid.AddPool("j", (50001 to 55000).toList).Selector = new RandomSelector
//guid.AddPool("k", (55001 to 60000).toList).Selector = new RandomSelector
//guid.AddPool("l", (60001 to 65535).toList).Selector = new RandomSelector
}
def SetupNumberPools(): Unit = { /* override to tailor to suit requirements of zone */ }
def findSpawns(
faction: PlanetSideEmpire.Value,
@ -436,14 +408,14 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
def Number: Int = zoneNumber
/**
* The globally unique identifier system is synchronized via an `Actor` to ensure that concurrent requests do not clash.
* The globally unique identifier system ensures that concurrent requests do not clash.
* A clash is merely when the same number is produced more than once by the same system due to concurrent requests.
* @return synchronized reference to the globally unique identifier system
* @return reference to the globally unique identifier system
*/
def GUID: ActorRef = accessor
def GUID: UniqueNumberOps = unops
/**
* Replace the current globally unique identifier system with a new one.
* Replace the current globally unique identifier support structure with a new one.
* The replacement will not occur if the current system is populated or if its synchronized reference has been created.
* The primary use of this function should be testing.
* A warning will be issued.
@ -475,12 +447,14 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
* @return `true`, if the new pool is created;
* `false`, if the new pool can not be created because the system has already been started
*/
def AddPool(name: String, pool: Seq[Int]): Boolean = {
if (accessor == Default.Actor || accessor == null) {
guid.AddPool(name, pool.toList)
true
def AddPool(name: String, pool: Seq[Int]): Option[NumberPool] = {
if (unops == null) {
guid.AddPool(name, pool.toList) match {
case _: Exception => None
case out => Some(out)
}
} else {
false
None
}
}
@ -489,13 +463,12 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
* Throws exceptions for specific reasons if the pool can not be removed before the system has been started.
* @see `NumberPoolHub.RemovePool`
* @param name the name of the pool
* @return `true`, if the new pool is un-made;
* `false`, if the new pool can not be removed because the system has already been started
* @return `true`, if the pool is un-made;
* `false`, if the pool can not be removed (because the system has already been started?)
*/
def RemovePool(name: String): Boolean = {
if (accessor == Default.Actor) {
guid.RemovePool(name)
true
if (unops == null) {
guid.RemovePool(name).nonEmpty
} else {
false
}
@ -526,7 +499,7 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
/**
* Recover an object from the globally unique identifier system by the number that was assigned previously.
* The object must be upcast into due to the differtence between the storage type and the return type.
* The object must be upcast into due to the minor difference between the storage type and the return type.
* @param object_guid the globally unique identifier requested
* @return the associated object, if it exists
* @see `NumberPoolHub(Int)`
@ -606,7 +579,7 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
private def BuildSupportObjects(): Unit = {
//guard against errors here, but don't worry about specifics; let ZoneActor.ZoneSetupCheck complain about problems
val other: ListBuffer[IdentifiableEntity] = new ListBuffer[IdentifiableEntity]()
val other: ListBuffer[PlanetSideGameObject] = new ListBuffer[PlanetSideGameObject]()
//turret to weapon
map.turretToWeapon.foreach({
case (turret_guid, weapon_guid) =>
@ -634,7 +607,7 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
}
})
//after all fixed GUID's are defined ...
other.foreach(obj => guid.register(obj, "dynamic"))
other.foreach(obj => guid.register(obj, obj.Definition.registerAs))
}
private def MakeBuildings(implicit context: ActorContext): PairMap[Int, Building] = {
@ -836,11 +809,26 @@ class Zone(val id: String, val map: ZoneMap, zoneNumber: Int) {
vehicleEvents = bus
VehicleEvents
}
}
def tasks: ActorRef = taskResolver
protected def CreateTaskResolvers(context: ActorContext, numberCreated: Int = 20): ActorRef = {
context.actorOf(RandomPool(numberCreated).props(Props[TaskResolver]()), s"zone-$id-taskResolver")
/**
* A local class for spawning `Actor`s to manage the number pools for this zone,
* create a number system operations class to access those pools within the context of registering and unregistering,
* and assign that number pool operations class to the containing zone
* through specific scope access.
* @see `UniqueNumberOps`
* @see `UniqueNumberSetup`
* @see `UniqueNumberSetup.AllocateNumberPoolActors`
* @see `Zone.unops`
* @param zone the zone in which the operations class will be referenced
* @param guid the number pool management class
*/
private class UniqueNumberSys(zone: Zone, guid: NumberPoolHub)
extends UniqueNumberSetup(guid, UniqueNumberSetup.AllocateNumberPoolActors) {
override def init(): UniqueNumberOps = {
val unsys = super.init()
zone.unops = unsys // zone.unops is accessible from here by virtue of being 'private[zones]`
unsys
}
}

41
src/main/scala/net/psforever/services/RemoverActor.scala
View file

@ -1,15 +1,15 @@
// Copyright (c) 2017 PSForever
package net.psforever.services
import akka.actor.{ActorRef, Cancellable}
import net.psforever.objects.guid.TaskResolver
import akka.actor.Cancellable
import net.psforever.objects.guid.{StraightforwardTask, TaskBundle, TaskWorkflow}
import net.psforever.objects.zones.Zone
import net.psforever.objects.{Default, PlanetSideGameObject}
import net.psforever.types.Vector3
import net.psforever.services.support.{SimilarityComparator, SupportActor, SupportActorCaseConversions}
import scala.concurrent.Future
import scala.concurrent.duration._
import scala.util.Success
/**
* The base class for a type of "destruction `Actor`" intended to be used for delaying object cleanup activity.
@ -30,7 +30,7 @@ import scala.util.Success
* and finally unregistering it.
* Some types of object have (de-)implementation variations which should be made explicit through the overrides.
*/
abstract class RemoverActor(val taskResolver: ActorRef) extends SupportActor[RemoverActor.Entry] {
abstract class RemoverActor() extends SupportActor[RemoverActor.Entry] {
/**
* The timer that checks whether entries in the first pool are still eligible for that pool.
@ -249,30 +249,23 @@ abstract class RemoverActor(val taskResolver: ActorRef) extends SupportActor[Rem
def SecondJob(entry: RemoverActor.Entry): Unit = {
entry.obj.Position = Vector3.Zero //somewhere it will not disturb anything
taskResolver ! FinalTask(entry)
TaskWorkflow.execute(FinalTask(entry))
}
def FinalTask(entry: RemoverActor.Entry): TaskResolver.GiveTask = {
import net.psforever.objects.guid.Task
TaskResolver.GiveTask(
new Task() {
private val localEntry = entry
private val localAnnounce = self
def FinalTask(entry: RemoverActor.Entry): TaskBundle = {
import scala.concurrent.ExecutionContext.Implicits.global
TaskBundle(
new StraightforwardTask() {
// private val localEntry = entry
// private val localAnnounce = self
override def isComplete: Task.Resolution.Value =
if (!localEntry.obj.HasGUID) {
Task.Resolution.Success
} else {
Task.Resolution.Incomplete
}
def Execute(resolver: ActorRef): Unit = {
resolver ! Success(this)
def action(): Future[Any] = {
Future(this)
}
override def onFailure(ex: Throwable): Unit = {
localAnnounce ! RemoverActor.FailureToWork(localEntry, ex)
}
// override def onFailure(ex: Throwable): Unit = {
// localAnnounce ! RemoverActor.FailureToWork(localEntry, ex)
// }
},
List(DeletionTask(entry))
)
@ -319,7 +312,7 @@ abstract class RemoverActor(val taskResolver: ActorRef) extends SupportActor[Rem
* @see `GUIDTask`
* @param entry the entry
*/
def DeletionTask(entry: RemoverActor.Entry): TaskResolver.GiveTask
def DeletionTask(entry: RemoverActor.Entry): TaskBundle
}
object RemoverActor extends SupportActorCaseConversions {

8
src/main/scala/net/psforever/services/account/AccountPersistenceService.scala
View file

@ -6,7 +6,7 @@ import akka.actor.{Actor, ActorRef, Cancellable, Props}
import scala.collection.mutable
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
import net.psforever.objects.guid.GUIDTask
import net.psforever.objects.guid.{GUIDTask, TaskWorkflow}
import net.psforever.objects._
import net.psforever.objects.avatar.Avatar
import net.psforever.objects.serverobject.mount.Mountable
@ -389,7 +389,8 @@ class PersistenceMonitor(name: String, squadService: ActorRef) extends Actor {
}
inZone.Population.tell(Zone.Population.Release(avatar), parent)
inZone.AvatarEvents.tell(AvatarServiceMessage(inZone.id, AvatarAction.ObjectDelete(pguid, pguid)), parent)
inZone.tasks.tell(GUIDTask.UnregisterPlayer(player)(inZone.GUID), parent)
TaskWorkflow.execute(GUIDTask.unregisterPlayer(inZone.GUID, player))
//inZone.tasks.tell(GUIDTask.UnregisterPlayer(player)(inZone.GUID), parent)
AvatarLogout(avatar)
}
@ -408,7 +409,8 @@ class PersistenceMonitor(name: String, squadService: ActorRef) extends Actor {
squadService.tell(Service.Leave(Some(avatar.id.toString)), context.parent)
Deployables.Disown(inZone, avatar, context.parent)
inZone.Population.tell(Zone.Population.Leave(avatar), context.parent)
inZone.tasks.tell(GUIDTask.UnregisterObjectTask(avatar.locker)(inZone.GUID), context.parent)
TaskWorkflow.execute(GUIDTask.unregisterObject(inZone.GUID, avatar.locker))
//inZone.tasks.tell(GUIDTask.UnregisterObjectTask(avatar.locker)(inZone.GUID), context.parent)
log.info(s"Logout of ${avatar.name}")
}
}

4
src/main/scala/net/psforever/services/avatar/AvatarService.scala
View file

@ -10,8 +10,8 @@ import net.psforever.services.avatar.support.{CorpseRemovalActor, DroppedItemRem
import net.psforever.services.{GenericEventBus, RemoverActor, Service}
class AvatarService(zone: Zone) extends Actor {
private val undertaker: ActorRef = context.actorOf(Props(classOf[CorpseRemovalActor], zone.tasks), s"${zone.id}-corpse-removal-agent")
private val janitor = context.actorOf(Props(classOf[DroppedItemRemover], zone.tasks), s"${zone.id}-item-remover-agent")
private val undertaker: ActorRef = context.actorOf(Props[CorpseRemovalActor](), s"${zone.id}-corpse-removal-agent")
private val janitor = context.actorOf(Props[DroppedItemRemover](), s"${zone.id}-item-remover-agent")
private[this] val log = org.log4s.getLogger

9
src/main/scala/net/psforever/services/avatar/support/CorpseRemovalActor.scala
View file

@ -1,8 +1,7 @@
// Copyright (c) 2017 PSForever
package net.psforever.services.avatar.support
import akka.actor.ActorRef
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle}
import net.psforever.objects.Player
import net.psforever.types.ExoSuitType
import net.psforever.services.{RemoverActor, Service}
@ -10,7 +9,7 @@ import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage}
import scala.concurrent.duration._
class CorpseRemovalActor(taskResolver: ActorRef) extends RemoverActor(taskResolver) {
class CorpseRemovalActor extends RemoverActor() {
final val FirstStandardDuration: FiniteDuration = 1 minute
final val SecondStandardDuration: FiniteDuration = 500 milliseconds
@ -32,9 +31,9 @@ class CorpseRemovalActor(taskResolver: ActorRef) extends RemoverActor(taskResolv
def ClearanceTest(entry: RemoverActor.Entry): Boolean = !entry.zone.Corpses.contains(entry.obj)
def DeletionTask(entry: RemoverActor.Entry): TaskResolver.GiveTask = {
def DeletionTask(entry: RemoverActor.Entry): TaskBundle = {
val player = entry.obj.asInstanceOf[Player]
val task = GUIDTask.UnregisterPlayer(player)(entry.zone.GUID)
val task = GUIDTask.unregisterPlayer(entry.zone.GUID, player)
player.ExoSuit = ExoSuitType.Standard
task
}

9
src/main/scala/net/psforever/services/avatar/support/DroppedItemRemover.scala
View file

@ -1,15 +1,14 @@
// Copyright (c) 2017 PSForever
package net.psforever.services.avatar.support
import akka.actor.ActorRef
import net.psforever.objects.equipment.Equipment
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle}
import net.psforever.services.{RemoverActor, Service}
import net.psforever.services.avatar.{AvatarAction, AvatarServiceMessage}
import scala.concurrent.duration._
class DroppedItemRemover(taskResolver: ActorRef) extends RemoverActor(taskResolver) {
class DroppedItemRemover extends RemoverActor() {
final val FirstStandardDuration: FiniteDuration = 3 minutes
final val SecondStandardDuration: FiniteDuration = 500 milliseconds
@ -31,7 +30,7 @@ class DroppedItemRemover(taskResolver: ActorRef) extends RemoverActor(taskResolv
def ClearanceTest(entry: RemoverActor.Entry): Boolean = !entry.zone.EquipmentOnGround.contains(entry.obj)
def DeletionTask(entry: RemoverActor.Entry): TaskResolver.GiveTask = {
GUIDTask.UnregisterEquipment(entry.obj.asInstanceOf[Equipment])(entry.zone.GUID)
def DeletionTask(entry: RemoverActor.Entry): TaskBundle = {
GUIDTask.unregisterEquipment(entry.zone.GUID, entry.obj.asInstanceOf[Equipment])
}
}

4
src/main/scala/net/psforever/services/local/LocalService.scala
View file

@ -19,10 +19,10 @@ class LocalService(zone: Zone) extends Actor {
Props[HackClearActor](), s"${zone.id}-local-hack-clearer"
)
private val hackCapturer = context.actorOf(
Props(classOf[HackCaptureActor], zone.tasks), s"${zone.id}-local-hack-capturer"
Props[HackCaptureActor](), s"${zone.id}-local-hack-capturer"
)
private val captureFlagManager = context.actorOf(
Props(classOf[CaptureFlagManager], zone.tasks, zone), s"${zone.id}-local-capture-flag-manager"
Props(classOf[CaptureFlagManager], zone), s"${zone.id}-local-capture-flag-manager"
)
private[this] val log = org.log4s.getLogger

35
src/main/scala/net/psforever/services/local/support/CaptureFlagManager.scala
View file

@ -1,8 +1,9 @@
package net.psforever.services.local.support
import akka.actor.{Actor, ActorRef, Cancellable}
import net.psforever.login.WorldSession
import net.psforever.objects.{Default, Player}
import net.psforever.objects.guid.{GUIDTask, Task, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskWorkflow}
import net.psforever.objects.serverobject.llu.CaptureFlag
import net.psforever.objects.serverobject.structures.Building
import net.psforever.objects.serverobject.terminals.capture.CaptureTerminal
@ -16,14 +17,11 @@ import net.psforever.services.local.{LocalAction, LocalServiceMessage}
import net.psforever.types.{ChatMessageType, PlanetSideEmpire, PlanetSideGUID, Vector3}
import scala.concurrent.duration.DurationInt
import scala.util.Success
/**
* Responsible for handling capture flag related lifecycles
* @param taskResolver A reference to a zone's task resolver actor
*/
class CaptureFlagManager(val taskResolver: ActorRef, zone: Zone) extends Actor{
class CaptureFlagManager(zone: Zone) extends Actor{
private[this] val log = org.log4s.getLogger(self.path.name)
var galaxyService: ActorRef = ActorRef.noSender
@ -105,14 +103,14 @@ class CaptureFlagManager(val taskResolver: ActorRef, zone: Zone) extends Actor{
socket.captureFlag = flag
TrackFlag(flag)
taskResolver ! CallBackForTask(
TaskResolver.GiveTask(GUIDTask.RegisterObjectTask(flag)(socket.Zone.GUID).task),
TaskWorkflow.execute(WorldSession.CallBackForTask(
GUIDTask.registerObject(socket.Zone.GUID, flag),
socket.Zone.LocalEvents,
LocalServiceMessage(
socket.Zone.id,
LocalAction.LluSpawned(PlanetSideGUID(-1), flag)
)
)
))
// Broadcast chat message for LLU spawn
val owner = flag.Owner.asInstanceOf[Building]
@ -184,7 +182,7 @@ class CaptureFlagManager(val taskResolver: ActorRef, zone: Zone) extends Actor{
// Unregister LLU from clients,
flag.Zone.LocalEvents ! LocalServiceMessage(flag.Zone.id, LocalAction.LluDespawned(PlanetSideGUID(-1), flag))
// Then unregister it from the GUID pool
taskResolver ! TaskResolver.GiveTask(GUIDTask.UnregisterObjectTask(flag)(flag.Zone.GUID).task)
TaskWorkflow.execute(GUIDTask.unregisterObject(flag.Zone.GUID,flag))
}
private def ChatBroadcast(zone: Zone, message: String, fanfare: Boolean = true): Unit = {
@ -202,25 +200,6 @@ class CaptureFlagManager(val taskResolver: ActorRef, zone: Zone) extends Actor{
)
)
}
// Todo: Duplicate from SessionActor. Make common.
def CallBackForTask(task: TaskResolver.GiveTask, sendTo: ActorRef, pass: Any): TaskResolver.GiveTask = {
TaskResolver.GiveTask(
new Task() {
private val localDesc = task.task.Description
private val destination = sendTo
private val passMsg = pass
override def Description: String = s"callback for tasking $localDesc"
def Execute(resolver: ActorRef): Unit = {
destination ! passMsg
resolver ! Success(this)
}
},
List(task)
)
}
}
object CaptureFlagManager {

4
src/main/scala/net/psforever/services/local/support/HackCaptureActor.scala
View file

@ -1,6 +1,6 @@
package net.psforever.services.local.support
import akka.actor.{Actor, ActorRef, Cancellable}
import akka.actor.{Actor, Cancellable}
import net.psforever.actors.zone.{BuildingActor, ZoneActor}
import net.psforever.objects.serverobject.CommonMessages
import net.psforever.objects.serverobject.hackable.Hackable
@ -20,7 +20,7 @@ import scala.util.Random
/**
* Responsible for handling the aspects related to hacking control consoles and capturing bases.
*/
class HackCaptureActor(val taskResolver: ActorRef) extends Actor {
class HackCaptureActor extends Actor {
private[this] val log = org.log4s.getLogger
private var clearTrigger: Cancellable = Default.Cancellable

39
src/main/scala/net/psforever/services/vehicle/support/TurretUpgrader.scala
View file

@ -1,10 +1,10 @@
// Copyright (c) 2017 PSForever
package net.psforever.services.vehicle.support
import akka.actor.{ActorRef, Cancellable}
import akka.actor.Cancellable
import net.psforever.objects.equipment.EquipmentSlot
import net.psforever.objects.{AmmoBox, Default, PlanetSideGameObject, Tool}
import net.psforever.objects.guid.{GUIDTask, Task, TaskResolver}
import net.psforever.objects.guid._
import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.objects.serverobject.turret.{FacilityTurret, TurretUpgrade, WeaponTurret}
import net.psforever.objects.vehicles.MountedWeapons
@ -13,8 +13,8 @@ import net.psforever.types.PlanetSideGUID
import net.psforever.services.support.{SimilarityComparator, SupportActor, SupportActorCaseConversions}
import net.psforever.services.vehicle.{VehicleAction, VehicleServiceMessage}
import scala.concurrent.Future
import scala.concurrent.duration._
import scala.util.Success
class TurretUpgrader extends SupportActor[TurretUpgrader.Entry] {
var task: Cancellable = Default.Cancellable
@ -172,39 +172,34 @@ class TurretUpgrader extends SupportActor[TurretUpgrader.Entry] {
val oldBoxesTask = oldBoxes
.filterNot { box => newBoxes.exists(_ eq box) }
.map(box => GUIDTask.UnregisterEquipment(box)(guid))
.map(box => GUIDTask.unregisterEquipment(guid, box))
.toList
val newBoxesTask = TaskResolver.GiveTask(
new Task() {
import scala.concurrent.ExecutionContext.Implicits.global
val newBoxesTask = TaskBundle(
new StraightforwardTask() {
private val localFunc: () => Unit = FinishUpgradingTurret(entry)
override def isComplete = Task.Resolution.Success
def Execute(resolver: ActorRef): Unit = {
resolver ! Success(this)
}
override def onSuccess(): Unit = {
super.onSuccess()
def action(): Future[Any] = {
localFunc()
Future(this)
}
},
newBoxes
.filterNot { box => oldBoxes.exists(_ eq box) }
.map(box => GUIDTask.RegisterEquipment(box)(guid))
.map(box => GUIDTask.registerEquipment(guid, box))
.toList
)
target.Zone.tasks ! TaskResolver.GiveTask(
new Task() {
TaskWorkflow.execute(TaskBundle(
new StraightforwardTask() {
private val tasks = oldBoxesTask
def Execute(resolver: ActorRef): Unit = {
tasks.foreach { resolver ! _ }
resolver ! Success(this)
def action(): Future[Any] = {
tasks.foreach { TaskWorkflow.execute }
Future(this)
}
},
List(newBoxesTask)
)
newBoxesTask
))
}
/**

118
src/main/scala/net/psforever/zones/Zones.scala
View file

@ -12,6 +12,7 @@ import io.circe.parser._
import net.psforever.objects.{GlobalDefinitions, LocalLockerItem, LocalProjectile}
import net.psforever.objects.ballistics.Projectile
import net.psforever.objects.definition.BasicDefinition
import net.psforever.objects.guid.selector.{NumberSelector, RandomSelector, SpecificSelector}
import net.psforever.objects.serverobject.doors.{Door, DoorDefinition, SpawnTubeDoor}
import net.psforever.objects.serverobject.generator.Generator
import net.psforever.objects.serverobject.llu.{CaptureFlagSocket, CaptureFlagSocketDefinition}
@ -55,6 +56,25 @@ object Zones {
}
}
private case class GuidNumberPool(
name: String,
start: Int,
max: Int,
selector: String
) {
def getSelector() : NumberSelector = {
if (selector.equals("random")) new RandomSelector
else new SpecificSelector
}
}
private implicit val decodeNumberPool: Decoder[GuidNumberPool] = Decoder.forProduct4(
"Name",
"Start",
"Max",
"Selector"
)(GuidNumberPool.apply)
private implicit val decodeZoneMapEntity: Decoder[ZoneMapEntity] = Decoder.forProduct11(
"Id",
"ObjectName",
@ -585,44 +605,84 @@ object Zones {
}
}
lazy val zones: Seq[Zone] = ZoneInfo.values.map { info =>
new Zone(info.id, zoneMaps.find(_.name == info.map.value).get, info.value) {
override def init(implicit context: ActorContext): Unit = {
super.init(context)
lazy val zones: Seq[Zone] = {
val defaultGuids =
try {
val res = Source.fromResource("guid-pools/default.json")
val json = res.mkString
res.close()
decode[Seq[GuidNumberPool]](json).toOption.get
} catch {
case _: Exception => Seq()
}
if (!info.id.startsWith("tz")) {
this.HotSpotCoordinateFunction = Zones.HotSpots.standardRemapping(info.map.scale, 80, 80)
this.HotSpotTimeFunction = Zones.HotSpots.standardTimeRules
Zones.initZoneAmenities(this)
ZoneInfo.values.map { info =>
val guids =
try {
val res = Source.fromResource(s"guid-pools/${info.id}.json")
val json = res.mkString
res.close()
val custom = decode[Seq[GuidNumberPool]](json).toOption.get
customizePools(defaultGuids, custom)
} catch {
case _: Exception => defaultGuids
}
info.id match {
case "home1" =>
this.Buildings.values.foreach(_.Faction = PlanetSideEmpire.NC)
case "home2" =>
this.Buildings.values.foreach(_.Faction = PlanetSideEmpire.TR)
case "home3" =>
this.Buildings.values.foreach(_.Faction = PlanetSideEmpire.VS)
case zoneid if zoneid.startsWith("c") =>
this.map.cavern = true
case _ => ()
}
new Zone(info.id, zoneMaps.find(_.name.equals(info.map.value)).get, info.value) {
private val addPoolsFunc: () => Unit = addPools(guids, zone = this)
// Set up warp gate factions aka "sanctuary link". Those names make no sense anymore, don't even ask.
this.Buildings.foreach {
case (_, building) if building.Name.startsWith("WG") =>
building.Name match {
case "WG_Amerish_to_Solsar" | "WG_Esamir_to_VSSanc" => building.Faction = PlanetSideEmpire.NC
case "WG_Hossin_to_VSSanc" | "WG_Solsar_to_Amerish" => building.Faction = PlanetSideEmpire.TR
case "WG_Ceryshen_to_Hossin" | "WG_Forseral_to_Solsar" => building.Faction = PlanetSideEmpire.VS
case _ => ()
}
case _ => ()
override def SetupNumberPools() : Unit = addPoolsFunc()
override def init(implicit context: ActorContext): Unit = {
super.init(context)
if (!info.id.startsWith("tz")) {
this.HotSpotCoordinateFunction = Zones.HotSpots.standardRemapping(info.map.scale, 80, 80)
this.HotSpotTimeFunction = Zones.HotSpots.standardTimeRules
Zones.initZoneAmenities(this)
}
info.id match {
case "home1" =>
this.Buildings.values.foreach(_.Faction = PlanetSideEmpire.NC)
case "home2" =>
this.Buildings.values.foreach(_.Faction = PlanetSideEmpire.TR)
case "home3" =>
this.Buildings.values.foreach(_.Faction = PlanetSideEmpire.VS)
case zoneid if zoneid.startsWith("c") =>
this.map.cavern = true
case _ => ;
}
// Set up warp gate factions aka "sanctuary link". Those names make no sense anymore, don't even ask.
this.Buildings.foreach {
case (_, building) if building.Name.startsWith("WG") =>
building.Name match {
case "WG_Amerish_to_Solsar" | "WG_Esamir_to_VSSanc" => building.Faction = PlanetSideEmpire.NC
case "WG_Hossin_to_VSSanc" | "WG_Solsar_to_Amerish" => building.Faction = PlanetSideEmpire.TR
case "WG_Ceryshen_to_Hossin" | "WG_Forseral_to_Solsar" => building.Faction = PlanetSideEmpire.VS
case _ => ;
}
case _ => ;
}
}
}
}
}
private def customizePools(base: Seq[GuidNumberPool], custom: Seq[GuidNumberPool]): Seq[GuidNumberPool] = {
val exclude = custom.map { _.name }
val remainder = base.filterNot { entry => exclude.contains { entry.name } }
custom ++ remainder
}
private def addPools(guids: Seq[GuidNumberPool], zone: Zone)(): Unit = {
guids.foreach { entry =>
zone.AddPool(name = entry.name, (entry.start to entry.max).toList)
.foreach { _.Selector = entry.getSelector() }
}
}
def initZoneAmenities(zone: Zone): Unit = {
initResourceSilos(zone)
initWarpGates(zone)

1
src/test/scala/objects/DamageableTest.scala
View file

@ -1614,7 +1614,6 @@ class DamageableVehicleDestroyMountedTest extends FreedContextActorTest {
override def Activity = activityProbe.ref
override def AvatarEvents = avatarProbe.ref
override def VehicleEvents = vehicleProbe.ref
override def tasks = catchall.ref
import akka.actor.typed.scaladsl.adapter._
this.actor = catchall.ref.toTyped[ZoneActor.Command]
}

26
src/test/scala/objects/DeployableBehaviorTest.scala
View file

@ -9,7 +9,7 @@ import net.psforever.actors.zone.ZoneActor
import net.psforever.objects.avatar.{Avatar, Certification, PlayerControl}
import net.psforever.objects.{ConstructionItem, Deployables, GlobalDefinitions, Player}
import net.psforever.objects.ce.{Deployable, DeployedItem}
import net.psforever.objects.guid.{NumberPoolHub, TaskResolver}
import net.psforever.objects.guid.NumberPoolHub
import net.psforever.objects.guid.source.MaxNumberSource
import net.psforever.objects.zones.{Zone, ZoneDeployableActor, ZoneMap}
import net.psforever.packet.game._
@ -141,7 +141,6 @@ class DeployableBehaviorSetupOwnedP2Test extends FreedContextActorTest {
override def Deployables: ActorRef = deployables
override def Players = List(avatar)
override def LivePlayers = List(player)
override def tasks: ActorRef = eventsProbe.ref
this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]
}
@ -165,7 +164,7 @@ class DeployableBehaviorSetupOwnedP2Test extends FreedContextActorTest {
assert(!avatar.deployables.Contains(jmine), "owned setup test, 2 - avatar already owns deployable")
zone.Deployables ! Zone.Deployable.BuildByOwner(jmine, player, citem)
//assert(false, "test needs to be fixed")
val eventsMsgs = eventsProbe.receiveN(8, 10.seconds)
val eventsMsgs = eventsProbe.receiveN(7, 10.seconds)
eventsMsgs.head match {
case AvatarServiceMessage(
"TestCharacter1",
@ -220,11 +219,6 @@ class DeployableBehaviorSetupOwnedP2Test extends FreedContextActorTest {
case _ =>
assert(false, "owned setup test, 2 - construction tool not deleted")
}
eventsMsgs(7) match {
case TaskResolver.GiveTask(_, _) => ;
case _ =>
assert(false, "owned setup test, 2 - construction tool not unregistered")
}
assert(player.Slot(slot = 0).Equipment.isEmpty, "owned setup test, 2 - player hand should be empty")
assert(deployableList.contains(jmine), "owned setup test, 2 - deployable not appended to list")
assert(avatar.deployables.Contains(jmine), "owned setup test, 2 - avatar does not own deployable")
@ -244,7 +238,6 @@ class DeployableBehaviorDeconstructTest extends ActorTest {
GUID(guid)
override def AvatarEvents: ActorRef = eventsProbe.ref
override def LocalEvents: ActorRef = eventsProbe.ref
override def tasks: ActorRef = eventsProbe.ref
override def Deployables: ActorRef = deployables
this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]
@ -261,7 +254,7 @@ class DeployableBehaviorDeconstructTest extends ActorTest {
assert(deployableList.contains(jmine), "deconstruct test - deployable not appended to list")
jmine.Actor ! Deployable.Deconstruct()
val eventsMsgs = eventsProbe.receiveN(3, 10.seconds)
val eventsMsgs = eventsProbe.receiveN(2, 10.seconds)
eventsMsgs.head match {
case LocalServiceMessage("test", LocalAction.EliminateDeployable(`jmine`, PlanetSideGUID(1), Vector3(1,2,3), 2)) => ;
case _ => assert(false, "deconstruct test - not eliminating deployable")
@ -277,10 +270,6 @@ class DeployableBehaviorDeconstructTest extends ActorTest {
) => ;
case _ => assert(false, "owned deconstruct test - not removing icon")
}
eventsMsgs(2) match {
case TaskResolver.GiveTask(_, _) => ;
case _ => assert(false, "deconstruct test - not unregistering deployable")
}
assert(!deployableList.contains(jmine), "deconstruct test - deployable not removed from list")
}
}
@ -304,7 +293,6 @@ class DeployableBehaviorDeconstructOwnedTest extends FreedContextActorTest {
override def Deployables: ActorRef = deployables
override def Players = List(avatar)
override def LivePlayers = List(player)
override def tasks: ActorRef = eventsProbe.ref
this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]
}
@ -324,12 +312,12 @@ class DeployableBehaviorDeconstructOwnedTest extends FreedContextActorTest {
"DeployableBehavior" should {
"deconstruct and alert owner" in {
zone.Deployables ! Zone.Deployable.BuildByOwner(jmine, player, citem)
eventsProbe.receiveN(8, 10.seconds)
eventsProbe.receiveN(7, 10.seconds)
assert(deployableList.contains(jmine), "owned deconstruct test - deployable not appended to list")
assert(avatar.deployables.Contains(jmine), "owned deconstruct test - avatar does not own deployable")
jmine.Actor ! Deployable.Deconstruct()
val eventsMsgs = eventsProbe.receiveN(4, 10.seconds)
val eventsMsgs = eventsProbe.receiveN(3, 10.seconds)
eventsMsgs.head match {
case LocalServiceMessage("test", LocalAction.EliminateDeployable(`jmine`, PlanetSideGUID(1), Vector3(1,2,3), 2)) => ;
case _ => assert(false, "owned deconstruct test - not eliminating deployable")
@ -349,10 +337,6 @@ class DeployableBehaviorDeconstructOwnedTest extends FreedContextActorTest {
) => ;
case _ => assert(false, "owned deconstruct test - not removing icon")
}
eventsMsgs(3) match {
case TaskResolver.GiveTask(_, _) => ;
case _ => assert(false, "owned deconstruct test - not unregistering deployable")
}
assert(deployableList.isEmpty, "owned deconstruct test - deployable still in list")
assert(!avatar.deployables.Contains(jmine), "owned deconstruct test - avatar still owns deployable")

3
src/test/scala/objects/DeployableTest.scala
View file

@ -330,7 +330,6 @@ class ExplosiveDeployableJammerTest extends ActorTest {
override def Deployables: ActorRef = deployables
override def Players = List(avatar1, avatar2)
override def LivePlayers = List(player1, player2)
override def tasks: ActorRef = eventsProbe.ref
}
player1.Spawn()
player2.Spawn()
@ -408,7 +407,6 @@ class ExplosiveDeployableJammerExplodeTest extends ActorTest {
override def Deployables: ActorRef = deployables
override def Players = List(avatar1, avatar2)
override def LivePlayers = List(player1, player2)
override def tasks: ActorRef = eventsProbe.ref
this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]
}
@ -518,7 +516,6 @@ class ExplosiveDeployableDestructionTest extends ActorTest {
override def Deployables: ActorRef = deployables
override def Players = List(avatar1, avatar2)
override def LivePlayers = List(player1, player2)
override def tasks: ActorRef = eventsProbe.ref
}
player1.Spawn()
player1.Actor = player1Probe.ref

22
src/test/scala/objects/OrbitalShuttlePadTest.scala
View file

@ -2,13 +2,11 @@
package objects
import akka.actor.{ActorRef, Props}
import akka.routing.RandomPool
import akka.testkit.TestProbe
import base.FreedContextActorTest
import net.psforever.actors.zone.{BuildingActor, ZoneActor}
import net.psforever.objects.guid.actor.UniqueNumberSystem
import net.psforever.objects.{GlobalDefinitions, Vehicle}
import net.psforever.objects.guid.{NumberPoolHub, TaskResolver}
import net.psforever.objects.guid.{NumberPoolHub, UniqueNumberOps, UniqueNumberSetup}
import net.psforever.objects.guid.source.MaxNumberSource
import net.psforever.objects.serverobject.doors.Door
import net.psforever.objects.serverobject.shuttle.{OrbitalShuttle, OrbitalShuttlePad, OrbitalShuttlePadControl, ShuttleAmenity}
@ -23,7 +21,7 @@ import scala.collection.concurrent.TrieMap
import scala.collection.mutable.ListBuffer
import scala.concurrent.duration._
class OrbitalShuttlePadControltest extends FreedContextActorTest {
class OrbitalShuttlePadControlTest extends FreedContextActorTest {
import akka.actor.typed.scaladsl.adapter._
system.spawn(InterstellarClusterService(Nil), InterstellarClusterService.InterstellarClusterServiceKey.id)
val services = ServiceManager.boot(system)
@ -32,22 +30,17 @@ class OrbitalShuttlePadControltest extends FreedContextActorTest {
expectNoMessage(1000 milliseconds)
var buildingMap = new TrieMap[Int, Building]()
val vehicles = ListBuffer[Vehicle]()
val guid = new NumberPoolHub(new MaxNumberSource(max = 15))
guid.AddPool("dynamic", (11 to 15).toList)
val guid = new NumberPoolHub(new MaxNumberSource(max = 20))
guid.AddPool("vehicles", (11 to 15).toList)
guid.AddPool("tools", (16 to 19).toList)
val catchall = new TestProbe(system).ref
val resolver = context.actorOf(RandomPool(1).props(Props[TaskResolver]()), s"test-taskResolver")
val uns = context.actorOf(
RandomPool(1).props(
Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystem.AllocateNumberPoolActors(this.guid))
),
s"test-uns"
)
val unops = new UniqueNumberOps(guid, UniqueNumberSetup.AllocateNumberPoolActors(context, guid))
val zone = new Zone("test", new ZoneMap("test-map"), 0) {
val transport: ActorRef = context.actorOf(Props(classOf[ZoneVehicleActor], this, vehicles), s"zone-test-vehicles")
override def SetupNumberPools() = {}
GUID(guid)
override def GUID = { uns }
override def GUID = { unops }
override def AvatarEvents = catchall
override def LocalEvents = catchall
override def VehicleEvents = catchall
@ -55,7 +48,6 @@ class OrbitalShuttlePadControltest extends FreedContextActorTest {
override def Transport = { transport }
override def Vehicles = { vehicles.toList }
override def Buildings = { buildingMap.toMap }
override def tasks = { resolver }
import akka.actor.typed.scaladsl.adapter._
this.actor = new TestProbe(system).ref.toTyped[ZoneActor.Command]

116
src/test/scala/objects/TaskWorkflowTest.scala Normal file
View file

@ -0,0 +1,116 @@
// Copyright (c) 2021 PSForever
package objects
import net.psforever.objects.guid.{Task, TaskBundle, TaskWorkflow}
import org.scalatest.flatspec.AsyncFlatSpec
import scala.concurrent.Future
import scala.util.Failure
class AsyncTaskWorkflowTest extends AsyncFlatSpec {
case class StringAppendTask(product: StringBuilder, str: String) extends Task {
def action() = { Future({ product.append(str) }) }
def undo() = {
val index = product.indexOf(str)
product.replace(index, index + str.length, "[successful task undo]")
}
def isSuccessful() = { product.indexOf(str) > -1 }
}
case class FailedStringAppendTask(product: StringBuilder, str: String) extends Task {
def action() = { Future(Failure(new Exception("intentional failure"))) }
def undo() = {
val index = product.indexOf(str)
product.replace(index, index + str.length, "[failed task undo]")
}
def isSuccessful() = { product.indexOf(str) > -1 }
}
behavior of "TaskWorkFlow"
it should "append a string as a task" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(StringAppendTask(test, "hello")))
result map { _ =>
assert(test.mkString.equals("hello"), "async result does not equal 'hello'")
}
}
it should "append the strings in order of subtask then main task" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(StringAppendTask(test, " world"), StringAppendTask(test, "hello")))
result map { _ =>
assert(test.mkString.equals("hello world"), "async result does not equal 'hello world'")
}
}
it should "append the strings in order of subtasks then main task, with the subtasks being in either order" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(
StringAppendTask(test, " world"),
Seq(
TaskBundle(StringAppendTask(test, " hello")),
TaskBundle(StringAppendTask(test, " or goodbye"))
)
))
result map { _ =>
val output = test.mkString
assert(
output.equals(" or goodbye hello world") || output.equals(" hello or goodbye world"),
s"async result '$output' does not equal either pattern"
)
}
}
it should "if a task fails, do not undo it" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(FailedStringAppendTask(test, " world")))
result map { _ =>
val output = test.mkString
assert(output.equals(""),"async result was written when should have not been written")
//see implementation of FailedStringAppendTask.undo
}
}
it should "if a middling subtask fails, its parent task will not be executed or undone, but its own subtask will be undone (1)" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(
StringAppendTask(test, " world"),
TaskBundle(FailedStringAppendTask(test, "hello"), StringAppendTask(test, " or goodbye")))
)
result map { _ =>
val output = test.mkString
assert(output.equals("[successful task undo]"),s"async result, formerly successful, was written as if it had failed - $output")
//see implementation of StringAppendTask.undo
}
}
it should "if a middling subtask fails, its parent task will not be executed or undone, but its own subtasks will be undone (2)" in {
val test: StringBuilder = new StringBuilder()
assert(test.mkString.isEmpty)
val result = TaskWorkflow.execute(TaskBundle(
StringAppendTask(test, " world"),
TaskBundle(FailedStringAppendTask(test, "hello"), List(
TaskBundle(StringAppendTask(test, " or goodbye")),
TaskBundle(StringAppendTask(test, " or something"))
))
))
result map { _ =>
val output = test.mkString
assert(
output.equals("[successful task undo][successful task undo]"),
s"async result, formerly successful, was written as if it had failed - $output"
)
//see implementation of StringAppendTask.undo
}
}
}
object TaskWorkflowTest {
/** placeholder */
}

1
src/test/scala/objects/VehicleControlTest.scala
View file

@ -212,7 +212,6 @@ class VehicleControlPrepareForDeletionMountedCargoTest extends FreedContextActor
override def SetupNumberPools(): Unit = {}
override def VehicleEvents = vehicleProbe.ref
override def tasks = catchall.ref
}
zone.actor = system.spawn(ZoneActor(zone), "test-zone-actor")
// crappy workaround but without it the zone doesn't get initialized in time

2
src/test/scala/objects/ZoneTest.scala
View file

@ -130,7 +130,7 @@ class ZoneActorTest extends ActorTest {
zone.actor = system.spawn(ZoneActor(zone), "test-add-pool-actor-init")
expectNoMessage(Duration.create(500, "ms"))
assert(!zone.AddPool("test1", 1 to 2))
assert(zone.AddPool("test1", 1 to 2).isEmpty)
}
"refuse to remove number pools after the Actor is started" in {

16
src/test/scala/objects/guidtask/GUIDTaskRegisterAmmoTest.scala
View file

@ -3,19 +3,21 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskRegisterAmmoTest extends ActorTest {
"RegisterEquipment -> RegisterObjectTask" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)
assert(!obj.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterEquipment(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerEquipment(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
}
}

18
src/test/scala/objects/guidtask/GUIDTaskRegisterAvatarTest.scala
View file

@ -4,15 +4,17 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.avatar.Avatar
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import net.psforever.objects.locker.LockerEquipment
import net.psforever.types.{CharacterSex, CharacterVoice, PlanetSideEmpire}
import scala.concurrent.duration._
class GUIDTaskRegisterAvatarTest extends ActorTest {
"RegisterAvatar" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
obj.Slot(0).Equipment = obj_wep
val obj_wep_ammo = AmmoBox(GlobalDefinitions.energy_cell)
obj_wep.AmmoSlots.head.Box = obj_wep_ammo
@ -28,11 +30,11 @@ class GUIDTaskRegisterAvatarTest extends ActorTest {
assert(!obj_inv_ammo.HasGUID)
assert(!obj_locker.HasGUID)
assert(obj_locker_ammo.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterAvatar(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerAvatar(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
assert(obj_wep_ammo.HasGUID)

16
src/test/scala/objects/guidtask/GUIDTaskRegisterObjectTest.scala
View file

@ -2,19 +2,21 @@
package objects.guidtask
import base.ActorTest
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskRegisterObjectTest extends ActorTest {
"RegisterObjectTask" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = new GUIDTaskTest.TestObject
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = new GUIDTaskTest.TestObject
assert(!obj.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterObjectTask(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerObject(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
}
}

18
src/test/scala/objects/guidtask/GUIDTaskRegisterPlayerTest.scala
View file

@ -4,15 +4,17 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.avatar.Avatar
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import net.psforever.objects.locker.LockerEquipment
import net.psforever.types.{CharacterSex, CharacterVoice, PlanetSideEmpire}
import scala.concurrent.duration._
class GUIDTaskRegisterPlayerTest extends ActorTest {
"RegisterPlayer" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar(0, "test", PlanetSideEmpire.TR, CharacterSex.Male, 0, CharacterVoice.Mute))
val obj_wep = Tool(GlobalDefinitions.beamer)
obj.Slot(0).Equipment = obj_wep
val obj_wep_ammo = AmmoBox(GlobalDefinitions.energy_cell)
obj_wep.AmmoSlots.head.Box = obj_wep_ammo
@ -28,11 +30,11 @@ class GUIDTaskRegisterPlayerTest extends ActorTest {
assert(!obj_inv_ammo.HasGUID)
assert(!obj_locker.HasGUID)
assert(obj_locker_ammo.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterPlayer(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerPlayer(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
assert(obj_wep_ammo.HasGUID)

16
src/test/scala/objects/guidtask/GUIDTaskRegisterToolTest.scala
View file

@ -3,21 +3,23 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskRegisterToolTest extends ActorTest {
"RegisterEquipment -> RegisterTool" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Tool(GlobalDefinitions.beamer)
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Tool(GlobalDefinitions.beamer)
obj.AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.energy_cell)
assert(!obj.HasGUID)
assert(!obj.AmmoSlots.head.Box.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterEquipment(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerEquipment(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
assert(obj.AmmoSlots.head.Box.HasGUID)
}

22
src/test/scala/objects/guidtask/GUIDTaskRegisterTurretTest.scala
View file

@ -3,25 +3,27 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskRegisterTurretTest extends ActorTest {
"RegisterDeployableTurret" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = new TurretDeployable(GlobalDefinitions.portable_manned_turret_vs)
val obj_wep = obj.Weapons(1).Equipment.get
val obj_ammo = obj_wep.asInstanceOf[Tool].AmmoSlot.Box
val obj_res = obj.Inventory.Items.map(_.obj)
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = new TurretDeployable(GlobalDefinitions.portable_manned_turret_vs)
val obj_wep = obj.Weapons(1).Equipment.get
val obj_ammo = obj_wep.asInstanceOf[Tool].AmmoSlot.Box
val obj_res = obj.Inventory.Items.map(_.obj)
assert(!obj.HasGUID)
assert(!obj_wep.HasGUID)
assert(!obj_ammo.HasGUID)
obj_res.foreach(box => !box.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterDeployableTurret(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerDeployableTurret(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
assert(obj_ammo.HasGUID)

18
src/test/scala/objects/guidtask/GUIDTaskRegisterVehicleTest.scala
View file

@ -3,13 +3,15 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskRegisterVehicleTest extends ActorTest {
"RegisterVehicle" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Vehicle(GlobalDefinitions.fury)
val obj_wep = obj.WeaponControlledFromSeat(0).get
val (_, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = Vehicle(GlobalDefinitions.fury)
val obj_wep = obj.WeaponControlledFromSeat(0).get
val obj_wep_ammo = (obj.WeaponControlledFromSeat(0).get.asInstanceOf[Tool].AmmoSlots.head.Box =
AmmoBox(GlobalDefinitions.hellfire_ammo)).get
obj.Trunk += 30 -> AmmoBox(GlobalDefinitions.hellfire_ammo)
@ -19,11 +21,11 @@ class GUIDTaskRegisterVehicleTest extends ActorTest {
assert(!obj_wep.HasGUID)
assert(!obj_wep_ammo.HasGUID)
assert(!obj_trunk_ammo.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.RegisterVehicle(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.registerVehicle(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(obj.HasGUID)
assert(obj_wep.HasGUID)
assert(obj_wep_ammo.HasGUID)

46
src/test/scala/objects/guidtask/GUIDTaskTest.scala
View file

@ -2,50 +2,54 @@
package objects.guidtask
import java.util.logging.LogManager
import scala.util.Success
import akka.actor.{ActorRef, ActorSystem, Props}
import akka.testkit.TestProbe
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.actor.{NumberPoolActor, UniqueNumberSystem}
import net.psforever.objects.guid.selector.RandomSelector
import net.psforever.objects.guid.source.MaxNumberSource
import net.psforever.objects.guid.{NumberPoolHub, Task, TaskResolver}
import net.psforever.objects.guid.uns.NumberPoolActor
import net.psforever.objects.guid.{NumberPoolHub, StraightforwardTask, UniqueNumberOps}
import scala.concurrent.Future
object GUIDTaskTest {
class TestObject extends IdentifiableEntity
class RegisterTestTask(probe: ActorRef) extends Task {
def Execute(resolver: ActorRef): Unit = {
probe ! Success
resolver ! Success(this)
class RegisterTestTask(probe: ActorRef) extends StraightforwardTask {
def action(): Future[Any] = {
probe ! Success(true)
Future(this)(scala.concurrent.ExecutionContext.Implicits.global)
}
}
def CommonTestSetup(implicit system: ActorSystem): (NumberPoolHub, ActorRef, ActorRef, TestProbe) = {
import akka.actor.Props
import akka.routing.RandomPool
def CommonTestSetup(implicit system: ActorSystem): (NumberPoolHub, UniqueNumberOps, TestProbe) = {
import akka.testkit.TestProbe
val guid: NumberPoolHub = new NumberPoolHub(new MaxNumberSource(110))
guid.AddPool("dynamic", (1 to 100).toList).Selector = new RandomSelector //TODO name is hardcoded for now
val uns = system.actorOf(
RandomPool(25).props(Props(classOf[UniqueNumberSystem], guid, GUIDTaskTest.AllocateNumberPoolActors(guid))),
"uns"
)
val taskResolver = system.actorOf(RandomPool(15).props(Props[TaskResolver]()), "resolver")
val guid: NumberPoolHub = new NumberPoolHub(new MaxNumberSource(90))
guid.AddPool("players", (1 to 10).toList).Selector = new RandomSelector
guid.AddPool("lockers", (11 to 20).toList).Selector = new RandomSelector
guid.AddPool("ammo", (21 to 30).toList).Selector = new RandomSelector
guid.AddPool("tools", (31 to 40).toList).Selector = new RandomSelector
guid.AddPool("vehicles", (41 to 50).toList).Selector = new RandomSelector
guid.AddPool("terminals", (51 to 60).toList).Selector = new RandomSelector
guid.AddPool("items", (61 to 70).toList).Selector = new RandomSelector
guid.AddPool("deployables", (71 to 80).toList).Selector = new RandomSelector
val uns = new UniqueNumberOps(guid, AllocateNumberPoolActors(guid)(system))
LogManager.getLogManager.reset() //suppresses any internal loggers created by the above elements
(guid, uns, taskResolver, TestProbe())
(guid, uns, TestProbe())
}
/**
* @see `UniqueNumberSystem.AllocateNumberPoolActors(NumberPoolHub)(implicit ActorContext)`
* @see `UniqueNumberSetup.AllocateNumberPoolActors(NumberPoolHub)(implicit ActorContext)`
*/
def AllocateNumberPoolActors(poolSource: NumberPoolHub)(implicit system: ActorSystem): Map[String, ActorRef] = {
poolSource.Pools
.map({
case ((pname, pool)) =>
.map {
case (pname, pool) =>
pname -> system.actorOf(Props(classOf[NumberPoolActor], pool), pname)
})
}
.toMap
}
}

18
src/test/scala/objects/guidtask/GUIDTaskUnregisterAmmoTest.scala
View file

@ -3,20 +3,22 @@ package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.guid.{GUIDTask, TaskBundle, TaskWorkflow}
import scala.concurrent.duration._
class GUIDTaskUnregisterAmmoTest extends ActorTest {
"UnregisterEquipment -> UnregisterObjectTask" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)
guid.register(obj, "dynamic")
val (guid, uns, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)
guid.register(obj, name = "ammo")
assert(obj.HasGUID)
taskResolver ! TaskResolver.GiveTask(
TaskWorkflow.execute(TaskBundle(
new GUIDTaskTest.RegisterTestTask(probe.ref),
List(GUIDTask.UnregisterEquipment(obj)(uns))
)
probe.expectMsg(scala.util.Success)
GUIDTask.unregisterEquipment(uns, obj)
))
probe.expectMsg(5.second, scala.util.Success(true))
assert(!obj.HasGUID)
}
}

Some files were not shown because too many files have changed in this diff Show more