PSForever/PSF-BotServer
1
0
Fork 0
mirror of https://github.com/2revoemag/PSF-BotServer.git synced 2026-02-13 19:53:38 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Facility Turrets (#223)

Browse source 
* object class, actor class, and definitions for base turrets; untested

* wired base turrets into existence, with hoop jumping; created interface for objects with mounted weapons (vehicles and turrets); working example phalanx_sgl_hevgatcan in Anguta, Ceryshen

* re-wiring manned turrets so that the turreted weapon itself never changes externally but merely identifies different and changes internally; workflow for upgrading wall turrets in place (30s); clarifications and documentation for HackMessage and UseItemMessage; getting rid of orphaned packages from previous location of services

* added a simple task that reverts upgraded manned turrets to their None state after a certain amount of time has passed; it works but need improvement

* turret weapon upgrades now last for a duration of 30 minutes before reverting; created a service support actor base actor that underlies all current support actors; nano-dispenser now properly loads 1 unit of upgrade canister, rather than 100 units; all canister types have appropriate 2x3 inventory size

* forgot to hurry; moved over the Services tests from main/test folder into the common/test folder and needed to change the location of ActorTest to accommodate it; test and documentation for MannedTurret; codecov ignore update

* wired facility turrets in Anguta, Ceryshen; Akna tower, Ceryshen; and S.Villa tower, home3 (Anguta tower is a watchtower); attempted workaround for Travis CI issues with receiveN; re-introduced RemoveActorTest, at least the first test; expanded how ZoneActor performs tests on MannedTurret setup

* getting rid of useless commented-out code; making common operations for mounting and dismounting

* removed outdated comment; added ResourceSilo tests; added extra test for Zone
This commit is contained in:
Fate-JH 2018-07-14 21:25:44 -04:00 • committed by GitHub
parent 61a51c1dd1
commit b81ff2bbf4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
75 changed files with 2246 additions and 680 deletions
Download patch file Download diff file Expand all files Collapse all files

78
common/src/main/scala/net/psforever/objects/GlobalDefinitions.scala
View file

@ -15,9 +15,11 @@ import net.psforever.objects.serverobject.terminals._
import net.psforever.objects.serverobject.tube.SpawnTubeDefinition
import net.psforever.objects.serverobject.resourcesilo.ResourceSiloDefinition
import net.psforever.objects.ballistics.{DamageType, Projectiles}
import net.psforever.objects.serverobject.turret.{MannedTurretDefinition, TurretUpgrade}
import net.psforever.objects.vehicles.{SeatArmorRestriction, UtilityType}
import net.psforever.types.PlanetSideEmpire
import scala.collection.mutable
import scala.concurrent.duration._
object GlobalDefinitions {
@ -414,11 +416,11 @@ object GlobalDefinitions {
val upgrade_canister = AmmoBoxDefinition(Ammo.upgrade_canister)
val trek_ammo = AmmoBoxDefinition(Ammo.trek_ammo)
//
val bullet_35mm = AmmoBoxDefinition(Ammo.bullet_35mm) //liberator nosegun
val ancient_ammo_vehicle = AmmoBoxDefinition(Ammo.ancient_ammo_vehicle)
//
val aphelion_laser_ammo = AmmoBoxDefinition(Ammo.aphelion_laser_ammo)
val aphelion_immolation_cannon_ammo = AmmoBoxDefinition(Ammo.aphelion_immolation_cannon_ammo)
@ -488,6 +490,8 @@ object GlobalDefinitions {
val peregrine_sparrow_ammo = AmmoBoxDefinition(Ammo.peregrine_sparrow_ammo)
val bullet_150mm = AmmoBoxDefinition(Ammo.bullet_150mm)
val phalanx_ammo = AmmoBoxDefinition(Ammo.phalanx_ammo)
init_ammo()
val chainblade = ToolDefinition(ObjectClass.chainblade)
@ -722,6 +726,12 @@ object GlobalDefinitions {
val galaxy_gunship_tailgun = ToolDefinition(ObjectClass.galaxy_gunship_tailgun)
val galaxy_gunship_gun = ToolDefinition(ObjectClass.galaxy_gunship_gun)
val phalanx_sgl_hevgatcan = ToolDefinition(ObjectClass.phalanx_sgl_hevgatcan)
val phalanx_avcombo = ToolDefinition(ObjectClass.phalanx_avcombo)
val phalanx_flakcombo = ToolDefinition(ObjectClass.phalanx_flakcombo)
init_tools()
/*
@ -849,6 +859,18 @@ object GlobalDefinitions {
val resource_silo = new ResourceSiloDefinition
val manned_turret = new MannedTurretDefinition(480) {
Name = "manned_turret"
MaxHealth = 3600
Weapons += 1 -> new mutable.HashMap()
Weapons(1) += TurretUpgrade.None -> phalanx_sgl_hevgatcan
Weapons(1) += TurretUpgrade.AVCombo -> phalanx_avcombo
Weapons(1) += TurretUpgrade.FlakCombo -> phalanx_flakcombo
MountPoints += 1 -> 0
FactionLocked = true
ReserveAmmunition = false
}
/**
* Given a faction, provide the standard assault melee weapon.
* @param faction the faction
@ -1352,15 +1374,15 @@ object GlobalDefinitions {
health_canister.Name = "health_canister"
health_canister.Capacity = 100
health_canister.Tile = InventoryTile.Tile33
health_canister.Tile = InventoryTile.Tile23
armor_canister.Name = "armor_canister"
armor_canister.Capacity = 100
armor_canister.Tile = InventoryTile.Tile33
armor_canister.Tile = InventoryTile.Tile23
upgrade_canister.Name = "upgrade_canister"
upgrade_canister.Capacity = 100
upgrade_canister.Tile = InventoryTile.Tile33
upgrade_canister.Capacity = 1
upgrade_canister.Tile = InventoryTile.Tile23
trek_ammo.Name = "trek_ammo"
trek_ammo.Size = EquipmentSize.Blocked
@ -1508,6 +1530,10 @@ object GlobalDefinitions {
bullet_150mm.Name = "bullet_150mm"
bullet_150mm.Capacity = 50
bullet_150mm.Tile = InventoryTile.Tile44
phalanx_ammo.Name = "phalanx_ammo"
phalanx_ammo.Capacity = 4000 //sufficient for a reload
phalanx_ammo.Size = EquipmentSize.Inventory
}
/**
@ -3743,6 +3769,7 @@ object GlobalDefinitions {
nano_dispenser.FireModes.head.AmmoTypeIndices += 1
nano_dispenser.FireModes.head.AmmoSlotIndex = 0
nano_dispenser.FireModes.head.Magazine = 100
nano_dispenser.FireModes.head.CustomMagazine = Ammo.upgrade_canister -> 1
nano_dispenser.FireModes.head.Modifiers.Damage1 = 20
nano_dispenser.FireModes.head.Modifiers.Damage4 = 20
nano_dispenser.Tile = InventoryTile.Tile63
@ -4297,6 +4324,45 @@ object GlobalDefinitions {
galaxy_gunship_gun.FireModes.head.AmmoTypeIndices += 0
galaxy_gunship_gun.FireModes.head.AmmoSlotIndex = 0
galaxy_gunship_gun.FireModes.head.Magazine = 200
phalanx_sgl_hevgatcan.Name = "phalanx_sgl_hevgatcan"
phalanx_sgl_hevgatcan.Size = EquipmentSize.BaseTurretWeapon
phalanx_sgl_hevgatcan.AmmoTypes += phalanx_ammo
phalanx_sgl_hevgatcan.ProjectileTypes += phalanx_projectile
phalanx_sgl_hevgatcan.FireModes += new InfiniteFireModeDefinition
phalanx_sgl_hevgatcan.FireModes.head.AmmoTypeIndices += 0
phalanx_sgl_hevgatcan.FireModes.head.AmmoSlotIndex = 0
phalanx_sgl_hevgatcan.FireModes.head.Magazine = 4000
phalanx_avcombo.Name = "phalanx_avcombo"
phalanx_avcombo.Size = EquipmentSize.BaseTurretWeapon
phalanx_avcombo.AmmoTypes += phalanx_ammo
phalanx_avcombo.ProjectileTypes += phalanx_projectile
phalanx_avcombo.ProjectileTypes += phalanx_av_projectile
phalanx_avcombo.FireModes += new InfiniteFireModeDefinition
phalanx_avcombo.FireModes.head.AmmoTypeIndices += 0
phalanx_avcombo.FireModes.head.AmmoSlotIndex = 0
phalanx_avcombo.FireModes.head.Magazine = 4000
phalanx_avcombo.FireModes += new InfiniteFireModeDefinition
phalanx_avcombo.FireModes(1).AmmoTypeIndices += 0
phalanx_avcombo.FireModes(1).ProjectileTypeIndices += 1
phalanx_avcombo.FireModes(1).AmmoSlotIndex = 0
phalanx_avcombo.FireModes(1).Magazine = 4000
phalanx_flakcombo.Name = "phalanx_flakcombo"
phalanx_flakcombo.Size = EquipmentSize.BaseTurretWeapon
phalanx_flakcombo.AmmoTypes += phalanx_ammo
phalanx_flakcombo.ProjectileTypes += phalanx_projectile
phalanx_flakcombo.ProjectileTypes += phalanx_flak_projectile
phalanx_flakcombo.FireModes += new InfiniteFireModeDefinition
phalanx_flakcombo.FireModes.head.AmmoTypeIndices += 0
phalanx_flakcombo.FireModes.head.AmmoSlotIndex = 0
phalanx_flakcombo.FireModes.head.Magazine = 4000
phalanx_flakcombo.FireModes += new InfiniteFireModeDefinition
phalanx_flakcombo.FireModes(1).AmmoTypeIndices += 0
phalanx_flakcombo.FireModes(1).ProjectileTypeIndices += 1
phalanx_flakcombo.FireModes(1).AmmoSlotIndex = 0
phalanx_flakcombo.FireModes(1).Magazine = 4000
}
/**

35
common/src/main/scala/net/psforever/objects/Tool.scala
View file

@ -21,24 +21,26 @@ class Tool(private val toolDef : ToolDefinition) extends Equipment with FireMode
/** index of the current fire mode on the `ToolDefinition`'s list of fire modes */
private var fireModeIndex : Int = 0
/** current ammunition slot being used by this fire mode */
private val ammoSlots : List[Tool.FireModeSlot] = Tool.LoadDefinition(this)
private var ammoSlots : List[Tool.FireModeSlot] = List.empty
Tool.LoadDefinition(this)
def FireModeIndex : Int = fireModeIndex
def FireModeIndex_=(index : Int) : Int = {
fireModeIndex = index % toolDef.FireModes.length
fireModeIndex = index % Definition.FireModes.length
FireModeIndex
}
def FireMode : FireModeDefinition = toolDef.FireModes(fireModeIndex)
def FireMode : FireModeDefinition = Definition.FireModes(fireModeIndex)
def NextFireMode : FireModeDefinition = {
FireModeIndex = toolDef.NextFireModeIndex(FireModeIndex)
FireModeIndex = Definition.NextFireModeIndex(FireModeIndex)
AmmoSlot.Chamber = FireMode.Chamber
FireMode
}
def ToFireMode : Int = toolDef.NextFireModeIndex(FireModeIndex)
def ToFireMode : Int = Definition.NextFireModeIndex(FireModeIndex)
def ToFireMode_=(index : Int) : FireModeDefinition = {
FireModeIndex = index
@ -53,7 +55,7 @@ class Tool(private val toolDef : ToolDefinition) extends Equipment with FireMode
AmmoTypeIndex
}
def AmmoType : Ammo.Value = toolDef.AmmoTypes(AmmoTypeIndex).AmmoType
def AmmoType : Ammo.Value = Definition.AmmoTypes(AmmoTypeIndex).AmmoType
def NextAmmoType : Ammo.Value = {
AmmoSlot.AmmoTypeIndex = AmmoSlot.AmmoTypeIndex + 1
@ -61,7 +63,7 @@ class Tool(private val toolDef : ToolDefinition) extends Equipment with FireMode
}
def Projectile : ProjectileDefinition = {
toolDef.ProjectileTypes({
Definition.ProjectileTypes({
val projIndices = FireMode.ProjectileTypeIndices
if(projIndices.isEmpty) {
AmmoTypeIndex //e.g., bullet_9mm -> bullet_9mm_projectile, bullet_9mm_AP -> bullet_9mm_AP_projectile
@ -77,11 +79,20 @@ class Tool(private val toolDef : ToolDefinition) extends Equipment with FireMode
def Magazine : Int = AmmoSlot.Magazine
def Magazine_=(mag : Int) : Int = {
AmmoSlot.Magazine = Math.min(Math.max(0, mag), MaxMagazine)
//AmmoSlot.Magazine = Math.min(Math.max(0, mag), MaxMagazine)
AmmoSlot.Magazine = Math.max(0, mag)
Magazine
}
def MaxMagazine : Int = FireMode.Magazine
def MaxMagazine : Int = {
val fmode = FireMode
fmode.CustomMagazine.get(AmmoType) match {
case Some(magSize) =>
magSize
case None =>
fmode.Magazine
}
}
def Discharge : Int = {
Magazine = FireMode.Discharge(this)
@ -98,6 +109,8 @@ class Tool(private val toolDef : ToolDefinition) extends Equipment with FireMode
override def toString : String = Tool.toString(this)
}
//AmmoType = Definition.AmmoTypes( (Definition.FireModes(fireModeIndex)).AmmoTypeIndices( (ammoSlots((Definition.FireModes(fireModeIndex)).AmmoSlotIndex)).AmmoTypeIndex) ).AmmoType
object Tool {
def apply(toolDef : ToolDefinition) : Tool = {
new Tool(toolDef)
@ -107,10 +120,10 @@ object Tool {
* Use the `*Definition` that was provided to this object to initialize its fields and settings.
* @param tool the `Tool` being initialized
*/
def LoadDefinition(tool : Tool) : List[FireModeSlot] = {
def LoadDefinition(tool : Tool) : Unit = {
val tdef : ToolDefinition = tool.Definition
val maxSlot = tdef.FireModes.maxBy(fmode => fmode.AmmoSlotIndex).AmmoSlotIndex
buildFireModes(tdef, (0 to maxSlot).iterator, tdef.FireModes.toList)
tool.ammoSlots = buildFireModes(tdef, (0 to maxSlot).iterator, tdef.FireModes.toList)
}
@tailrec private def buildFireModes(tdef : ToolDefinition, iter : Iterator[Int], fmodes : List[FireModeDefinition], list : List[FireModeSlot] = Nil) : List[FireModeSlot] = {

33
common/src/main/scala/net/psforever/objects/Vehicle.scala
View file

@ -65,6 +65,7 @@ import scala.annotation.tailrec
class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServerObject
with FactionAffinity
with Mountable
with MountedWeapons
with Deployment
with Container {
private var faction : PlanetSideEmpire.Value = PlanetSideEmpire.TR
@ -371,38 +372,6 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ
}
}
/**
* Given a valid seat number, retrieve an index where the weapon controlled from this seat is mounted.
* @param seatNumber the seat number
* @return a mounted weapon by index, or `None` if either the seat doesn't exist or there is no controlled weapon
*/
def WeaponControlledFromSeat(seatNumber : Int) : Option[Equipment] = {
Seat(seatNumber) match {
case Some(seat) =>
wepFromSeat(seat)
case None =>
None
}
}
private def wepFromSeat(seat : Seat) : Option[Equipment] = {
seat.ControlledWeapon match {
case Some(index) =>
wepFromSeat(index)
case None =>
None
}
}
private def wepFromSeat(wepIndex : Int) : Option[Equipment] = {
weapons.get(wepIndex) match {
case Some(wep) =>
wep.Equipment
case None =>
None
}
}
def Utilities : Map[Int, Utility] = utilities
/**

1
common/src/main/scala/net/psforever/objects/equipment/EquipmentSize.scala
View file

@ -9,6 +9,7 @@ object EquipmentSize extends Enumeration {
Rifle, //6x3 and 9x3
Max, //max weapon only
VehicleWeapon, //vehicle-mounted weapons
BaseTurretWeapon, //common phalanx cannons, and cavern turrets
BFRArmWeapon, //duel arm weapons for bfr
BFRGunnerWeapon, //gunner seat for bfr
Inventory //reserved

11
common/src/main/scala/net/psforever/objects/equipment/FireModeDefinition.scala
View file

@ -18,6 +18,9 @@ class FireModeDefinition {
private var ammoSlotIndex : Int = 0
/** how many rounds are replenished each reload cycle */
private var magazine : Int = 1
/** how many rounds are replenished each reload cycle, per type of ammunition loaded
* key - ammo type index, value - magazine capacity*/
private val customAmmoMagazine : mutable.HashMap[Ammo.Value, Int] = mutable.HashMap[Ammo.Value, Int]()
/** how much is subtracted from the magazine each fire cycle;
* most weapons will only fire 1 round per fire cycle; the flamethrower in fire mode 1 fires 50 */
private var rounds : Int = 1
@ -53,6 +56,14 @@ class FireModeDefinition {
Magazine
}
def CustomMagazine : mutable.HashMap[Ammo.Value, Int] = customAmmoMagazine
def CustomMagazine_=(kv : (Ammo.Value, Int)) : mutable.HashMap[Ammo.Value, Int] = {
val (ammoTypeIndex, cap) = kv
customAmmoMagazine += ammoTypeIndex -> cap
CustomMagazine
}
def Rounds : Int = rounds
def Rounds_=(round : Int) : Int = {

2
common/src/main/scala/net/psforever/objects/serverobject/resourcesilo/ResourceSilo.scala
View file

@ -82,4 +82,4 @@ object ResourceSilo {
obj.Actor ! "startup"
obj
}
}
}

224
common/src/main/scala/net/psforever/objects/serverobject/turret/MannedTurret.scala Normal file
View file

@ -0,0 +1,224 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.serverobject.turret
import net.psforever.objects.{EquipmentSlot, Player}
import net.psforever.objects.definition.SeatDefinition
import net.psforever.objects.equipment.Equipment
import net.psforever.objects.inventory.{Container, GridInventory}
import net.psforever.objects.serverobject.affinity.FactionAffinity
import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.serverobject.structures.Amenity
import net.psforever.objects.serverobject.turret.MannedTurret.MannedTurretWeapon
import net.psforever.objects.vehicles.{MountedWeapons, Seat => Chair}
class MannedTurret(tDef : MannedTurretDefinition) extends Amenity
with FactionAffinity
with Mountable
with MountedWeapons
with Container {
private var health : Int = 1
private var jammered : Boolean = false
/** manned turrets have just one seat; this is just standard interface */
private val seats : Map[Int, Chair] = Map(0 -> Chair(new SeatDefinition() { ControlledWeapon = Some(1) }))
/** manned turrets have just one weapon; this is just standard interface */
private var weapons : Map[Int, EquipmentSlot] = Map.empty
/** may or may not have inaccessible inventory space
* see `ReserveAmmunition` in the definition */
private val inventory : GridInventory = new GridInventory() {
import net.psforever.packet.game.PlanetSideGUID
override def Remove(index : Int) : Boolean = false
override def Remove(guid : PlanetSideGUID) : Boolean = false
}
/** some turrets can be updated; they all start without updates */
private var upgradePath : TurretUpgrade.Value = TurretUpgrade.None
MannedTurret.LoadDefinition(this)
def Health : Int = {
health
}
def Health_=(toHealth : Int) : Int = {
health = toHealth
health
}
def MaxHealth : Int = {
Definition.MaxHealth
}
def Seats : Map[Int, Chair] = seats
def Seat(seatNum : Int) : Option[Chair] = seats.get(seatNum)
/**
* Given the index of an entry mounting point, return the infantry-accessible `Seat` associated with it.
* @param mountPoint an index representing the seat position / mounting point
* @return a seat number, or `None`
*/
def GetSeatFromMountPoint(mountPoint : Int) : Option[Int] = {
Definition.MountPoints.get(mountPoint)
}
def MountPoints : Map[Int, Int] = Definition.MountPoints.toMap
def PassengerInSeat(user : Player) : Option[Int] = {
if(seats(0).Occupant.contains(user)) {
Some(0)
}
else {
None
}
}
def Weapons : Map[Int, EquipmentSlot] = weapons.filter({ case(index, _) => index < 2 })
def ControlledWeapon(wepNumber : Int) : Option[Equipment] = {
if(VisibleSlots.contains(wepNumber)) {
weapons(wepNumber).Equipment
}
else {
None
}
}
def Inventory : GridInventory = inventory
def VisibleSlots : Set[Int] = Set(1)
def Upgrade : TurretUpgrade.Value = upgradePath
def Upgrade_=(upgrade : TurretUpgrade.Value) : TurretUpgrade.Value = {
upgradePath = upgrade
//upgrade each weapon as long as that weapon has a valid option for that upgrade
Definition.Weapons.foreach({ case(index, upgradePaths) =>
if(upgradePaths.contains(upgrade)) {
weapons(index).Equipment.get.asInstanceOf[MannedTurretWeapon].Upgrade = upgrade
}
})
Upgrade
}
def Jammered : Boolean = jammered
def Jammered_=(jamState : Boolean) : Boolean = {
jammered = jamState
Jammered
}
def Definition : MannedTurretDefinition = tDef
}
object MannedTurret {
/**
* Overloaded constructor.
* @param tDef the `ObjectDefinition` that constructs this object and maintains some of its immutable fields
* @return a `MannedTurret` object
*/
def apply(tDef : MannedTurretDefinition) : MannedTurret = {
new MannedTurret(tDef)
}
/**
* Use the `*Definition` that was provided to this object to initialize its fields and settings.
* @param turret the `MannedTurret` being initialized
* @see `{object}.LoadDefinition`
*/
def LoadDefinition(turret : MannedTurret) : MannedTurret = {
import net.psforever.objects.equipment.EquipmentSize.BaseTurretWeapon
val tdef : MannedTurretDefinition = turret.Definition
//general stuff
turret.Health = tdef.MaxHealth
//create weapons; note the class
turret.weapons = tdef.Weapons.map({case (num, upgradePaths) =>
val slot = EquipmentSlot(BaseTurretWeapon)
slot.Equipment = new MannedTurretWeapon(tdef, upgradePaths.toMap)
num -> slot
}).toMap
//special inventory ammunition object(s)
if(tdef.ReserveAmmunition) {
val allAmmunitionTypes = tdef.Weapons.values.flatMap{ _.values.flatMap { _.AmmoTypes } }.toSet
if(allAmmunitionTypes.nonEmpty) {
turret.inventory.Resize(allAmmunitionTypes.size, 1)
var i : Int = 0
allAmmunitionTypes.foreach(ammotype => {
turret.inventory.InsertQuickly(i, new TurretAmmoBox(ammotype))
i += 1
})
}
}
turret
}
import net.psforever.objects.definition.ToolDefinition
import net.psforever.objects.Tool
/**
* A stateful weapon that is mounted in `MannedTurrets`
* and may maintains a group of upgraded forms that can by swapped
* without reconstructing the weapon object itself or managing object registration.
* @param mdef the turret's definition
* @param udefs a map of turret upgrades to tool definitions that would be constructed by this weapon
* @param default the default upgrade state;
* defaults to `None`
*/
private class MannedTurretWeapon(mdef : MannedTurretDefinition, udefs : Map[TurretUpgrade.Value, ToolDefinition], default : TurretUpgrade.Value = TurretUpgrade.None)
extends Tool(udefs(default)) {
private var upgradePath : TurretUpgrade.Value = default
def Upgrade : TurretUpgrade.Value = {
/*
Must check `not null` due to how this object's `Definition` will be called during `Tool`'s constructor
before the internal value can be set to default value `None`
*/
Option(upgradePath) match {
case Some(value) =>
value
case None =>
default
}
}
def Upgrade_=(upgrade : TurretUpgrade.Value) : TurretUpgrade.Value = {
if(udefs.contains(upgrade)) {
val beforeUpgrade = upgradePath
upgradePath = upgrade
if(beforeUpgrade != upgradePath) {
Tool.LoadDefinition(this) //rebuild weapon internal structure
FireModeIndex = 0 //reset fire mode; this option is always valid
}
}
Upgrade
}
override def Definition = udefs(Upgrade)
}
import net.psforever.objects.definition.AmmoBoxDefinition
import net.psforever.objects.AmmoBox
/**
* A special type of ammunition box contained within a `MannedTurret` for the purposes of infinite reloads.
* The original quantity of ammunition does not change.
* @param adef ammunition definition
*/
private class TurretAmmoBox(private val adef : AmmoBoxDefinition) extends AmmoBox(adef, Some(65535)) {
import net.psforever.objects.inventory.InventoryTile
override def Tile = InventoryTile.Tile11
override def Capacity_=(toCapacity : Int) = Capacity
}
import akka.actor.ActorContext
/**
* Instantiate an configure a `MannedTurret` object
* @param id the unique id that will be assigned to this entity
* @param context a context to allow the object to properly set up `ActorSystem` functionality
* @return the `MannedTurret` object
*/
def Constructor(tdef : MannedTurretDefinition)(id : Int, context : ActorContext) : MannedTurret = {
import akka.actor.Props
val obj = MannedTurret(tdef)
obj.Actor = context.actorOf(Props(classOf[MannedTurretControl], obj), s"${tdef.Name}_$id")
obj
}
}

43
common/src/main/scala/net/psforever/objects/serverobject/turret/MannedTurretControl.scala Normal file
View file

@ -0,0 +1,43 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.serverobject.turret
import akka.actor.Actor
import net.psforever.objects.serverobject.mount.{Mountable, MountableBehavior}
import net.psforever.objects.serverobject.affinity.{FactionAffinity, FactionAffinityBehavior}
/**
* An `Actor` that handles messages being dispatched to a specific `MannedTurret`.<br>
* <br>
* Mounted turrets have only slightly different entry requirements than a normal vehicle
* because they encompass both faction-specific facility turrets
* and faction-blind cavern sentry turrets.
* @param turret the `MannedTurret` object being governed
*/
class MannedTurretControl(turret : MannedTurret) extends Actor
with FactionAffinityBehavior.Check
with MountableBehavior.Dismount {
def MountableObject = turret //do not add type!
def FactionObject : FactionAffinity = turret
def receive : Receive = checkBehavior
.orElse(dismountBehavior)
.orElse {
case Mountable.TryMount(user, seat_num) =>
turret.Seat(seat_num) match {
case Some(seat) =>
if((!turret.Definition.FactionLocked || user.Faction == turret.Faction) &&
(seat.Occupant = user).contains(user)) {
user.VehicleSeated = turret.GUID
sender ! Mountable.MountMessages(user, Mountable.CanMount(turret, seat_num))
}
else {
sender ! Mountable.MountMessages(user, Mountable.CanNotMount(turret, seat_num))
}
case None =>
sender ! Mountable.MountMessages(user, Mountable.CanNotMount(turret, seat_num))
}
case _ => ;
}
}

53
common/src/main/scala/net/psforever/objects/serverobject/turret/MannedTurretDefinition.scala Normal file
View file

@ -0,0 +1,53 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.serverobject.turret
import net.psforever.objects.definition.{ObjectDefinition, ToolDefinition}
import net.psforever.objects.vehicles.Turrets
import scala.collection.mutable
/**
* The definition for any `MannedTurret`.
* @param objectId the object's identifier number
*/
class MannedTurretDefinition(private val objectId : Int) extends ObjectDefinition(objectId) {
Turrets(objectId) //let throw NoSuchElementException
private var maxHealth : Int = 100
/* key - entry point index, value - seat index */
private val mountPoints : mutable.HashMap[Int, Int] = mutable.HashMap()
/* key - seat number, value - hash map (below) */
/* key - upgrade, value - weapon definition */
private val weapons : mutable.HashMap[Int, mutable.HashMap[TurretUpgrade.Value, ToolDefinition]] =
mutable.HashMap[Int, mutable.HashMap[TurretUpgrade.Value, ToolDefinition]]()
/** can only be mounted by owning faction when `true` */
private var factionLocked : Boolean = true
/** creates internal ammunition reserves that can not become depleted
* see `MannedTurret.TurretAmmoBox` for details */
private var hasReserveAmmunition : Boolean = false
def MaxHealth : Int = maxHealth
def MaxHealth_=(health : Int) : Int = {
maxHealth = health
MaxHealth
}
def MountPoints : mutable.HashMap[Int, Int] = mountPoints
def Weapons : mutable.HashMap[Int, mutable.HashMap[TurretUpgrade.Value, ToolDefinition]] = weapons
def FactionLocked : Boolean = factionLocked
def FactionLocked_=(ownable : Boolean) : Boolean = {
factionLocked = ownable
FactionLocked
}
def ReserveAmmunition : Boolean = hasReserveAmmunition
def ReserveAmmunition_=(reserved : Boolean) : Boolean = {
hasReserveAmmunition = reserved
ReserveAmmunition
}
}

13
common/src/main/scala/net/psforever/objects/serverobject/turret/TurretUpgrade.scala Normal file
View file

@ -0,0 +1,13 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.serverobject.turret
/**
* An `Enumeration` of the available turret upgrade states.
*/
object TurretUpgrade extends Enumeration {
val
None, //default, always
AVCombo, //phalanx_avcombo
FlakCombo //phalanx_flakcombo
= Value
}

39
common/src/main/scala/net/psforever/objects/vehicles/MountedWeapons.scala Normal file
View file

@ -0,0 +1,39 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.vehicles
import net.psforever.objects.{EquipmentSlot, PlanetSideGameObject}
import net.psforever.objects.equipment.Equipment
import net.psforever.objects.inventory.Container
import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.vehicles.{Seat => Chair}
trait MountedWeapons {
this : PlanetSideGameObject with Mountable with Container =>
def Weapons : Map[Int, EquipmentSlot]
/**
* Given a valid seat number, retrieve an index where the weapon controlled from this seat is mounted.
* @param seatNumber the seat number
* @return a mounted weapon by index, or `None` if either the seat doesn't exist or there is no controlled weapon
*/
def WeaponControlledFromSeat(seatNumber : Int) : Option[Equipment] = {
Seat(seatNumber) match {
case Some(seat) =>
wepFromSeat(seat)
case None =>
None
}
}
private def wepFromSeat(seat : Chair) : Option[Equipment] = {
seat.ControlledWeapon match {
case Some(index) =>
ControlledWeapon(index)
case None =>
None
}
}
def ControlledWeapon(wepNumber : Int) : Option[Equipment]
}

10
common/src/main/scala/net/psforever/objects/vehicles/Turrets.scala Normal file
View file

@ -0,0 +1,10 @@
// Copyright (c) 2017 PSForever
package net.psforever.objects.vehicles
/**
* An `Enumeration` of all the turret type objectss in the game, paired with their object id as the `Value`.
*/
object Turrets extends Enumeration {
val manned_turret = Value(480)
val vanu_sentry_turret = Value(943)
}

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

@ -12,6 +12,7 @@ import net.psforever.objects.guid.selector.RandomSelector
import net.psforever.objects.guid.source.LimitedNumberSource
import net.psforever.objects.serverobject.structures.{Amenity, Building}
import net.psforever.objects.serverobject.tube.SpawnTube
import net.psforever.objects.serverobject.turret.MannedTurret
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.Vector3
@ -93,7 +94,8 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
transport = context.actorOf(Props(classOf[ZoneVehicleActor], this, vehicles), s"$Id-vehicles")
population = context.actorOf(Props(classOf[ZonePopulationActor], this, players, corpses), s"$Id-players")
Map.LocalObjects.foreach({ builderObject => builderObject.Build })
BuildLocalObjects(context, guid)
BuildSupportObjects()
MakeBuildings(context)
AssignAmenities()
CreateSpawnGroups()
@ -279,6 +281,39 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) {
buildings.get(id)
}
private def BuildLocalObjects(implicit context : ActorContext, guid : NumberPoolHub) : Unit = {
Map.LocalObjects.foreach({ builderObject => builderObject.Build })
}
private def BuildSupportObjects() : Unit = {
//guard against errors here, but don't worry about specifics; let ZoneActor.ZoneSetupCheck complain about problems
//turret to weapon
Map.TurretToWeapon.foreach({ case ((turret_guid, weapon_guid)) =>
((GUID(turret_guid) match {
case Some(obj : MannedTurret) =>
Some(obj)
case _ => ;
None
}) match {
case Some(obj) =>
obj.Weapons.get(1) match {
case Some(slot) =>
Some(obj, slot.Equipment)
case None =>
None
}
case None =>
None
}) match {
case Some((obj, Some(weapon : Tool))) =>
guid.register(weapon, weapon_guid)
weapon.AmmoSlots.foreach(slot => guid.register(slot.Box, "dynamic"))
obj.Inventory.Items.foreach(item => guid.register(item.obj, "dynamic")) //internal ammunition reserves, if any
case _ => ;
}
})
}
private def MakeBuildings(implicit context : ActorContext) : PairMap[Int, Building] = {
val buildingList = Map.LocalBuildings
buildings = buildingList.map({case(building_id, constructor) => building_id -> constructor.Build(building_id, this) })

87
common/src/main/scala/net/psforever/objects/zones/ZoneActor.scala
View file

@ -4,7 +4,7 @@ package net.psforever.objects.zones
import java.util.concurrent.atomic.AtomicInteger
import akka.actor.Actor
import net.psforever.objects.{GlobalDefinitions, PlanetSideGameObject}
import net.psforever.objects.{GlobalDefinitions, PlanetSideGameObject, Tool}
import net.psforever.objects.serverobject.structures.StructureType
import net.psforever.objects.serverobject.tube.SpawnTube
import net.psforever.objects.vehicles.UtilityType
@ -171,73 +171,24 @@ class ZoneActor(zone : Zone) extends Actor {
validateObject(mech_guid, ImplantMechCheck, "implant terminal mech")
validateObject(interface_guid, TerminalCheck, "implant terminal interface")
})
//check manned turret to weapon association
map.TurretToWeapon.foreach({ case ((turret_guid, weapon_guid)) =>
validateObject(turret_guid, MannedTurretCheck, "manned turret mount")
if(validateObject(weapon_guid, WeaponCheck, "manned turret weapon")) {
if(guid(weapon_guid).get.asInstanceOf[Tool].AmmoSlots.count(!_.Box.HasGUID) > 0) {
slog.error(s"expected weapon $weapon_guid has an unregistered ammunition unit")
errors.incrementAndGet()
}
}
})
//output number of errors
errors.intValue()
}
}
object ZoneActor {
// import net.psforever.types.PlanetSideEmpire
// import net.psforever.objects.Vehicle
// import net.psforever.objects.serverobject.structures.Building
// def AllSpawnGroup(zone : Zone, targetPosition : Vector3, targetFaction : PlanetSideEmpire.Value) : Option[List[SpawnTube]] = {
// ClosestOwnedSpawnTube(AmsSpawnGroup(zone) ++ BuildingSpawnGroup(zone, 0), targetPosition, targetFaction)
// }
//
// def AmsSpawnGroup(vehicles : List[Vehicle]) : Iterable[(Vector3, PlanetSideEmpire.Value, Iterable[SpawnTube])] = {
// vehicles
// .filter(veh => veh.DeploymentState == DriveState.Deployed && veh.Definition == GlobalDefinitions.ams)
// .map(veh =>
// (veh.Position, veh.Faction,
// veh.Utilities
// .values
// .filter(util => util.UtilType == UtilityType.ams_respawn_tube)
// .map { _().asInstanceOf[SpawnTube] }
// )
// )
// }
//
// def AmsSpawnGroup(zone : Zone, spawn_group : Int = 2) : Iterable[(Vector3, PlanetSideEmpire.Value, Iterable[SpawnTube])] = {
// if(spawn_group == 2) {
// AmsSpawnGroup(zone.Vehicles)
// }
// else {
// Nil
// }
// }
//
// def BuildingSpawnGroup(spawnGroups : Map[Building, List[SpawnTube]]) : Iterable[(Vector3, PlanetSideEmpire.Value, Iterable[SpawnTube])] = {
// spawnGroups
// .map({ case ((building, tubes)) => (building.Position.xy, building.Faction, tubes) })
// }
//
// def BuildingSpawnGroup(zone : Zone, spawn_group : Int) : Iterable[(Vector3, PlanetSideEmpire.Value, Iterable[SpawnTube])] = {
// val buildingTypeSet = if(spawn_group == 0) {
// Set(StructureType.Facility, StructureType.Tower, StructureType.Building)
// }
// else if(spawn_group == 6) {
// Set(StructureType.Tower)
// }
// else if(spawn_group == 7) {
// Set(StructureType.Facility, StructureType.Building)
// }
// else {
// Set.empty[StructureType.Value]
// }
// BuildingSpawnGroup(
// zone.SpawnGroups().filter({ case((building, _)) => buildingTypeSet.contains(building.BuildingType) })
// )
// }
//
// def ClosestOwnedSpawnTube(tubes : Iterable[(Vector3, PlanetSideEmpire.Value, Iterable[SpawnTube])], targetPosition : Vector3, targetFaction : PlanetSideEmpire.Value) : Option[List[SpawnTube]] = {
// tubes
// .toSeq
// .filter({ case (_, faction, _) => faction == targetFaction })
// .sortBy({ case (pos, _, _) => Vector3.DistanceSquared(pos, targetPosition) })
// .take(1)
// .map({ case (_, _, tubes : List[SpawnTube]) => tubes })
// .headOption
// }
/**
* Recover an object from a collection and perform any number of validating tests upon it.
* If the object fails any tests, log an error.
@ -295,4 +246,14 @@ object ZoneActor {
import net.psforever.objects.serverobject.pad.VehicleSpawnPad
obj.isInstanceOf[VehicleSpawnPad]
}
def MannedTurretCheck(obj : PlanetSideGameObject) : Boolean = {
import net.psforever.objects.serverobject.turret.MannedTurret
obj.isInstanceOf[MannedTurret]
}
def WeaponCheck(obj : PlanetSideGameObject) : Boolean = {
import net.psforever.objects.Tool
obj.isInstanceOf[Tool]
}
}

7
common/src/main/scala/net/psforever/objects/zones/ZoneMap.scala
View file

@ -26,6 +26,7 @@ import net.psforever.objects.serverobject.{PlanetSideServerObject, ServerObjectB
*/
class ZoneMap(private val name : String) {
private var localObjects : List[ServerObjectBuilder[_]] = List()
private var linkTurretWeapon : Map[Int, Int] = Map()
private var linkTerminalPad : Map[Int, Int] = Map()
private var linkTerminalInterface : Map[Int, Int] = Map()
private var linkDoorLock : Map[Int, Int] = Map()
@ -87,4 +88,10 @@ class ZoneMap(private val name : String) {
def TerminalToInterface(interface_guid : Int, terminal_guid : Int) : Unit = {
linkTerminalInterface = linkTerminalInterface ++ Map(interface_guid -> terminal_guid)
}
def TurretToWeapon : Map[Int, Int] = linkTurretWeapon
def TurretToWeapon(turret_guid : Int, weapon_guid : Int) : Unit = {
linkTurretWeapon = linkTurretWeapon ++ Map(turret_guid -> weapon_guid)
}
}

30
common/src/main/scala/net/psforever/packet/game/HackMessage.scala
View file

@ -33,21 +33,27 @@ object HackState extends Enumeration {
}
/**
* Dispatched by the server to control the process of hacking.<br>
* Dispatched by the server to control the progress of hacking.
* While "hacking" is typically performed against enemy targets,
* some actions that involve ally on ally hacking can occur.
* In this sense, hacking can be consider change progress.<br>
* <br>
* Part of the hacking process is regulated by the server while another part of it is automatically reset by the client.
* The visibility, update, and closing of the hacking progress bar must be handled manually, for each tick.
* When hacking is complete, using the appropriate `HackState` will cue the target to be affected by the hack.
* Terminals and door IFF panels will temporarily expose their functionality;
* the faction association of vehicles will be converted permanently;
* a protracted process of a base conversion will be enacted; etc..
* This transfer of faction association occurs to align the target with the faction of the hacking player (as indicated).
* The client will select the faction without needing to be explicitly told
* and will select the appropriate action to enact upon the target.
* Upon the hack's completion, the target on the client will automatically revert back to its original state, if possible.
* (It will still be necessary to alert this change from the server's perspective.)
* In general, the act of hacking is maintained by the server but the conclusion is managed by the client.
* Hacking typically locks the player into a cancellable firing animation and works as all-or-nothing.
* The progress bar window is displayed and updated each tick by the server; but, the client can cancel it on its own.
* When hacking is complete as indicated by the appropriate `HackState`,
* the client performs the intended action upon the target.
* Facility amenities will temporarily ignore IFF requirements;
* vehicles will permanently transfer control over to the hack-starter's empire;
* facility turret weapons will temporarily convert to their anti-vehicle or anti-aircraft configurations;
* facilities will be compromised and begin the long process of converting to the hack-starter's empire;
* and, so forth.<br>
* <br>
* As mentioned, one of the unexpected uses of this message
* will assist the conversion of allied facility turreted weapons to their upgraded armaments.
* @param unk1 na;
* 0 commonly;
* 2 when performing (phalanx) upgrades;
* 3 for building objects during login phase;
* hack type?
* @param target_guid the target of the hack

39
common/src/main/scala/net/psforever/packet/game/UseItemMessage.scala
View file

@ -7,21 +7,28 @@ import scodec.Codec
import scodec.codecs._
/**
* (Where the child object was before it was moved is not specified or important.)<br>
* @param avatar_guid the player.
* @param item_used_guid The "item" GUID used e.g. a rek to hack or a medkit to heal.
* @param object_guid can be : Door, Terminal, Avatar (medkit).
* @param unk2 ???
* @param unk3 ??? true when use a rek (false when door, medkit or open equip term)
* @param unk4 ???
* @param unk5 ???
* @param unk6 ???
* @param unk7 ??? 25 when door 223 when terminal
* @param unk8 ??? 0 when door 1 when use rek (252 then equipment term)
* @param itemType object ID from game_objects.adb (ex 612 is an equipment terminal, for medkit we have 121 (avatar))
* (Where the child object was before it was moved is not specified or important.)
* @see `Definition.ObjectId`<br>
* `TurretUpgrade`
* @param avatar_guid the player
* @param item_used_guid the item used;
* e.g., a REK to hack, or a medkit to heal
* @param object_guid the object affected;
* e.g., door when opened, terminal when accessed, avatar when medkit used
* @param unk2 na;
* when upgrading phalanx turrets, 1 for `AVCombo` and 2 for `FlakCombo`
* @param unk3 using tools, e.g., a REK or nano-dispenser
* @param unk4 na
* @param unk5 na
* @param unk6 na
* @param unk7 na;
* 25 when door 223 when terminal
* @param unk8 na;
* 0 when door 1 when use rek (252 then equipment term)
* @param object_id he object id for `object_guid`'s object
*/
final case class UseItemMessage(avatar_guid : PlanetSideGUID,
item_used_guid : Int,
item_used_guid : PlanetSideGUID,
object_guid : PlanetSideGUID,
unk2 : Long,
unk3 : Boolean,
@ -30,7 +37,7 @@ final case class UseItemMessage(avatar_guid : PlanetSideGUID,
unk6 : Int,
unk7 : Int,
unk8 : Int,
itemType : Long)
object_id : Long)
extends PlanetSideGamePacket {
type Packet = UseItemMessage
def opcode = GamePacketOpcode.UseItemMessage
@ -40,7 +47,7 @@ final case class UseItemMessage(avatar_guid : PlanetSideGUID,
object UseItemMessage extends Marshallable[UseItemMessage] {
implicit val codec : Codec[UseItemMessage] = (
("avatar_guid" | PlanetSideGUID.codec) ::
("item_used_guid" | uint16L) ::
("item_used_guid" | PlanetSideGUID.codec) ::
("object_guid" | PlanetSideGUID.codec) ::
("unk2" | uint32L) ::
("unk3" | bool) ::
@ -49,6 +56,6 @@ object UseItemMessage extends Marshallable[UseItemMessage] {
("unk6" | uint8L) ::
("unk7" | uint8L) ::
("unk8" | uint8L) ::
("itemType" | uint32L)
("object_id" | uint32L)
).as[UseItemMessage]
}

1
common/src/main/scala/net/psforever/packet/game/objectcreate/ObjectClass.scala
View file

@ -373,6 +373,7 @@ object ObjectClass {
final val implant_terminal_interface = 409
final val locker_container = 456
final val lodestar_repair_terminal = 461
final val manned_turret = 480
final val matrix_terminala = 517
final val matrix_terminalb = 518
final val matrix_terminalc = 519

316
common/src/main/scala/services/RemoverActor.scala
View file

@ -6,8 +6,8 @@ import net.psforever.objects.guid.TaskResolver
import net.psforever.objects.zones.Zone
import net.psforever.objects.{DefaultCancellable, PlanetSideGameObject}
import net.psforever.types.Vector3
import services.support.{SimilarityComparator, SupportActor, SupportActorCaseConversions}
import scala.annotation.tailrec
import scala.concurrent.duration._
/**
@ -29,7 +29,7 @@ import scala.concurrent.duration._
* and finally unregistering it.
* Some types of object have (de-)implementation variations which should be made explicit through the overrides.
*/
abstract class RemoverActor extends Actor {
abstract class RemoverActor extends SupportActor[RemoverActor.Entry] {
/**
* The timer that checks whether entries in the first pool are still eligible for that pool.
*/
@ -50,16 +50,18 @@ abstract class RemoverActor extends Actor {
private var taskResolver : ActorRef = Actor.noSender
private[this] val log = org.log4s.getLogger
def trace(msg : String) : Unit = log.trace(msg)
def debug(msg : String) : Unit = log.debug(msg)
val sameEntryComparator = new SimilarityComparator[RemoverActor.Entry]() {
def Test(entry1 : RemoverActor.Entry, entry2 : RemoverActor.Entry) : Boolean = {
entry1.obj == entry2.obj && entry1.zone == entry2.zone && entry1.obj.GUID == entry2.obj.GUID
}
}
/**
* Send the initial message that requests a task resolver for assisting in the removal process.
*/
override def preStart() : Unit = {
super.preStart()
self ! RemoverActor.Startup()
self ! Service.Startup()
}
/**
@ -82,7 +84,7 @@ abstract class RemoverActor extends Actor {
}
def receive : Receive = {
case RemoverActor.Startup() =>
case Service.Startup() =>
ServiceManager.serviceManager ! ServiceManager.Lookup("taskResolver") //ask for a resolver to deal with the GUID system
case ServiceManager.LookupResult("taskResolver", endpoint) =>
@ -90,83 +92,72 @@ abstract class RemoverActor extends Actor {
context.become(Processing)
case msg =>
log.error(s"received message $msg before being properly initialized")
debug(s"received message $msg before being properly initialized")
}
def Processing : Receive = {
case RemoverActor.AddTask(obj, zone, duration) =>
val entry = RemoverActor.Entry(obj, zone, duration.getOrElse(FirstStandardDuration).toNanos)
if(InclusionTest(entry) && !secondHeap.exists(test => RemoverActor.Similarity(test, entry) )) {
InitialJob(entry)
if(firstHeap.isEmpty) {
//we were the only entry so the event must be started from scratch
firstHeap = List(entry)
trace(s"a remover task has been added: $entry")
RetimeFirstTask()
}
else {
//unknown number of entries; append, sort, then re-time tasking
val oldHead = firstHeap.head
if(!firstHeap.exists(test => RemoverActor.Similarity(test, entry))) {
firstHeap = (firstHeap :+ entry).sortBy(_.duration)
def Processing : Receive = entryManagementBehaviors
.orElse {
case RemoverActor.AddTask(obj, zone, duration) =>
val entry = RemoverActor.Entry(obj, zone, duration.getOrElse(FirstStandardDuration).toNanos)
if(InclusionTest(entry) && !secondHeap.exists(test => sameEntryComparator.Test(test, entry) )) {
InitialJob(entry)
if(firstHeap.isEmpty) {
//we were the only entry so the event must be started from scratch
firstHeap = List(entry)
trace(s"a remover task has been added: $entry")
if(oldHead != firstHeap.head) {
RetimeFirstTask()
}
RetimeFirstTask()
}
else {
trace(s"$obj is already queued for removal")
//unknown number of entries; append, sort, then re-time tasking
val oldHead = firstHeap.head
if(!firstHeap.exists(test => sameEntryComparator.Test(test, entry))) {
firstHeap = (firstHeap :+ entry).sortBy(entry => entry.time + entry.duration)
trace(s"a remover task has been added: $entry")
if(oldHead != firstHeap.head) {
RetimeFirstTask()
}
}
else {
trace(s"$obj is already queued for removal")
}
}
}
}
else {
trace(s"$obj either does not qualify for this Remover or is already queued")
}
else {
trace(s"$obj either does not qualify for this Remover or is already queued")
}
case RemoverActor.HurrySpecific(targets, zone) =>
HurrySpecific(targets, zone)
//private messages from RemoverActor to RemoverActor
case RemoverActor.StartDelete() =>
firstTask.cancel
secondTask.cancel
val now : Long = System.nanoTime
val (in, out) = firstHeap.partition(entry => { now - entry.time >= entry.duration })
firstHeap = out
secondHeap = secondHeap ++ in.map { RepackageEntry }
in.foreach { FirstJob }
RetimeFirstTask()
if(secondHeap.nonEmpty) {
import scala.concurrent.ExecutionContext.Implicits.global
secondTask = context.system.scheduler.scheduleOnce(SecondStandardDuration, self, RemoverActor.TryDelete())
}
trace(s"item removal task has found ${in.size} items to remove")
case RemoverActor.HurryAll() =>
HurryAll()
case RemoverActor.TryDelete() =>
secondTask.cancel
val (in, out) = secondHeap.partition { ClearanceTest }
secondHeap = out
in.foreach { SecondJob }
if(out.nonEmpty) {
import scala.concurrent.ExecutionContext.Implicits.global
secondTask = context.system.scheduler.scheduleOnce(SecondStandardDuration, self, RemoverActor.TryDelete())
}
trace(s"item removal task has removed ${in.size} items")
case RemoverActor.ClearSpecific(targets, zone) =>
ClearSpecific(targets, zone)
case RemoverActor.FailureToWork(entry, ex) =>
debug(s"${entry.obj} from ${entry.zone} not properly deleted - $ex")
case RemoverActor.ClearAll() =>
ClearAll()
//private messages from RemoverActor to RemoverActor
case RemoverActor.StartDelete() =>
firstTask.cancel
secondTask.cancel
val now : Long = System.nanoTime
val (in, out) = firstHeap.partition(entry => { now - entry.time >= entry.duration })
firstHeap = out
secondHeap = secondHeap ++ in.map { RepackageEntry }
in.foreach { FirstJob }
RetimeFirstTask()
if(secondHeap.nonEmpty) {
import scala.concurrent.ExecutionContext.Implicits.global
secondTask = context.system.scheduler.scheduleOnce(SecondStandardDuration, self, RemoverActor.TryDelete())
}
trace(s"item removal task has found ${in.size} items to remove")
case RemoverActor.TryDelete() =>
secondTask.cancel
val (in, out) = secondHeap.partition { ClearanceTest }
secondHeap = out
in.foreach { SecondJob }
if(out.nonEmpty) {
import scala.concurrent.ExecutionContext.Implicits.global
secondTask = context.system.scheduler.scheduleOnce(SecondStandardDuration, self, RemoverActor.TryDelete())
}
trace(s"item removal task has removed ${in.size} items")
case RemoverActor.FailureToWork(entry, ex) =>
log.error(s"${entry.obj} from ${entry.zone} not properly deleted - $ex")
case _ => ;
}
case _ => ;
}
/**
* Expedite some entries from the first pool into the second.
@ -175,14 +166,18 @@ abstract class RemoverActor extends Actor {
* all targets must be in this zone, with the assumption that this is the zone where they were registered
*/
def HurrySpecific(targets : List[PlanetSideGameObject], zone : Zone) : Unit = {
CullTargetsFromFirstHeap(targets, zone) match {
case Nil =>
PartitionTargetsFromList(firstHeap, targets.map { RemoverActor.Entry(_, zone, 0) }, zone) match {
case (Nil, _) =>
debug(s"no tasks matching the targets $targets have been hurried")
case list =>
debug(s"the following tasks have been hurried: $list")
case (in, out) =>
debug(s"the following tasks have been hurried: $in")
firstHeap = out //.sortBy(entry => entry.time + entry.duration)
if(out.nonEmpty) {
RetimeFirstTask()
}
secondTask.cancel
list.foreach { FirstJob }
secondHeap = secondHeap ++ list.map { RepackageEntry }
in.foreach { FirstJob }
secondHeap = secondHeap ++ in.map { RepackageEntry }
import scala.concurrent.ExecutionContext.Implicits.global
secondTask = context.system.scheduler.scheduleOnce(SecondStandardDuration, self, RemoverActor.TryDelete())
}
@ -206,11 +201,15 @@ abstract class RemoverActor extends Actor {
* Remove specific entries from the first pool.
*/
def ClearSpecific(targets : List[PlanetSideGameObject], zone : Zone) : Unit = {
CullTargetsFromFirstHeap(targets, zone) match {
case Nil =>
PartitionTargetsFromList(firstHeap, targets.map { RemoverActor.Entry(_, zone, 0) }, zone) match {
case (Nil, _) =>
debug(s"no tasks matching the targets $targets have been cleared")
case list =>
debug(s"the following tasks have been cleared: $list")
case (in, out) =>
debug(s"the following tasks have been cleared: $in")
firstHeap = out //.sortBy(entry => entry.time + entry.duration)
if(out.nonEmpty) {
RetimeFirstTask()
}
}
}
@ -232,68 +231,6 @@ abstract class RemoverActor extends Actor {
RemoverActor.Entry(entry.obj, entry.zone, SecondStandardDuration.toNanos)
}
/**
* Search the first pool of entries awaiting removal processing.
* If any entry has the same object as one of the targets and belongs to the same zone, remove it from the first pool.
* If no targets are selected (an empty list), all discovered targets within the appropriate zone are removed.
* @param targets a list of objects to pick
* @param zone the zone in which these objects must be discovered;
* all targets must be in this zone, with the assumption that this is the zone where they were registered
* @return all of the discovered entries
*/
private def CullTargetsFromFirstHeap(targets : List[PlanetSideGameObject], zone : Zone) : List[RemoverActor.Entry] = {
val culledEntries = if(targets.nonEmpty) {
if(targets.size == 1) {
debug(s"a target submitted: ${targets.head}")
//simple selection
RemoverActor.recursiveFind(firstHeap.iterator, RemoverActor.Entry(targets.head, zone, 0)) match {
case None => ;
Nil
case Some(index) =>
val entry = firstHeap(index)
firstHeap = (firstHeap.take(index) ++ firstHeap.drop(index + 1)).sortBy(_.duration)
List(entry)
}
}
else {
debug(s"multiple targets submitted: $targets")
//cumbersome partition
//a - find targets from entries
val locatedTargets = for {
a <- targets.map(RemoverActor.Entry(_, zone, 0))
b <- firstHeap//.filter(entry => entry.zone == zone)
if b.obj.HasGUID && a.obj.HasGUID && RemoverActor.Similarity(b, a)
} yield b
if(locatedTargets.nonEmpty) {
//b - entries, after the found targets are removed (cull any non-GUID entries while at it)
firstHeap = (for {
a <- locatedTargets
b <- firstHeap
if b.obj.HasGUID && a.obj.HasGUID && !RemoverActor.Similarity(b, a)
} yield b).sortBy(_.duration)
locatedTargets
}
else {
Nil
}
}
}
else {
debug(s"all targets within the specified zone $zone will be submitted")
//no specific targets; split on all targets in the given zone instead
val (in, out) = firstHeap.partition(entry => entry.zone == zone)
firstHeap = out.sortBy(_.duration)
in
}
if(culledEntries.nonEmpty) {
RetimeFirstTask()
culledEntries
}
else {
Nil
}
}
/**
* Common function to reset the first task's delayed execution.
* Cancels the scheduled timer and will only restart the timer if there is at least one entry in the first pool.
@ -353,15 +290,6 @@ abstract class RemoverActor extends Actor {
*/
def SecondStandardDuration : FiniteDuration
/**
* Determine whether or not the resulting entry is valid for this removal process.
* The primary purpose of this function should be to determine if the appropriate type of object is being submitted.
* Override.
* @param entry the entry
* @return `true`, if it can be processed; `false`, otherwise
*/
def InclusionTest(entry : RemoverActor.Entry) : Boolean
/**
* Performed when the entry is initially added to the first list.
* Override.
@ -392,23 +320,15 @@ abstract class RemoverActor extends Actor {
def DeletionTask(entry : RemoverActor.Entry) : TaskResolver.GiveTask
}
object RemoverActor {
object RemoverActor extends SupportActorCaseConversions {
/**
* All information necessary to apply to the removal process to produce an effect.
* Internally, all entries have a "time created" field.
* @param obj the target
* @param zone the zone in which this target is registered
* @param duration how much longer the target will exist in its current state (in nanoseconds)
* @param _obj the target
* @param _zone the zone in which this target is registered
* @param _duration how much longer the target will exist in its current state (in nanoseconds)
*/
case class Entry(obj : PlanetSideGameObject, zone : Zone, duration : Long) {
/** The time when this entry was created (in nanoseconds) */
val time : Long = System.nanoTime
}
/**
* A message that prompts the retrieval of a `TaskResolver` for us in the removal process.
*/
case class Startup()
case class Entry(_obj : PlanetSideGameObject, _zone : Zone, _duration : Long) extends SupportActor.Entry(_obj, _zone, _duration)
/**
* Message to submit an object to the removal process.
@ -420,36 +340,6 @@ object RemoverActor {
*/
case class AddTask(obj : PlanetSideGameObject, zone : Zone, duration : Option[FiniteDuration] = None)
/**
* "Hurrying" shifts entries with the discovered objects (in the same `zone`)
* through their first task and into the second pool.
* If the list of targets is empty, all discovered objects in the given zone will be considered targets.
* @param targets a list of objects to match
* @param zone the zone in which these objects exist;
* the assumption is that all these target objects are registered to this zone
*/
case class HurrySpecific(targets : List[PlanetSideGameObject], zone : Zone)
/**
* "Hurrying" shifts all entries through their first task and into the second pool.
*/
case class HurryAll()
/**
* "Clearing" cancels entries with the discovered objects (in the same `zone`)
* if they are discovered in the first pool of objects.
* Those entries will no longer be affected by any actions performed by the removal process until re-submitted.
* If the list of targets is empty, all discovered objects in the given zone will be considered targets.
* @param targets a list of objects to match
* @param zone the zone in which these objects exist;
* the assumption is that all these target objects are registered to this zone
*/
case class ClearSpecific(targets : List[PlanetSideGameObject], zone : Zone)
/**
* "Clearing" cancels all entries if they are discovered in the first pool of objects.
* Those entries will no longer be affected by any actions performed by the removal process until re-submitted.
*/
case class ClearAll()
/**
* Message that indicates that the final stage of the remover process has failed.
* Since the last step is generally unregistering the object, it could be a critical error.
@ -467,36 +357,4 @@ object RemoverActor {
* Internal message to flag operations by data in the second list if it has been in that list long enough.
*/
private final case class TryDelete()
/**
* Match two entries by object and by zone information.
* @param entry1 the first entry
* @param entry2 the second entry
* @return if they match
*/
private def Similarity(entry1 : RemoverActor.Entry, entry2 : RemoverActor.Entry) : Boolean = {
entry1.obj == entry2.obj && entry1.zone == entry2.zone && entry1.obj.GUID == entry2.obj.GUID
}
/**
* Get the index of an entry in the list of entries.
* @param iter an `Iterator` of entries
* @param target the specific entry to be found
* @param index the incrementing index value
* @return the index of the entry in the list, if a match to the target is found
*/
@tailrec private def recursiveFind(iter : Iterator[RemoverActor.Entry], target : RemoverActor.Entry, index : Int = 0) : Option[Int] = {
if(!iter.hasNext) {
None
}
else {
val entry = iter.next
if(entry.obj.HasGUID && target.obj.HasGUID && Similarity(entry, target)) {
Some(index)
}
else {
recursiveFind(iter, target, index + 1)
}
}
}
}

1
common/src/main/scala/services/Service.scala
View file

@ -8,6 +8,7 @@ import net.psforever.packet.game.PlanetSideGUID
object Service {
final val defaultPlayerGUID : PlanetSideGUID = PlanetSideGUID(0)
final case class Startup()
final case class Join(channel : String)
final case class Leave(channel : Option[String] = None)
final case class LeaveAll()

12
common/src/main/scala/services/support/SimilarityComparator.scala Normal file
View file

@ -0,0 +1,12 @@
// Copyright (c) 2017 PSForever
package services.support
abstract class SimilarityComparator[A <: SupportActor.Entry] {
/**
* Match two entries by object and by zone information.
* @param entry1 the first entry
* @param entry2 the second entry
* @return if they match
*/
def Test(entry1 : A, entry2 : A) : Boolean
}

155
common/src/main/scala/services/support/SupportActor.scala Normal file
View file

@ -0,0 +1,155 @@
// Copyright (c) 2017 PSForever
package services.support
import akka.actor.Actor
import net.psforever.objects.PlanetSideGameObject
import net.psforever.objects.zones.Zone
import scala.annotation.tailrec
abstract class SupportActor[A <: SupportActor.Entry] extends Actor {
private[this] val log = org.log4s.getLogger
def info(msg : String) : Unit = log.info(msg)
def trace(msg : String) : Unit = log.trace(msg)
def debug(msg : String) : Unit = log.debug(msg)
def sameEntryComparator : SimilarityComparator[A]
/**
* Determine whether or not the resulting entry is valid for this process.
* The primary purpose of this function should be to determine if the appropriate type of object is being submitted.
* Override.
* @param entry the entry
* @return `true`, if it can be processed; `false`, otherwise
*/
def InclusionTest(entry : A) : Boolean
def entryManagementBehaviors : Receive = {
case SupportActor.HurrySpecific(targets, zone) =>
HurrySpecific(targets, zone)
case SupportActor.HurryAll() =>
HurryAll()
case SupportActor.ClearSpecific(targets, zone) =>
ClearSpecific(targets, zone)
case SupportActor.ClearAll() =>
ClearAll()
}
def HurrySpecific(targets : List[PlanetSideGameObject], zone : Zone) : Unit
def HurryAll()
def ClearSpecific(targets : List[PlanetSideGameObject], zone : Zone) : Unit
def ClearAll() : Unit
/*
* Search the first pool of entries awaiting removal processing.
* If any entry has the same object as one of the targets and belongs to the same zone, remove it from the first pool.
* If no targets are selected (an empty list), all discovered targets within the appropriate zone are removed.
* @param targets a list of objects to pick
* @param zone the zone in which these objects must be discovered;
* all targets must be in this zone, with the assumption that this is the zone where they were registered
* @return all of the discovered entries
*/
def PartitionTargetsFromList(list : List[A], targets : List[A], zone : Zone, comparator : SimilarityComparator[A] = sameEntryComparator) : (List[A], List[A]) = {
if(targets.nonEmpty) {
if(targets.size == 1) {
debug(s"a target submitted: ${targets.head}")
//simple selection
SupportActor.recursiveFind(comparator)(list.iterator, targets.head) match {
case None => ;
(Nil, list)
case Some(index) =>
(List(list(index)), list.take(index) ++ list.drop(index + 1))
}
}
else {
debug(s"multiple targets submitted: $targets")
//cumbersome partition
//a - find targets from entries
val locatedTargets = for {
a <- targets
b <- list//.filter(entry => entry.zone == zone)
if b.obj.HasGUID && a.obj.HasGUID && comparator.Test(b, a)
} yield b
if(locatedTargets.nonEmpty) {
//b - entries, after the found targets are removed (cull any non-GUID entries while at it)
val retained = for {
a <- locatedTargets
b <- list
if b.obj.HasGUID && a.obj.HasGUID && !comparator.Test(b, a)
} yield b
(locatedTargets, retained)
}
else {
(Nil, list)
}
}
}
else {
list.partition(entry => entry.zone == zone)
}
}
}
object SupportActor {
class Entry(val obj : PlanetSideGameObject, val zone : Zone, val duration : Long) {
val time : Long = System.nanoTime
}
/**
* "Hurrying" shifts entries with the discovered objects (in the same `zone`)
* through their first task and into the second pool.
* If the list of targets is empty, all discovered objects in the given zone will be considered targets.
* @param targets a list of objects to match
* @param zone the zone in which these objects exist;
* the assumption is that all these target objects are registered to this zone
*/
case class HurrySpecific(targets : List[PlanetSideGameObject], zone : Zone)
/**
* "Hurrying" shifts all entries through their first task and into the second pool.
*/
case class HurryAll()
/**
* "Clearing" cancels entries with the discovered objects (in the same `zone`)
* if they are discovered in the first pool of objects.
* Those entries will no longer be affected by any actions performed by the removal process until re-submitted.
* If the list of targets is empty, all discovered objects in the given zone will be considered targets.
* @param targets a list of objects to match
* @param zone the zone in which these objects exist;
* the assumption is that all these target objects are registered to this zone
*/
case class ClearSpecific(targets : List[PlanetSideGameObject], zone : Zone)
/**
* "Clearing" cancels all entries if they are discovered in the first pool of objects.
* Those entries will no longer be affected by any actions performed by the removal process until re-submitted.
*/
case class ClearAll()
/**
* Get the index of an entry in the list of entries.
* @param iter an `Iterator` of entries
* @param target the specific entry to be found
* @param index the incrementing index value
* @return the index of the entry in the list, if a match to the target is found
*/
@tailrec private def recursiveFind[A <: SupportActor.Entry](comparator : SimilarityComparator[A])(iter : Iterator[A], target : A, index : Int = 0) : Option[Int] = {
if(!iter.hasNext) {
None
}
else {
val entry = iter.next
if(entry.obj.HasGUID && target.obj.HasGUID && comparator.Test(entry, target)) {
Some(index)
}
else {
recursiveFind(comparator)(iter, target, index + 1)
}
}
}
}

37
common/src/main/scala/services/support/SupportActorCaseConversions.scala Normal file
View file

@ -0,0 +1,37 @@
// Copyright (c) 2017 PSForever
package services.support
import net.psforever.objects.PlanetSideGameObject
import net.psforever.objects.zones.Zone
trait SupportActorCaseConversions {
/**
* A mask for converting between a class local and `SupportActor.HurrySpecific`.
* @param targets a list of objects to match
* @param zone the zone in which these objects exist
* @return a `SupportActor.HurrySpecific` object
*/
def HurrySpecific(targets : List[PlanetSideGameObject], zone : Zone) : SupportActor.HurrySpecific =
SupportActor.HurrySpecific(targets, zone)
/**
* A mask for converting between a class local and `SupportActor.HurryAll`.
* @return a `SupportActor.HurryAll` object
*/
def HurryAll() : SupportActor.HurryAll = SupportActor.HurryAll()
/**
* A mask for converting between a class local and `SupportActor.ClearSpecific`.
* @param targets a list of objects to match
* @param zone the zone in which these objects exist
* @return a `SupportActor.ClearSpecific` object
*/
def ClearSpecific(targets : List[PlanetSideGameObject], zone : Zone) : SupportActor.ClearSpecific =
SupportActor.ClearSpecific(targets, zone)
/**
* A mask for converting between a class local and `SupportActor.ClearAll`.
* @return a `SupportActor.ClearAll` object
*/
def ClearAll() : SupportActor.ClearAll = SupportActor.ClearAll()
}

1
common/src/main/scala/services/vehicle/VehicleAction.scala
View file

@ -15,6 +15,7 @@ object VehicleAction {
final case class ChildObjectState(player_guid : PlanetSideGUID, object_guid : PlanetSideGUID, pitch : Float, yaw : Float) extends Action
final case class DeployRequest(player_guid : PlanetSideGUID, object_guid : PlanetSideGUID, state : DriveState.Value, unk1 : Int, unk2 : Boolean, pos : Vector3) extends Action
final case class DismountVehicle(player_guid : PlanetSideGUID, bailType : BailType.Value, unk2 : Boolean) extends Action
final case class EquipmentInSlot(player_guid : PlanetSideGUID, target_guid : PlanetSideGUID, slot : Int, equipment : Equipment) extends Action
final case class InventoryState(player_guid : PlanetSideGUID, obj : PlanetSideGameObject, parent_guid : PlanetSideGUID, start : Int, con_data : ConstructorData) extends Action
final case class InventoryState2(player_guid : PlanetSideGUID, obj_guid : PlanetSideGUID, parent_guid : PlanetSideGUID, value : Int) extends Action
final case class KickPassenger(player_guid : PlanetSideGUID, unk1 : Int, unk2 : Boolean, vehicle_guid : PlanetSideGUID) extends Action

4
common/src/main/scala/services/vehicle/VehicleResponse.scala
View file

@ -1,10 +1,11 @@
// Copyright (c) 2017 PSForever
package services.vehicle
import net.psforever.objects.equipment.Equipment
import net.psforever.objects.serverobject.tube.SpawnTube
import net.psforever.objects.{PlanetSideGameObject, Vehicle}
import net.psforever.packet.PlanetSideGamePacket
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.packet.game.{ObjectCreateMessage, PlanetSideGUID}
import net.psforever.packet.game.objectcreate.ConstructorData
import net.psforever.types.{BailType, DriveState, Vector3}
@ -17,6 +18,7 @@ object VehicleResponse {
final case class DeployRequest(object_guid : PlanetSideGUID, state : DriveState.Value, unk1 : Int, unk2 : Boolean, pos : Vector3) extends Response
final case class DetachFromRails(vehicle_guid : PlanetSideGUID, rails_guid : PlanetSideGUID, rails_pos : Vector3, rails_rot : Float) extends Response
final case class DismountVehicle(bailType : BailType.Value , unk2 : Boolean) extends Response
final case class EquipmentInSlot(pkt : ObjectCreateMessage) extends Response
final case class InventoryState(obj : PlanetSideGameObject, parent_guid : PlanetSideGUID, start : Int, con_data : ConstructorData) extends Response
final case class InventoryState2(obj_guid : PlanetSideGUID, parent_guid : PlanetSideGUID, value : Int) extends Response
final case class KickPassenger(seat_num : Int, kickedByDriver : Boolean, vehicle_guid : PlanetSideGUID) extends Response

21
common/src/main/scala/services/vehicle/VehicleService.scala
View file

@ -4,7 +4,9 @@ package services.vehicle
import akka.actor.{Actor, ActorRef, Props}
import net.psforever.objects.serverobject.pad.VehicleSpawnPad
import net.psforever.objects.zones.Zone
import services.vehicle.support.VehicleRemover
import net.psforever.packet.game.ObjectCreateMessage
import net.psforever.packet.game.objectcreate.ObjectCreateMessageParent
import services.vehicle.support.{TurretUpgrader, VehicleRemover}
import net.psforever.types.DriveState
import services.{GenericEventBus, RemoverActor, Service}
@ -12,6 +14,7 @@ import scala.concurrent.duration._
class VehicleService extends Actor {
private val vehicleDecon : ActorRef = context.actorOf(Props[VehicleRemover], "vehicle-decon-agent")
private val turretUpgrade : ActorRef = context.actorOf(Props[TurretUpgrader], "turret-upgrade-agent")
private [this] val log = org.log4s.getLogger
override def preStart = {
@ -53,6 +56,18 @@ class VehicleService extends Actor {
VehicleEvents.publish(
VehicleServiceResponse(s"/$forChannel/Vehicle", player_guid, VehicleResponse.DismountVehicle(bailType, unk2))
)
case VehicleAction.EquipmentInSlot(player_guid, target_guid, slot, equipment) =>
val definition = equipment.Definition
val pkt = ObjectCreateMessage(
definition.ObjectId,
equipment.GUID,
ObjectCreateMessageParent(target_guid, slot),
definition.Packet.ConstructorData(equipment).get
)
ObjectCreateMessageParent(target_guid, slot)
VehicleEvents.publish(
VehicleServiceResponse(s"/$forChannel/Vehicle", player_guid, VehicleResponse.EquipmentInSlot(pkt))
)
case VehicleAction.InventoryState(player_guid, obj, parent_guid, start, con_data) =>
VehicleEvents.publish(
VehicleServiceResponse(s"/$forChannel/Vehicle", player_guid, VehicleResponse.InventoryState(obj, parent_guid, start, con_data))
@ -114,6 +129,10 @@ class VehicleService extends Actor {
case VehicleServiceMessage.Decon(msg) =>
vehicleDecon forward msg
//message to TurretUpgrader
case VehicleServiceMessage.TurretUpgrade(msg) =>
turretUpgrade forward msg
//from VehicleSpawnControl
case VehicleSpawnPad.ConcealPlayer(player_guid, zone_id) =>
VehicleEvents.publish(

2
common/src/main/scala/services/vehicle/VehicleServiceMessage.scala
View file

@ -12,5 +12,7 @@ object VehicleServiceMessage {
final case class Decon(msg : Any)
final case class TurretUpgrade(msg : Any)
final case class AMSDeploymentChange(zone : Zone)
}

260
common/src/main/scala/services/vehicle/support/TurretUpgrader.scala Normal file
View file

@ -0,0 +1,260 @@
// Copyright (c) 2017 PSForever
package services.vehicle.support
import akka.actor.{Actor, ActorRef, Cancellable}
import net.psforever.objects.{AmmoBox, DefaultCancellable, PlanetSideGameObject, Tool}
import net.psforever.objects.guid.{GUIDTask, Task, TaskResolver}
import net.psforever.objects.serverobject.turret.{MannedTurret, TurretUpgrade}
import net.psforever.objects.vehicles.MountedWeapons
import net.psforever.objects.zones.Zone
import net.psforever.packet.game.PlanetSideGUID
import services.support.{SimilarityComparator, SupportActor, SupportActorCaseConversions}
import services.vehicle.{VehicleAction, VehicleServiceMessage}
import services.{Service, ServiceManager}
import scala.concurrent.duration._
class TurretUpgrader extends SupportActor[TurretUpgrader.Entry] {
var task : Cancellable = DefaultCancellable.obj
var list : List[TurretUpgrader.Entry] = List()
private var taskResolver : ActorRef = Actor.noSender
val sameEntryComparator = new SimilarityComparator[TurretUpgrader.Entry]() {
def Test(entry1 : TurretUpgrader.Entry, entry2 : TurretUpgrader.Entry) : Boolean = {
entry1.obj == entry2.obj && entry1.zone == entry2.zone && entry1.obj.GUID == entry2.obj.GUID
}
}
/**
* Send the initial message that requests a task resolver for assisting in the removal process.
*/
override def preStart() : Unit = {
super.preStart()
self ! Service.Startup()
}
/**
* Sufficiently clean up the current contents of these waiting removal jobs.
* Cancel all timers, rush all entries in the lists through their individual steps, then empty the lists.
* This is an improved `HurryAll`.
*/
override def postStop() : Unit = {
super.postStop()
task.cancel
list.foreach { UpgradeTurretAmmo }
list = Nil
taskResolver = ActorRef.noSender
}
def CreateEntry(obj : PlanetSideGameObject, zone : Zone, upgrade : TurretUpgrade.Value, duration : Long) = TurretUpgrader.Entry(obj, zone, upgrade, duration)
def InclusionTest(entry : TurretUpgrader.Entry) : Boolean = entry.obj.isInstanceOf[MannedTurret]
def receive : Receive = {
case Service.Startup() =>
ServiceManager.serviceManager ! ServiceManager.Lookup("taskResolver") //ask for a resolver to deal with the GUID system
case ServiceManager.LookupResult("taskResolver", endpoint) =>
taskResolver = endpoint
context.become(Processing)
case msg =>
debug(s"received message $msg before being properly initialized")
}
def Processing : Receive = entryManagementBehaviors
.orElse {
case TurretUpgrader.AddTask(turret, zone, upgrade, duration) =>
val lengthOfTime = duration.getOrElse(TurretUpgrader.StandardUpgradeLifetime).toNanos
if(lengthOfTime > (1 second).toNanos) { //don't even bother if it's too short; it'll revert near instantly
val entry = CreateEntry(turret, zone, TurretUpgrade.None, lengthOfTime)
UpgradeTurretAmmo(CreateEntry(turret, zone, upgrade, lengthOfTime))
if(list.isEmpty) {
//we were the only entry so the event must be started from scratch
list = List(entry)
trace(s"a task has been added: $entry")
RetimeFirstTask()
}
else{
val oldHead = list.head
if(!list.exists(test => TurretUpgrader.Similarity(test, entry))) {
list = (list :+ entry).sortBy(entry => entry.time + entry.duration)
trace(s"a task has been added: $entry")
if(oldHead != list.head) {
RetimeFirstTask()
}
}
}
}
case TurretUpgrader.Downgrade() =>
task.cancel
val now : Long = System.nanoTime
val (in, out) = list.partition(entry => { now - entry.time >= entry.duration }) //&& entry.obj.Seats.values.count(_.isOccupied) == 0
list = out
in.foreach { UpgradeTurretAmmo }
RetimeFirstTask()
case _ => ;
}
def RetimeFirstTask(now : Long = System.nanoTime) : Unit = {
task.cancel
if(list.nonEmpty) {
val short_timeout : FiniteDuration = math.max(1, list.head.duration - (now - list.head.time)) nanoseconds
import scala.concurrent.ExecutionContext.Implicits.global
task = context.system.scheduler.scheduleOnce(short_timeout, self, TurretUpgrader.Downgrade())
}
}
def HurrySpecific(targets : List[PlanetSideGameObject], zone : Zone) : Unit = {
PartitionTargetsFromList(list, targets.map { TurretUpgrader.Entry(_, zone, TurretUpgrade.None, 0) }, zone) match {
case (Nil, _) =>
debug(s"no tasks matching the targets $targets have been hurried")
case (in, out) =>
debug(s"the following tasks have been hurried: $in")
in.foreach { UpgradeTurretAmmo }
list = out //.sortBy(entry => entry.time + entry.duration)
if(out.nonEmpty) {
RetimeFirstTask()
}
}
}
def HurryAll() : Unit = {
trace("all tasks have been hurried")
task.cancel
list.foreach { UpgradeTurretAmmo }
list = Nil
}
def ClearSpecific(targets : List[PlanetSideGameObject], zone : Zone) : Unit = {
PartitionTargetsFromList(list, targets.map { TurretUpgrader.Entry(_, zone, TurretUpgrade.None, 0) }, zone) match {
case (Nil, _) =>
debug(s"no tasks matching the targets $targets have been cleared")
case (in, out) =>
debug(s"the following tasks have been cleared: $in")
list = out //.sortBy(entry => entry.time + entry.duration)
if(out.nonEmpty) {
RetimeFirstTask()
}
}
}
def ClearAll() : Unit = {
task.cancel
list = Nil
}
/**
* The process of upgrading a turret is nearly complete.
* After the upgrade status is changed, the internal structure of the turret's weapons change to suit the configuration.
* Of special importance are internal ammo supplies of the changing weapon,
* the original ammunition that must be un-registered,
* and the new boxes that must be registered so the weapon may be introduced into the game world properly.
* @param entry na
*/
def UpgradeTurretAmmo(entry : TurretUpgrader.Entry) : Unit = {
val target = entry.obj.asInstanceOf[MannedTurret]
val zone = entry.zone
val zoneId = zone.Id
val upgrade = entry.upgrade
val guid = zone.GUID
val turretGUID = target.GUID
//kick all occupying players for duration of conversion
target.Seats.values
.filter { _.isOccupied }
.foreach({seat =>
val tplayer = seat.Occupant.get
seat.Occupant = None
tplayer.VehicleSeated = None
if(tplayer.HasGUID) {
context.parent ! VehicleServiceMessage(zoneId, VehicleAction.KickPassenger(tplayer.GUID, 4, false, turretGUID))
}
})
info(s"Converting manned wall turret weapon to $upgrade")
val oldBoxesTask = AllMountedWeaponMagazines(target)
.map(box => GUIDTask.UnregisterEquipment(box)(guid))
.toList
target.Upgrade = upgrade //perform upgrade
val newBoxesTask = TaskResolver.GiveTask(
new Task() {
private val localFunc : ()=>Unit = FinishUpgradingTurret(entry)
override def isComplete = Task.Resolution.Success
def Execute(resolver : ActorRef) : Unit = {
localFunc()
resolver ! scala.util.Success(this)
}
}, AllMountedWeaponMagazines(target).map(box => GUIDTask.RegisterEquipment(box)(guid)).toList
)
taskResolver ! TaskResolver.GiveTask(
new Task() {
def Execute(resolver : ActorRef) : Unit = {
resolver ! scala.util.Success(this)
}
}, oldBoxesTask :+ newBoxesTask
)
}
/**
* From an object that has mounted weapons, parse all of the internal ammunition loaded into all of the weapons.
* @param target the object with mounted weaponry
* @return all of the internal ammunition objects
*/
def AllMountedWeaponMagazines(target : MountedWeapons) : Iterable[AmmoBox] = {
target.Weapons
.values
.map { _.Equipment }
.collect { case Some(tool : Tool) => tool.AmmoSlots }
.flatMap { _.map { _.Box } }
}
/**
* Finish upgrading the turret by announcing to other players that the weapon type has changed.
* By this point, a prior required action that required that new ammunition objects had to be registered.
* It is now safe to announce that clients can update to the new weapon.
* @param entry na
*/
def FinishUpgradingTurret(entry : TurretUpgrader.Entry)() : Unit = {
val target = entry.obj.asInstanceOf[MannedTurret]
val zone = entry.zone
info(s"Wall turret finished ${target.Upgrade} upgrade")
val targetGUID = target.GUID
target.Weapons
.map({ case (index, slot) => (index, slot.Equipment) })
.collect { case (index, Some(tool : Tool)) =>
context.parent ! VehicleServiceMessage(
zone.Id,
VehicleAction.EquipmentInSlot(PlanetSideGUID(0), targetGUID, index, tool)
)
}
}
}
object TurretUpgrader extends SupportActorCaseConversions {
private val StandardUpgradeLifetime : FiniteDuration = 30 minutes
/**
* All information necessary to apply to the removal process to produce an effect.
* Internally, all entries have a "time created" field.
* @param _obj the target
* @param _zone the zone in which this target is registered
* @param upgrade the next upgrade state for this turret
* @param _duration how much longer the target will exist in its current state (in nanoseconds)
*/
case class Entry(_obj : PlanetSideGameObject, _zone : Zone, upgrade : TurretUpgrade.Value, _duration : Long) extends SupportActor.Entry(_obj, _zone, _duration)
final case class AddTask(turret : MannedTurret, zone : Zone, upgrade : TurretUpgrade.Value, duration : Option[FiniteDuration] = None)
final case class Downgrade()
private def Similarity(entry1 : TurretUpgrader.Entry, entry2 : TurretUpgrader.Entry) : Boolean = {
entry1.obj == entry2.obj && entry1.zone == entry2.zone && entry1.obj.GUID == entry2.obj.GUID
}
}

51
common/src/test/scala/base/ActorTest.scala Normal file
View file

@ -0,0 +1,51 @@
package base
// Copyright (c) 2017 PSForever
import akka.actor.ActorSystem
import akka.testkit.{ImplicitSender, TestKit}
import com.typesafe.config.ConfigFactory
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}
import org.specs2.specification.Scope
import scala.collection.mutable
import scala.concurrent.duration.FiniteDuration
abstract class ActorTest(sys : ActorSystem = ActorSystem("system", ConfigFactory.parseMap(ActorTest.LoggingConfig)))
extends TestKit(sys) with Scope with ImplicitSender with WordSpecLike with Matchers with BeforeAndAfterAll {
override def afterAll {
TestKit.shutdownActorSystem(system)
}
}
object ActorTest {
import scala.collection.JavaConverters._
private val LoggingConfig = Map(
"akka.loggers" -> List("akka.testkit.TestEventListener").asJava,
"akka.loglevel" -> "OFF",
"akka.stdout-loglevel" -> "OFF",
"akka.log-dead-letters" -> "OFF"
).asJava
/**
* A (potential) workaround to a Travis CI issue involving polling a series of messages over a period of time.
* Running the test in isolation works every time.
* Running the test as part of a series produces mixed results.
* Travis CI fails the test every time by not getting any messages.
* @see TestKit.receiveN
* @param n the number of messages to poll
* @param timeout how long to wait for each message
* @param sys what to poll
* @return a list of messages
*/
def receiveMultiple(n : Int, timeout : FiniteDuration, sys : TestKit) : List[Any] = {
assert(0 < n, s"number of expected messages must be positive non-zero integer - $n")
val out = {
val msgs = mutable.ListBuffer[Any]()
(0 until n).foreach(_ => {
msgs += sys.receiveOne(timeout)
})
msgs.toList
}
out
}
}

4
common/src/test/scala/game/UseItemMessageTest.scala
View file

@ -14,7 +14,7 @@ class UseItemMessageTest extends Specification {
PacketCoding.DecodePacket(string).require match {
case UseItemMessage(avatar_guid, unk1, object_guid, unk2, unk3, unk4, unk5, unk6, unk7, unk8, itemType) =>
avatar_guid mustEqual PlanetSideGUID(75)
unk1 mustEqual 0
unk1 mustEqual PlanetSideGUID(0)
object_guid mustEqual PlanetSideGUID(372)
unk2 mustEqual 0xFFFFFFFFL
unk3 mustEqual false
@ -30,7 +30,7 @@ class UseItemMessageTest extends Specification {
}
"encode" in {
val msg = UseItemMessage(PlanetSideGUID(75), 0, PlanetSideGUID(372), 0xFFFFFFFFL, false, Vector3(5.0f, 0.0f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), 11, 25, 0, 364)
val msg = UseItemMessage(PlanetSideGUID(75), PlanetSideGUID(0), PlanetSideGUID(372), 0xFFFFFFFFL, false, Vector3(5.0f, 0.0f, 0.0f), Vector3(0.0f, 0.0f, 0.0f), 11, 25, 0, 364)
val pkt = PacketCoding.EncodePacket(msg).require.toByteVector
pkt mustEqual string

25
common/src/test/scala/objects/ActorTest.scala
View file

@ -1,25 +0,0 @@
// Copyright (c) 2017 PSForever
package objects
import akka.actor.ActorSystem
import akka.testkit.{ImplicitSender, TestKit}
import com.typesafe.config.{ConfigFactory, ConfigValueFactory}
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}
import org.specs2.specification.Scope
abstract class ActorTest(sys : ActorSystem = ActorSystem("system", ConfigFactory.parseMap(ActorTest.LoggingConfig)))
extends TestKit(sys) with Scope with ImplicitSender with WordSpecLike with Matchers with BeforeAndAfterAll {
override def afterAll {
TestKit.shutdownActorSystem(system)
}
}
object ActorTest {
import scala.collection.JavaConverters._
private val LoggingConfig = Map(
"akka.loggers" -> List("akka.testkit.TestEventListener").asJava,
"akka.loglevel" -> "OFF",
"akka.stdout-loglevel" -> "OFF",
"akka.log-dead-letters" -> "OFF"
).asJava
}

1
common/src/test/scala/objects/AutoDriveControlsTest.scala
View file

@ -3,6 +3,7 @@ package objects
import akka.actor.Props
import akka.testkit.TestProbe
import base.ActorTest
import net.psforever.objects.serverobject.pad.{VehicleSpawnControl, VehicleSpawnPad}
import net.psforever.objects.{Avatar, GlobalDefinitions, Player, Vehicle}
import net.psforever.objects.serverobject.pad.process.{AutoDriveControls, VehicleSpawnControlGuided}

14
common/src/test/scala/objects/BuildingTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{ActorRef, Props}
import base.ActorTest
import net.psforever.objects.GlobalDefinitions
import net.psforever.objects.definition.ObjectDefinition
import net.psforever.objects.serverobject.affinity.FactionAffinity
@ -128,12 +129,11 @@ class BuildingControl2Test extends ActorTest {
val bldg = Building(10, Zone.Nowhere, StructureType.Building)
bldg.Faction = PlanetSideEmpire.TR
bldg.Actor = system.actorOf(Props(classOf[BuildingControl], bldg), "test")
bldg.Actor ! "startup"
"Building Control" should {
"convert and assert faction affinity on convert request" in {
expectNoMsg(250 milliseconds)
bldg.Actor ! "startup"
expectNoMsg(250 milliseconds)
expectNoMsg(500 milliseconds)
assert(bldg.Faction == PlanetSideEmpire.TR)
bldg.Actor ! FactionAffinity.ConvertFactionAffinity(PlanetSideEmpire.VS)
@ -159,12 +159,11 @@ class BuildingControl3Test extends ActorTest {
door2.Actor = system.actorOf(Props(classOf[DoorControl], door2), "door2-test")
bldg.Amenities = door2
bldg.Amenities = door1
bldg.Actor ! "startup"
"Building Control" should {
"convert and assert faction affinity on convert request, and for each of its amenities" in {
expectNoMsg(250 milliseconds)
bldg.Actor ! "startup"
expectNoMsg(250 milliseconds)
expectNoMsg(500 milliseconds)
assert(bldg.Faction == PlanetSideEmpire.TR)
assert(bldg.Amenities.length == 2)
@ -172,7 +171,8 @@ class BuildingControl3Test extends ActorTest {
assert(bldg.Amenities(1) == door1)
bldg.Actor ! FactionAffinity.ConvertFactionAffinity(PlanetSideEmpire.VS)
val reply = receiveN(3, Duration.create(500, "ms"))
val reply = ActorTest.receiveMultiple(3, 500 milliseconds, this)
//val reply = receiveN(3, Duration.create(5000, "ms"))
assert(reply.length == 3)
var building_count = 0
var door_count = 0

1
common/src/test/scala/objects/DeploymentTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{Actor, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.objects.{GlobalDefinitions, Vehicle}
import net.psforever.objects.serverobject.deploy.{Deployment, DeploymentBehavior}

11
common/src/test/scala/objects/DoorTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{ActorRef, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.objects.serverobject.doors.{Door, DoorControl}
import net.psforever.objects.serverobject.structures.{Building, StructureType}
@ -42,7 +43,7 @@ class DoorTest extends Specification {
}
"be opened and closed (2; toggle)" in {
val msg = UseItemMessage(PlanetSideGUID(6585), 0, PlanetSideGUID(372), 4294967295L, false, Vector3(5.0f,0.0f,0.0f), Vector3(0.0f,0.0f,0.0f), 11, 25, 0, 364)
val msg = UseItemMessage(PlanetSideGUID(6585), PlanetSideGUID(0), PlanetSideGUID(372), 4294967295L, false, Vector3(5.0f,0.0f,0.0f), Vector3(0.0f,0.0f,0.0f), 11, 25, 0, 364)
val door = Door(GlobalDefinitions.door)
door.Open mustEqual None
door.Use(player, msg)
@ -74,7 +75,7 @@ class DoorTest extends Specification {
}
}
class DoorControl1Test extends ActorTest() {
class DoorControl1Test extends ActorTest {
"DoorControl" should {
"construct" in {
val door = Door(GlobalDefinitions.door)
@ -84,11 +85,11 @@ class DoorControl1Test extends ActorTest() {
}
}
class DoorControl2Test extends ActorTest() {
class DoorControl2Test extends ActorTest {
"DoorControl" should {
"open on use" in {
val (player, door) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)
val msg = UseItemMessage(PlanetSideGUID(1), 0, PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
val msg = UseItemMessage(PlanetSideGUID(1), PlanetSideGUID(0), PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
assert(door.Open.isEmpty)
door.Actor ! Door.Use(player, msg)
@ -103,7 +104,7 @@ class DoorControl2Test extends ActorTest() {
}
}
class DoorControl3Test extends ActorTest() {
class DoorControl3Test extends ActorTest {
"DoorControl" should {
"do nothing if given garbage" in {
val (_, door) = DoorControlTest.SetUpAgents(PlanetSideEmpire.TR)

7
common/src/test/scala/objects/FactionAffinityTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{Actor, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.{GlobalDefinitions, Vehicle}
import net.psforever.objects.serverobject.affinity.FactionAffinity
import net.psforever.objects.serverobject.doors.Door
@ -55,7 +56,7 @@ class FactionAffinityTest extends Specification {
}
}
class FactionAffinity1Test extends ActorTest() {
class FactionAffinity1Test extends ActorTest {
"FactionAffinity" should {
"assert affinity on confirm request" in {
val obj = FactionAffinityTest.SetUpAgent
@ -71,7 +72,7 @@ class FactionAffinity1Test extends ActorTest() {
}
}
class FactionAffinity2Test extends ActorTest() {
class FactionAffinity2Test extends ActorTest {
"FactionAffinity" should {
"assert affinity on assert request" in {
val obj = FactionAffinityTest.SetUpAgent
@ -87,7 +88,7 @@ class FactionAffinity2Test extends ActorTest() {
}
}
class FactionAffinity3Test extends ActorTest() {
class FactionAffinity3Test extends ActorTest {
"FactionAffinity" should {
"convert and assert affinity on convert request" in {
val obj = FactionAffinityTest.SetUpAgent

7
common/src/test/scala/objects/IFFLockTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{ActorRef, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.serverobject.CommonMessages
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.objects.serverobject.locks.{IFFLock, IFFLockControl}
@ -22,7 +23,7 @@ class IFFLockTest extends Specification {
}
}
class IFFLockControl1Test extends ActorTest() {
class IFFLockControl1Test extends ActorTest {
"IFFLockControl" should {
"construct" in {
val lock = IFFLock(GlobalDefinitions.lock_external)
@ -32,7 +33,7 @@ class IFFLockControl1Test extends ActorTest() {
}
}
class IFFLockControl2Test extends ActorTest() {
class IFFLockControl2Test extends ActorTest {
"IFFLockControl" should {
"can hack" in {
val (player, lock) = IFFLockControlTest.SetUpAgents(PlanetSideEmpire.TR)
@ -46,7 +47,7 @@ class IFFLockControl2Test extends ActorTest() {
}
}
class IFFLockControl3Test extends ActorTest() {
class IFFLockControl3Test extends ActorTest {
"IFFLockControl" should {
"can hack" in {
val (player, lock) = IFFLockControlTest.SetUpAgents(PlanetSideEmpire.TR)

1
common/src/test/scala/objects/LockerTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{ActorRef, Props}
import base.ActorTest
import net.psforever.objects.GlobalDefinitions
import net.psforever.objects.serverobject.affinity.FactionAffinity
import net.psforever.objects.serverobject.mblocker.{Locker, LockerControl}

179
common/src/test/scala/objects/MannedTurretTest.scala Normal file
View file

@ -0,0 +1,179 @@
// Copyright (c) 2017 PSForever
package objects
import akka.actor.{ActorRef, Props}
import base.ActorTest
import net.psforever.objects.{Avatar, GlobalDefinitions, Player, Tool}
import net.psforever.objects.definition.ToolDefinition
import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.serverobject.structures.{Building, StructureType}
import net.psforever.objects.serverobject.turret.{MannedTurret, MannedTurretControl, MannedTurretDefinition, TurretUpgrade}
import net.psforever.objects.zones.Zone
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import org.specs2.mutable.Specification
import scala.collection.mutable
import scala.concurrent.duration._
class MannedTurretTest extends Specification {
"MannedTurretTest" should {
"define" in {
val obj = new MannedTurretDefinition(480)
obj.Weapons mustEqual mutable.HashMap.empty[TurretUpgrade.Value, ToolDefinition]
obj.ReserveAmmunition mustEqual false
obj.FactionLocked mustEqual true
obj.MaxHealth mustEqual 100
obj.MountPoints mustEqual mutable.HashMap.empty[Int,Int]
}
"construct" in {
val obj = MannedTurret(GlobalDefinitions.manned_turret)
obj.Weapons.size mustEqual 1
obj.Weapons(1).Equipment match {
case Some(tool : Tool) =>
tool.Definition mustEqual GlobalDefinitions.phalanx_sgl_hevgatcan
case _ =>
ko
}
obj.Seats.size mustEqual 1
obj.Seats(0).ControlledWeapon mustEqual Some(1)
obj.MountPoints.size mustEqual 1
obj.MountPoints(1) mustEqual 0
obj.Health mustEqual 3600
obj.Upgrade mustEqual TurretUpgrade.None
obj.Jammered mustEqual false
obj.Health = 360
obj.Health mustEqual 360
obj.Jammered = true
obj.Jammered mustEqual true
}
"upgrade to a different weapon" in {
val obj = MannedTurret(GlobalDefinitions.manned_turret)
obj.Upgrade = TurretUpgrade.None
obj.Weapons(1).Equipment match {
case Some(tool : Tool) =>
tool.Definition mustEqual GlobalDefinitions.phalanx_sgl_hevgatcan
tool.FireModeIndex mustEqual 0
tool.NextFireMode
tool.FireModeIndex mustEqual 0 //one fire mode
case _ =>
ko
}
//upgrade
obj.Upgrade = TurretUpgrade.AVCombo
obj.Weapons(1).Equipment match {
case Some(tool : Tool) =>
tool.Definition mustEqual GlobalDefinitions.phalanx_avcombo
tool.FireModeIndex mustEqual 0
tool.ProjectileType mustEqual GlobalDefinitions.phalanx_projectile.ProjectileType
tool.NextFireMode
tool.FireModeIndex mustEqual 1
tool.ProjectileType mustEqual GlobalDefinitions.phalanx_av_projectile.ProjectileType
case _ =>
ko
}
//revert
obj.Upgrade = TurretUpgrade.None
obj.Weapons(1).Equipment match {
case Some(tool : Tool) =>
tool.Definition mustEqual GlobalDefinitions.phalanx_sgl_hevgatcan
case _ =>
ko
}
}
}
}
class MannedTurretControl1Test extends ActorTest {
"MannedTurretControl" should {
"construct" in {
val obj = MannedTurret(GlobalDefinitions.manned_turret)
obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
assert(obj.Actor != ActorRef.noSender)
}
}
}
class MannedTurretControl2Test extends ActorTest {
val player = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
val obj = MannedTurret(GlobalDefinitions.manned_turret)
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
val bldg = Building(0, Zone.Nowhere, StructureType.Building)
bldg.Amenities = obj
bldg.Faction = PlanetSideEmpire.TR
"MannedTurretControl" should {
"seat on faction affiliation when FactionLock is true" in {
assert(player.Faction == PlanetSideEmpire.TR)
assert(obj.Faction == PlanetSideEmpire.TR)
assert(obj.Definition.FactionLocked)
obj.Actor ! Mountable.TryMount(player, 0)
val reply = receiveOne(300 milliseconds)
reply match {
case msg : Mountable.MountMessages =>
assert(msg.response.isInstanceOf[Mountable.CanMount])
case _ =>
assert(false)
}
}
}
}
class MannedTurretControl3Test extends ActorTest {
val player = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
val obj = MannedTurret(GlobalDefinitions.manned_turret)
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
val bldg = Building(0, Zone.Nowhere, StructureType.Building)
bldg.Amenities = obj
"MannedTurretControl" should {
"block seating on mismatched faction affiliation when FactionLock is true" in {
assert(player.Faction == PlanetSideEmpire.TR)
assert(obj.Faction == PlanetSideEmpire.NEUTRAL)
assert(obj.Definition.FactionLocked)
obj.Actor ! Mountable.TryMount(player, 0)
val reply = receiveOne(300 milliseconds)
reply match {
case msg : Mountable.MountMessages =>
assert(msg.response.isInstanceOf[Mountable.CanNotMount])
case _ =>
assert(false)
}
}
}
}
class MannedTurretControl4Test extends ActorTest {
val player = Player(Avatar("", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
val objDef = new MannedTurretDefinition(480)
objDef.FactionLocked = false
val obj = MannedTurret(objDef)
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[MannedTurretControl], obj), "turret-control")
val bldg = Building(0, Zone.Nowhere, StructureType.Building)
bldg.Amenities = obj
"MannedTurretControl" should {
"seating even with mismatched faction affiliation when FactionLock is false" in {
assert(player.Faction == PlanetSideEmpire.TR)
assert(obj.Faction == PlanetSideEmpire.NEUTRAL)
assert(!obj.Definition.FactionLocked)
obj.Actor ! Mountable.TryMount(player, 0)
val reply = receiveOne(300 milliseconds)
reply match {
case msg : Mountable.MountMessages =>
assert(msg.response.isInstanceOf[Mountable.CanMount])
case _ =>
assert(false)
}
}
}
}

7
common/src/test/scala/objects/MountableTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{Actor, ActorRef, Props}
import base.ActorTest
import net.psforever.objects.{Avatar, Player}
import net.psforever.objects.definition.{ObjectDefinition, SeatDefinition}
import net.psforever.objects.serverobject.mount.{Mountable, MountableBehavior}
@ -12,7 +13,7 @@ import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import scala.concurrent.duration.Duration
class MountableControl1Test extends ActorTest() {
class MountableControl1Test extends ActorTest {
"MountableControl" should {
"construct" in {
val obj = new MountableTest.MountableTestObject
@ -22,7 +23,7 @@ class MountableControl1Test extends ActorTest() {
}
}
class MountableControl2Test extends ActorTest() {
class MountableControl2Test extends ActorTest {
"MountableControl" should {
"let a player mount" in {
val player = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
@ -43,7 +44,7 @@ class MountableControl2Test extends ActorTest() {
}
}
class MountableControl3Test extends ActorTest() {
class MountableControl3Test extends ActorTest {
"MountableControl" should {
"block a player from mounting" in {
val player1 = Player(Avatar("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

332
common/src/test/scala/objects/ResourceSiloTest.scala Normal file
View file

@ -0,0 +1,332 @@
// Copyright (c) 2017 PSForever
package objects
import akka.actor.{Actor, Props}
import akka.routing.RandomPool
import akka.testkit.TestProbe
import base.ActorTest
import net.psforever.objects.guid.TaskResolver
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.objects.serverobject.resourcesilo.{ResourceSilo, ResourceSiloControl, ResourceSiloDefinition}
import net.psforever.objects.serverobject.structures.{Building, StructureType}
import net.psforever.objects.zones.Zone
import net.psforever.packet.game.{PlanetSideGUID, UseItemMessage}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
import org.specs2.mutable.Specification
import services.ServiceManager
import services.avatar.{AvatarAction, AvatarService, AvatarServiceMessage}
import scala.concurrent.duration._
class ResourceSiloTest extends Specification {
"Resource Silo" should {
"define" in {
val obj = new ResourceSiloDefinition
obj.ObjectId mustEqual 731
}
"construct" in {
val obj = ResourceSilo()
obj.Definition mustEqual GlobalDefinitions.resource_silo
obj.MaximumCharge mustEqual 1000
obj.ChargeLevel mustEqual 0
obj.LowNtuWarningOn mustEqual 0
obj.CapacitorDisplay mustEqual 0
//
obj.ChargeLevel = 50
obj.LowNtuWarningOn = 25
obj.CapacitorDisplay = 75
obj.ChargeLevel mustEqual 50
obj.LowNtuWarningOn mustEqual 25
obj.CapacitorDisplay mustEqual 75
}
"charge level can not exceed limits(0 to maximum)" in {
val obj = ResourceSilo()
obj.ChargeLevel mustEqual 0
obj.ChargeLevel = -5
obj.ChargeLevel mustEqual 0
obj.ChargeLevel = 1250
obj.ChargeLevel mustEqual 1000
obj.ChargeLevel mustEqual obj.MaximumCharge
}
"using the silo generates a charge event" in {
val msg = UseItemMessage(PlanetSideGUID(1), PlanetSideGUID(0), PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
ResourceSilo().Use(ResourceSiloTest.player, msg) mustEqual ResourceSilo.ChargeEvent()
}
}
}
class ResourceSiloControlStartupTest extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
val probe = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe), "avatar")
"Resource silo" should {
"startup properly" in {
expectNoMsg(500 milliseconds)
system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
expectNoMsg(1 seconds)
assert(true)
}
}
}
class ResourceSiloControlUseTest extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val probe = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe), "avatar")
val msg = UseItemMessage(PlanetSideGUID(1), PlanetSideGUID(0), PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
"Resource silo" should {
"respond when being used" in {
expectNoMsg(1 seconds)
obj.Actor ! ResourceSilo.Use(ResourceSiloTest.player, msg)
val reply = receiveOne(500 milliseconds)
assert(reply.isInstanceOf[ResourceSilo.ResourceSiloMessage])
assert(reply.asInstanceOf[ResourceSilo.ResourceSiloMessage].player == ResourceSiloTest.player)
assert(reply.asInstanceOf[ResourceSilo.ResourceSiloMessage].msg == msg)
assert(reply.asInstanceOf[ResourceSilo.ResourceSiloMessage].response == ResourceSilo.ChargeEvent())
}
}
}
class ResourceSiloControlNtuWarningTest extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val probe = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe), "avatar")
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
obj.Owner = new Building(0, Zone.Nowhere, StructureType.Building) {
ModelId = 6
}
"Resource silo" should {
"announce low ntu" in {
expectNoMsg(1 seconds)
assert(obj.LowNtuWarningOn == 0)
obj.Actor ! ResourceSilo.LowNtuWarning(10)
val reply = probe.receiveOne(500 milliseconds)
assert(obj.LowNtuWarningOn == 10)
assert(reply.isInstanceOf[AvatarServiceMessage])
assert(reply.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
assert(reply.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 47)
assert(reply.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 10)
}
}
}
class ResourceSiloControlUpdate1Test extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val probe1 = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe1), "avatar")
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
val bldg = new Building(0, Zone.Nowhere, StructureType.Building) {
ModelId = 6
}
val probe2 = TestProbe()
bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
obj.Owner = bldg
"Resource silo" should {
"update the charge level and capacitor display (report low ntu, power restored)" in {
expectNoMsg(1 seconds)
assert(obj.ChargeLevel == 0)
assert(obj.CapacitorDisplay == 0)
obj.Actor ! ResourceSilo.UpdateChargeLevel(105)
val reply1 = probe1.receiveOne(500 milliseconds)
val reply2 = probe2.receiveOne(500 milliseconds)
assert(obj.ChargeLevel == 105)
assert(obj.CapacitorDisplay == 1)
assert(reply1.isInstanceOf[AvatarServiceMessage])
assert(reply1.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(1))
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 45)
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 1)
assert(reply2.isInstanceOf[Building.SendMapUpdateToAllClients])
val reply3 = probe1.receiveOne(500 milliseconds)
assert(reply3.isInstanceOf[AvatarServiceMessage])
assert(reply3.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 48)
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 0)
val reply4 = probe1.receiveOne(500 milliseconds)
assert(obj.LowNtuWarningOn == 1)
assert(reply4.isInstanceOf[AvatarServiceMessage])
assert(reply4.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply4.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply4.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
assert(reply4.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 47)
assert(reply4.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 1)
}
}
}
class ResourceSiloControlUpdate2Test extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val probe1 = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe1), "avatar")
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
val bldg = new Building(0, Zone.Nowhere, StructureType.Building) {
ModelId = 6
}
val probe2 = TestProbe()
bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
obj.Owner = bldg
"Resource silo" should {
"update the charge level and capacitor display (report good ntu)" in {
expectNoMsg(1 seconds)
obj.ChargeLevel = 100
obj.CapacitorDisplay = 1
obj.LowNtuWarningOn = 1
assert(obj.ChargeLevel == 100)
assert(obj.CapacitorDisplay == 1)
assert(obj.LowNtuWarningOn == 1)
obj.Actor ! ResourceSilo.UpdateChargeLevel(105)
val reply1 = probe1.receiveOne(500 milliseconds)
val reply2 = probe2.receiveOne(500 milliseconds)
assert(obj.ChargeLevel == 205)
assert(obj.CapacitorDisplay == 2)
assert(reply1.isInstanceOf[AvatarServiceMessage])
assert(reply1.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(1))
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 45)
assert(reply1.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 2)
assert(reply2.isInstanceOf[Building.SendMapUpdateToAllClients])
val reply3 = probe1.receiveOne(500 milliseconds)
assert(obj.LowNtuWarningOn == 0)
assert(reply3.isInstanceOf[AvatarServiceMessage])
assert(reply3.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].player_guid == PlanetSideGUID(6))
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_type == 47)
assert(reply3.asInstanceOf[AvatarServiceMessage]
.actionMessage.asInstanceOf[AvatarAction.PlanetsideAttribute].attribute_value == 0)
}
}
}
class ResourceSiloControlNoUpdateTest extends ActorTest {
val serviceManager = ServiceManager.boot(system)
serviceManager ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val probe1 = TestProbe()
serviceManager ! ServiceManager.Register(Props(classOf[ResourceSiloTest.ProbedAvatarService], probe1), "avatar")
val obj = ResourceSilo()
obj.GUID = PlanetSideGUID(1)
obj.Actor = system.actorOf(Props(classOf[ResourceSiloControl], obj), "test-silo")
obj.Actor ! "startup"
val bldg = new Building(0, Zone.Nowhere, StructureType.Building) {
ModelId = 6
}
val probe2 = TestProbe()
bldg.Actor = system.actorOf(Props(classOf[ResourceSiloTest.ProbedBuildingControl], probe2), "test-bldg")
obj.Owner = bldg
"Resource silo" should {
"update, but not sufficiently to change the capacitor display" in {
expectNoMsg(1 seconds)
obj.ChargeLevel = 250
obj.CapacitorDisplay = 3
obj.LowNtuWarningOn = 0
assert(obj.ChargeLevel == 250)
assert(obj.CapacitorDisplay == 3)
assert(obj.LowNtuWarningOn == 0)
obj.Actor ! ResourceSilo.UpdateChargeLevel(50)
expectNoMsg(500 milliseconds)
probe1.expectNoMsg(500 milliseconds)
probe2.expectNoMsg(500 milliseconds)
assert(obj.ChargeLevel == 300)
assert(obj.CapacitorDisplay == 3)
assert(obj.LowNtuWarningOn == 0)
}
}
}
object ResourceSiloTest {
val player = Player(Avatar("TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
class ProbedAvatarService(probe : TestProbe) extends Actor {
override def receive : Receive = {
case msg =>
probe.ref ! msg
}
}
class ProbedBuildingControl(probe : TestProbe) extends Actor {
override def receive : Receive = {
case msg =>
probe.ref ! msg
}
}
class ProbedResourceSiloControl(silo : ResourceSilo, probe : TestProbe) extends ResourceSiloControl(silo) {
override def receive : Receive = {
case msg =>
super.receive.apply(msg)
probe.ref ! msg
}
}
}

47
common/src/test/scala/objects/ServerObjectBuilderTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{Actor, ActorContext, Props}
import base.ActorTest
import net.psforever.objects.guid.NumberPoolHub
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.objects.serverobject.ServerObjectBuilder
@ -137,7 +138,8 @@ class ProximityTerminalObjectBuilderTest extends ActorTest {
"Terminal object" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1, ProximityTerminal.Constructor(medical_terminal)), hub), "term")
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
ProximityTerminal.Constructor(medical_terminal)), hub), "term")
actor ! "!"
val reply = receiveOne(Duration.create(1000, "ms"))
@ -172,7 +174,7 @@ class VehicleSpawnPadObjectBuilderTest extends ActorTest {
class LocalProjectileBuilderTest extends ActorTest {
import net.psforever.objects.LocalProjectile
"Local ProjectileBuilder" should {
"Local projectile object" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
@ -190,7 +192,7 @@ class LocalProjectileBuilderTest extends ActorTest {
class LockerObjectBuilderTest extends ActorTest {
import net.psforever.objects.serverobject.mblocker.Locker
"LockerObjectBuilder" should {
"Locker object" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
@ -206,9 +208,27 @@ class LockerObjectBuilderTest extends ActorTest {
}
}
class ResourceSiloObjectBuilderTest extends ActorTest {
import net.psforever.objects.serverobject.resourcesilo.ResourceSilo
"Resource silo object" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
ResourceSilo.Constructor), hub), "spawn-tube")
actor ! "startup"
val reply = receiveOne(Duration.create(1000, "ms"))
assert(reply.isInstanceOf[ResourceSilo])
assert(reply.asInstanceOf[ResourceSilo].HasGUID)
assert(reply.asInstanceOf[ResourceSilo].GUID == PlanetSideGUID(1))
assert(reply == hub(1).get)
}
}
}
class SpawnTubeObjectBuilderTest extends ActorTest {
import net.psforever.objects.serverobject.tube.SpawnTube
"LockerObjectBuilder" should {
"Spawn tube object" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
@ -226,6 +246,25 @@ class SpawnTubeObjectBuilderTest extends ActorTest {
}
}
class MannedTurretObjectBuilderTest extends ActorTest {
import net.psforever.objects.GlobalDefinitions.manned_turret
import net.psforever.objects.serverobject.turret.MannedTurret
"MannedTurretObjectBuilder" should {
"build" in {
val hub = ServerObjectBuilderTest.NumberPoolHub
val actor = system.actorOf(Props(classOf[ServerObjectBuilderTest.BuilderTestActor], ServerObjectBuilder(1,
MannedTurret.Constructor(manned_turret)), hub), "spawn-tube")
actor ! "!"
val reply = receiveOne(Duration.create(1000, "ms"))
assert(reply.isInstanceOf[MannedTurret])
assert(reply.asInstanceOf[MannedTurret].HasGUID)
assert(reply.asInstanceOf[MannedTurret].GUID == PlanetSideGUID(1))
assert(reply == hub(1).get)
}
}
}
object ServerObjectBuilderTest {
import net.psforever.objects.guid.source.LimitedNumberSource
def NumberPoolHub : NumberPoolHub = {

3
common/src/test/scala/objects/SpawnTubeTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{ActorRef, Props}
import base.ActorTest
import net.psforever.objects.GlobalDefinitions
import net.psforever.objects.serverobject.tube.{SpawnTube, SpawnTubeControl, SpawnTubeDefinition}
import org.specs2.mutable.Specification
@ -48,7 +49,7 @@ class SpawnTubeTest extends Specification {
}
}
class SpawnTubeControlTest extends ActorTest() {
class SpawnTubeControlTest extends ActorTest {
"SpawnTubeControl" should {
"construct" in {
val obj = SpawnTube(GlobalDefinitions.ams_respawn_tube)

9
common/src/test/scala/objects/UtilityTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.{Actor, ActorRef, Props}
import base.ActorTest
import net.psforever.objects.{GlobalDefinitions, Vehicle}
import net.psforever.objects.serverobject.terminals.Terminal
import net.psforever.objects.vehicles._
@ -73,7 +74,7 @@ class UtilityTest extends Specification {
}
}
class Utility1Test extends ActorTest() {
class Utility1Test extends ActorTest {
"Utility" should {
"wire an order_terminala Actor" in {
val obj = Utility(UtilityType.order_terminala, UtilityTest.vehicle)
@ -87,7 +88,7 @@ class Utility1Test extends ActorTest() {
}
}
class Utility2Test extends ActorTest() {
class Utility2Test extends ActorTest {
"Utility" should {
"wire an order_terminalb Actor" in {
val obj = Utility(UtilityType.order_terminalb, UtilityTest.vehicle)
@ -101,7 +102,7 @@ class Utility2Test extends ActorTest() {
}
}
class Utility3Test extends ActorTest() {
class Utility3Test extends ActorTest {
"Utility" should {
"wire a matrix_terminalc Actor" in {
val obj = Utility(UtilityType.matrix_terminalc, UtilityTest.vehicle)
@ -115,7 +116,7 @@ class Utility3Test extends ActorTest() {
}
}
class Utility4Test extends ActorTest() {
class Utility4Test extends ActorTest {
"Utility" should {
"wire an ams_respawn_tube Actor" in {
val obj = Utility(UtilityType.ams_respawn_tube, UtilityTest.vehicle)

14
common/src/test/scala/objects/VehicleSpawnPadTest.scala
View file

@ -3,7 +3,7 @@ package objects
import akka.actor.{ActorRef, ActorSystem, Props}
import akka.testkit.TestProbe
import net.psforever.objects.ballistics.Projectile
import base.ActorTest
import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.serverobject.pad.{VehicleSpawnControl, VehicleSpawnPad}
import net.psforever.objects.serverobject.structures.StructureType
@ -39,7 +39,7 @@ class VehicleSpawnPadTest extends Specification {
}
}
class VehicleSpawnControl1Test extends ActorTest() {
class VehicleSpawnControl1Test extends ActorTest {
"VehicleSpawnControl" should {
"construct" in {
val obj = VehicleSpawnPad(GlobalDefinitions.spawn_pad)
@ -49,7 +49,7 @@ class VehicleSpawnControl1Test extends ActorTest() {
}
}
class VehicleSpawnControl2aTest extends ActorTest() {
class VehicleSpawnControl2aTest extends ActorTest {
// This runs for a long time.
"VehicleSpawnControl" should {
"complete on a vehicle order (block a second one until the first is done and the spawn pad is cleared)" in {
@ -113,7 +113,7 @@ class VehicleSpawnControl2aTest extends ActorTest() {
}
}
class VehicleSpawnControl2bTest extends ActorTest() {
class VehicleSpawnControl2bTest extends ActorTest {
// This runs for a long time.
"VehicleSpawnControl" should {
"complete on a vehicle order (railless)" in {
@ -170,7 +170,7 @@ class VehicleSpawnControl2bTest extends ActorTest() {
}
}
class VehicleSpawnControl3Test extends ActorTest() {
class VehicleSpawnControl3Test extends ActorTest {
"VehicleSpawnControl" should {
"player is on wrong continent before vehicle can partially load; vehicle is cleaned up" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
@ -241,7 +241,7 @@ class VehicleSpawnControl4Test extends ActorTest() {
// }
//}
class VehicleSpawnControl5Test extends ActorTest() {
class VehicleSpawnControl5Test extends ActorTest {
"VehicleSpawnControl" should {
"player dies right after vehicle partially loads; the vehicle spawns and blocks the pad" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)
@ -274,7 +274,7 @@ class VehicleSpawnControl5Test extends ActorTest() {
}
}
class VehicleSpawnControl6Test extends ActorTest() {
class VehicleSpawnControl6Test extends ActorTest {
"VehicleSpawnControl" should {
"the player can not sit in vehicle; vehicle spawns and blocks the pad" in {
val (vehicle, player, pad, zone) = VehicleSpawnPadControlTest.SetUpAgents(PlanetSideEmpire.TR)

1
common/src/test/scala/objects/VehicleTest.scala
View file

@ -2,6 +2,7 @@
package objects
import akka.actor.Props
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.definition.{SeatDefinition, VehicleDefinition}
import net.psforever.objects.serverobject.mount.Mountable

10
common/src/test/scala/objects/ZoneTest.scala
View file

@ -4,6 +4,7 @@ package objects
import java.util.concurrent.atomic.AtomicInteger
import akka.actor.{ActorContext, ActorRef, Props}
import base.ActorTest
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.equipment.Equipment
import net.psforever.objects.guid.NumberPoolHub
@ -74,6 +75,15 @@ class ZoneTest extends Specification {
map.TerminalToInterface(3, 4)
map.TerminalToInterface mustEqual Map(1 -> 2, 3 -> 4)
}
"associate turrets to weapons" in {
val map = new ZoneMap("map13")
map.TurretToWeapon mustEqual Map.empty
map.TurretToWeapon(1, 2)
map.TurretToWeapon mustEqual Map(1 -> 2)
map.TurretToWeapon(3, 4)
map.TurretToWeapon mustEqual Map(1 -> 2, 3 -> 4)
}
}
val map13 = new ZoneMap("map13")

2
common/src/test/scala/objects/guidtask/GUIDTaskRegister1Test.scala
View file

@ -1,8 +1,8 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskRegister1Test extends ActorTest {
"RegisterObjectTask" in {

4
common/src/test/scala/objects/guidtask/GUIDTaskRegister2Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskRegister2Test extends ActorTest() {
class GUIDTaskRegister2Test extends ActorTest {
"RegisterEquipment -> RegisterObjectTask" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)

4
common/src/test/scala/objects/guidtask/GUIDTaskRegister3Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskRegister3Test extends ActorTest() {
class GUIDTaskRegister3Test extends ActorTest {
"RegisterEquipment -> RegisterTool" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Tool(GlobalDefinitions.beamer)

4
common/src/test/scala/objects/guidtask/GUIDTaskRegister4Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskRegister4Test extends ActorTest() {
class GUIDTaskRegister4Test extends ActorTest {
"RegisterVehicle" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Vehicle(GlobalDefinitions.fury)

4
common/src/test/scala/objects/guidtask/GUIDTaskRegister5Test.scala
View file

@ -1,12 +1,12 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
class GUIDTaskRegister5Test extends ActorTest() {
class GUIDTaskRegister5Test extends ActorTest {
"RegisterAvatar" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

4
common/src/test/scala/objects/guidtask/GUIDTaskRegister6Test.scala
View file

@ -1,12 +1,12 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
class GUIDTaskRegister6Test extends ActorTest() {
class GUIDTaskRegister6Test extends ActorTest {
"RegisterPlayer" in {
val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister1Test.scala
View file

@ -1,10 +1,10 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskUnregister1Test extends ActorTest() {
class GUIDTaskUnregister1Test extends ActorTest {
"UnregisterObjectTask" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = new GUIDTaskTest.TestObject

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister2Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskUnregister2Test extends ActorTest() {
class GUIDTaskUnregister2Test extends ActorTest {
"UnregisterEquipment -> UnregisterObjectTask" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = AmmoBox(GlobalDefinitions.energy_cell)

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister3Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskUnregister3Test extends ActorTest() {
class GUIDTaskUnregister3Test extends ActorTest {
"UnregisterEquipment -> UnregisterTool" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Tool(GlobalDefinitions.beamer)

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister4Test.scala
View file

@ -1,11 +1,11 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import objects.ActorTest
class GUIDTaskUnregister4Test extends ActorTest() {
class GUIDTaskUnregister4Test extends ActorTest {
"RegisterVehicle" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Vehicle(GlobalDefinitions.fury)

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister5Test.scala
View file

@ -1,12 +1,12 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
class GUIDTaskUnregister5Test extends ActorTest() {
class GUIDTaskUnregister5Test extends ActorTest {
"UnregisterAvatar" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

4
common/src/test/scala/objects/guidtask/GUIDTaskUnregister6Test.scala
View file

@ -1,12 +1,12 @@
// Copyright (c) 2017 PSForever
package objects.guidtask
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
class GUIDTaskUnregister6Test extends ActorTest() {
class GUIDTaskUnregister6Test extends ActorTest {
"UnregisterPlayer" in {
val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup
val obj = Player(Avatar("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))

8
common/src/test/scala/objects/number/NumberPoolActorTest.scala
View file

@ -2,14 +2,14 @@
package objects.number
import akka.actor.{ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.guid.actor.NumberPoolActor
import net.psforever.objects.guid.pool.ExclusivePool
import net.psforever.objects.guid.selector.RandomSelector
import objects.ActorTest
import scala.concurrent.duration.Duration
class NumberPoolActorTest extends ActorTest() {
class NumberPoolActorTest extends ActorTest {
"NumberPoolActor" should {
"GetAnyNumber" in {
val pool = new ExclusivePool((25 to 50).toList)
@ -22,7 +22,7 @@ class NumberPoolActorTest extends ActorTest() {
}
}
class NumberPoolActorTest1 extends ActorTest() {
class NumberPoolActorTest1 extends ActorTest {
"NumberPoolActor" should {
"GetSpecificNumber" in {
val pool = new ExclusivePool((25 to 50).toList)
@ -34,7 +34,7 @@ class NumberPoolActorTest1 extends ActorTest() {
}
}
class NumberPoolActorTest2 extends ActorTest() {
class NumberPoolActorTest2 extends ActorTest {
"NumberPoolActor" should {
"NoNumber" in {
val pool = new ExclusivePool((25 to 25).toList) //pool only has one number - 25

4
common/src/test/scala/objects/number/UniqueNumberSystemTest.scala
View file

@ -2,17 +2,17 @@
package objects.number
import akka.actor.{ActorRef, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.entity.IdentifiableEntity
import net.psforever.objects.guid.NumberPoolHub
import net.psforever.objects.guid.actor.{NumberPoolActor, Register, UniqueNumberSystem, Unregister}
import net.psforever.objects.guid.selector.RandomSelector
import net.psforever.objects.guid.source.LimitedNumberSource
import objects.ActorTest
import scala.concurrent.duration.Duration
import scala.util.{Failure, Success}
class AllocateNumberPoolActors extends ActorTest() {
class AllocateNumberPoolActors extends ActorTest {
"AllocateNumberPoolActors" in {
val src : LimitedNumberSource = LimitedNumberSource(6000)
val guid : NumberPoolHub = new NumberPoolHub(src)

12
common/src/test/scala/objects/terminal/ImplantTerminalMechTest.scala
View file

@ -2,6 +2,7 @@
package objects.terminal
import akka.actor.{ActorRef, ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.definition.SeatDefinition
import net.psforever.objects.serverobject.mount.Mountable
import net.psforever.objects.serverobject.implantmech.{ImplantTerminalMech, ImplantTerminalMechControl}
@ -9,7 +10,6 @@ import net.psforever.objects.serverobject.structures.StructureType
import net.psforever.objects.vehicles.Seat
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
import objects.ActorTest
import org.specs2.mutable.Specification
import scala.concurrent.duration.Duration
@ -56,7 +56,7 @@ class ImplantTerminalMechTest extends Specification {
}
}
class ImplantTerminalMechControl1Test extends ActorTest() {
class ImplantTerminalMechControl1Test extends ActorTest {
"ImplantTerminalMechControl" should {
"construct" in {
val obj = ImplantTerminalMech(GlobalDefinitions.implant_terminal_mech)
@ -66,7 +66,7 @@ class ImplantTerminalMechControl1Test extends ActorTest() {
}
}
class ImplantTerminalMechControl2Test extends ActorTest() {
class ImplantTerminalMechControl2Test extends ActorTest {
"ImplantTerminalMechControl" should {
"let a player mount" in {
val (player, mech) = ImplantTerminalMechTest.SetUpAgents(PlanetSideEmpire.TR)
@ -85,7 +85,7 @@ class ImplantTerminalMechControl2Test extends ActorTest() {
}
}
class ImplantTerminalMechControl3Test extends ActorTest() {
class ImplantTerminalMechControl3Test extends ActorTest {
import net.psforever.types.CharacterGender
"ImplantTerminalMechControl" should {
"block a player from mounting" in {
@ -108,7 +108,7 @@ class ImplantTerminalMechControl3Test extends ActorTest() {
}
}
class ImplantTerminalMechControl4Test extends ActorTest() {
class ImplantTerminalMechControl4Test extends ActorTest {
"ImplantTerminalMechControl" should {
"dismount player after mounting" in {
val (player, mech) = ImplantTerminalMechTest.SetUpAgents(PlanetSideEmpire.TR)
@ -130,7 +130,7 @@ class ImplantTerminalMechControl4Test extends ActorTest() {
}
}
class ImplantTerminalMechControl5Test extends ActorTest() {
class ImplantTerminalMechControl5Test extends ActorTest {
"ImplantTerminalMechControl" should {
"block a player from dismounting" in {
val (player, mech) = ImplantTerminalMechTest.SetUpAgents(PlanetSideEmpire.TR)

12
common/src/test/scala/objects/terminal/ProximityTerminalControlTest.scala
View file

@ -2,16 +2,16 @@
package objects.terminal
import akka.actor.{ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.serverobject.CommonMessages
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.objects.serverobject.terminals._
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
import scala.concurrent.duration.Duration
class ProximityTerminalControl1Test extends ActorTest() {
class ProximityTerminalControl1Test extends ActorTest {
"ProximityTerminalControl" should {
"construct (medical terminal)" in {
val terminal = ProximityTerminal(GlobalDefinitions.medical_terminal)
@ -20,7 +20,7 @@ class ProximityTerminalControl1Test extends ActorTest() {
}
}
class ProximityTerminalControl2Test extends ActorTest() {
class ProximityTerminalControl2Test extends ActorTest {
"ProximityTerminalControl can not process wrong messages" in {
val (_, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
@ -30,7 +30,7 @@ class ProximityTerminalControl2Test extends ActorTest() {
}
//terminal control is mostly a pass-through actor for Terminal.Exchange messages, wrapped in Terminal.TerminalMessage protocol
class MedicalTerminalControl1Test extends ActorTest() {
class MedicalTerminalControl1Test extends ActorTest {
"ProximityTerminalControl sends a message to the first new user only" in {
val (player, terminal) = ProximityTerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
player.GUID = PlanetSideGUID(10)
@ -53,7 +53,7 @@ class MedicalTerminalControl1Test extends ActorTest() {
}
}
class MedicalTerminalControl2Test extends ActorTest() {
class MedicalTerminalControl2Test extends ActorTest {
"ProximityTerminalControl sends a message to the last user only" in {
val (player, terminal) : (Player, ProximityTerminal) = ProximityTerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
player.GUID = PlanetSideGUID(10)
@ -82,7 +82,7 @@ class MedicalTerminalControl2Test extends ActorTest() {
}
}
class MedicalTerminalControl3Test extends ActorTest() {
class MedicalTerminalControl3Test extends ActorTest {
"ProximityTerminalControl sends a message to the last user only (confirmation of test #2)" in {
val (player, terminal) : (Player, ProximityTerminal) = ProximityTerminalControlTest.SetUpAgents(GlobalDefinitions.medical_terminal, PlanetSideEmpire.TR)
player.GUID = PlanetSideGUID(10)

2
common/src/test/scala/objects/terminal/ProximityTest.scala
View file

@ -2,13 +2,13 @@
package objects.terminal
import akka.actor.Props
import base.ActorTest
import net.psforever.objects.serverobject.CommonMessages
import net.psforever.objects.serverobject.terminals.Terminal.TerminalMessage
import net.psforever.objects.serverobject.terminals.{ProximityTerminal, ProximityTerminalControl, ProximityUnit, Terminal}
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire}
import objects.ActorTest
import org.specs2.mutable.Specification
import scala.concurrent.duration._

16
common/src/test/scala/objects/terminal/TerminalControlTest.scala
View file

@ -2,17 +2,17 @@
package objects.terminal
import akka.actor.{ActorSystem, Props}
import base.ActorTest
import net.psforever.objects.serverobject.structures.{Building, StructureType}
import net.psforever.objects.serverobject.terminals.{Terminal, TerminalControl, TerminalDefinition}
import net.psforever.objects.zones.Zone
import net.psforever.objects.{Avatar, GlobalDefinitions, Player}
import net.psforever.packet.game.{ItemTransactionMessage, PlanetSideGUID}
import net.psforever.types._
import objects.ActorTest
import scala.concurrent.duration.Duration
class TerminalControl1Test extends ActorTest() {
class TerminalControl1Test extends ActorTest {
"TerminalControl" should {
"construct (cert terminal)" in {
val terminal = Terminal(GlobalDefinitions.cert_terminal)
@ -21,7 +21,7 @@ class TerminalControl1Test extends ActorTest() {
}
}
class TerminalControl2Test extends ActorTest() {
class TerminalControl2Test extends ActorTest {
"TerminalControl can not process wrong messages" in {
val (_, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
@ -32,7 +32,7 @@ class TerminalControl2Test extends ActorTest() {
//terminal control is mostly a pass-through actor for Terminal.Exchange messages, wrapped in Terminal.TerminalMessage protocol
//test for Cert_Terminal messages (see CertTerminalTest)
class CertTerminalControl1Test extends ActorTest() {
class CertTerminalControl1Test extends ActorTest {
"TerminalControl can be used to learn a certification ('medium_assault')" in {
val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "medium_assault", 0, PlanetSideGUID(0))
@ -47,7 +47,7 @@ class CertTerminalControl1Test extends ActorTest() {
}
}
class CertTerminalControl2Test extends ActorTest() {
class CertTerminalControl2Test extends ActorTest {
"TerminalControl can be used to warn about not learning a fake certification ('juggling')" in {
val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "juggling", 0, PlanetSideGUID(0))
@ -62,7 +62,7 @@ class CertTerminalControl2Test extends ActorTest() {
}
}
class CertTerminalControl3Test extends ActorTest() {
class CertTerminalControl3Test extends ActorTest {
"TerminalControl can be used to forget a certification ('medium_assault')" in {
val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.cert_terminal, PlanetSideEmpire.TR)
val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Sell, 0, "medium_assault", 0, PlanetSideGUID(0))
@ -77,7 +77,7 @@ class CertTerminalControl3Test extends ActorTest() {
}
}
class VehicleTerminalControl1Test extends ActorTest() {
class VehicleTerminalControl1Test extends ActorTest {
"TerminalControl can be used to buy a vehicle ('two_man_assault_buggy')" in {
val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.ground_vehicle_terminal, PlanetSideEmpire.TR)
val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "two_man_assault_buggy", 0, PlanetSideGUID(0))
@ -102,7 +102,7 @@ class VehicleTerminalControl1Test extends ActorTest() {
}
}
class VehicleTerminalControl2Test extends ActorTest() {
class VehicleTerminalControl2Test extends ActorTest {
"TerminalControl can be used to warn about not buy a vehicle ('harasser')" in {
val (player, terminal) = TerminalControlTest.SetUpAgents(GlobalDefinitions.ground_vehicle_terminal, PlanetSideEmpire.TR)
val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "harasser", 0, PlanetSideGUID(0))

544
common/src/test/scala/service/AvatarServiceTest.scala Normal file
View file

@ -0,0 +1,544 @@
// Copyright (c) 2017 PSForever
package service
import akka.actor.Props
import akka.routing.RandomPool
import base.ActorTest
import net.psforever.objects._
import net.psforever.objects.guid.{GUIDTask, TaskResolver}
import net.psforever.objects.zones.{Zone, ZoneActor, ZoneMap}
import net.psforever.packet.game.objectcreate.{DroppedItemData, ObjectClass, ObjectCreateMessageParent, PlacementData}
import net.psforever.packet.game.{ObjectCreateMessage, PlanetSideGUID, PlayerStateMessageUpstream}
import net.psforever.types._
import services.{RemoverActor, Service, ServiceManager}
import services.avatar._
import scala.concurrent.duration._
class AvatarService1Test extends ActorTest {
"AvatarService" should {
"construct" in {
ServiceManager.boot(system)
system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
assert(true)
}
}
}
class AvatarService2Test extends ActorTest {
"AvatarService" should {
"subscribe" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
assert(true)
}
}
}
class AvatarService3Test extends ActorTest {
"AvatarService" should {
ServiceManager.boot(system)
"subscribe to a specific channel" in {
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! Service.Leave()
assert(true)
}
}
}
class AvatarService4Test extends ActorTest {
"AvatarService" should {
"subscribe" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! Service.LeaveAll()
assert(true)
}
}
}
class AvatarService5Test extends ActorTest {
"AvatarService" should {
"pass an unhandled message" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! "hello"
expectNoMsg()
}
}
}
class ArmorChangedTest extends ActorTest {
"AvatarService" should {
"pass ArmorChanged" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ArmorChanged(PlanetSideGUID(10), ExoSuitType.Reinforced, 0))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ArmorChanged(ExoSuitType.Reinforced, 0)))
}
}
}
class ConcealPlayerTest extends ActorTest {
"AvatarService" should {
"pass ConcealPlayer" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ConcealPlayer(PlanetSideGUID(10)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ConcealPlayer()))
}
}
}
class EquipmentInHandTest extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "release-test-service")
val zone = new Zone("test", new ZoneMap("test-map"), 0)
val taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
val toolDef = GlobalDefinitions.beamer
val tool = Tool(toolDef)
tool.GUID = PlanetSideGUID(40)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(41)
val pkt = ObjectCreateMessage(
toolDef.ObjectId,
tool.GUID,
ObjectCreateMessageParent(PlanetSideGUID(11), 2),
toolDef.Packet.ConstructorData(tool).get
)
"AvatarService" should {
"pass EquipmentInHand" in {
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.EquipmentInHand(PlanetSideGUID(10), PlanetSideGUID(11), 2, tool))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.EquipmentInHand(pkt)))
}
}
}
class DroptItemTest extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "release-test-service")
val zone = new Zone("test", new ZoneMap("test-map"), 0)
val taskResolver = system.actorOf(Props[TaskResolver], "drop-item-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "drop-item-test-zone")
zone.Actor ! Zone.Init()
val toolDef = GlobalDefinitions.beamer
val tool = Tool(toolDef)
tool.Position = Vector3(1,2,3)
tool.Orientation = Vector3(4,5,6)
tool.GUID = PlanetSideGUID(40)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(41)
val pkt = ObjectCreateMessage(
toolDef.ObjectId,
tool.GUID,
DroppedItemData(
PlacementData(tool.Position, tool.Orientation),
toolDef.Packet.ConstructorData(tool).get
)
)
"AvatarService" should {
"pass DropItem" in {
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.DropItem(PlanetSideGUID(10), tool, zone))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.DropItem(pkt)))
}
}
}
class LoadPlayerTest extends ActorTest {
val obj = Player(Avatar("TestCharacter1", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
obj.GUID = PlanetSideGUID(10)
obj.Slot(5).Equipment.get.GUID = PlanetSideGUID(11)
val c1data = obj.Definition.Packet.DetailedConstructorData(obj).get
val pkt1 = ObjectCreateMessage(ObjectClass.avatar, PlanetSideGUID(10), c1data)
val parent = ObjectCreateMessageParent(PlanetSideGUID(12), 0)
obj.VehicleSeated = PlanetSideGUID(12)
val c2data = obj.Definition.Packet.DetailedConstructorData(obj).get
val pkt2 = ObjectCreateMessage(ObjectClass.avatar, PlanetSideGUID(10), parent, c2data)
"AvatarService" should {
"pass LoadPlayer" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
//no parent data
service ! AvatarServiceMessage("test", AvatarAction.LoadPlayer(
PlanetSideGUID(20), ObjectClass.avatar, PlanetSideGUID(10), c1data, None)
)
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(20), AvatarResponse.LoadPlayer(pkt1)))
//parent data
service ! AvatarServiceMessage("test", AvatarAction.LoadPlayer(
PlanetSideGUID(20), ObjectClass.avatar, PlanetSideGUID(10), c2data, Some(parent))
)
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(20), AvatarResponse.LoadPlayer(pkt2)))
}
}
}
class ObjectDeleteTest extends ActorTest {
"AvatarService" should {
"pass ObjectDelete" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ObjectDelete(PlanetSideGUID(10), PlanetSideGUID(11)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ObjectDelete(PlanetSideGUID(11), 0)))
service ! AvatarServiceMessage("test", AvatarAction.ObjectDelete(PlanetSideGUID(10), PlanetSideGUID(11), 55))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ObjectDelete(PlanetSideGUID(11), 55)))
}
}
}
class ObjectHeldTest extends ActorTest {
"AvatarService" should {
"pass ObjectHeld" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ObjectHeld(PlanetSideGUID(10), 1))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ObjectHeld(1)))
}
}
}
class PlanetsideAttributeTest extends ActorTest {
"AvatarService" should {
"pass PlanetsideAttribute" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.PlanetsideAttribute(PlanetSideGUID(10), 5, 1200L))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.PlanetsideAttribute(5, 1200L)))
}
}
}
class PlayerStateTest extends ActorTest {
val msg = PlayerStateMessageUpstream(PlanetSideGUID(75), Vector3(3694.1094f, 2735.4531f, 90.84375f), Some(Vector3(4.375f, 2.59375f, 0.0f)), 61.875f, 351.5625f, 0.0f, 136, 0, false, false, false, false, 112, 0)
"AvatarService" should {
"pass PlayerState" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.PlayerState(PlanetSideGUID(10), msg, false, false))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.PlayerState(msg, false, false)))
}
}
}
class PickupItemATest extends ActorTest {
val obj = Player(Avatar("TestCharacter", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
obj.GUID = PlanetSideGUID(10)
obj.Slot(5).Equipment.get.GUID = PlanetSideGUID(11)
val toolDef = GlobalDefinitions.beamer
val tool = Tool(toolDef)
tool.GUID = PlanetSideGUID(40)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(41)
val pkt = ObjectCreateMessage(
toolDef.ObjectId,
tool.GUID,
ObjectCreateMessageParent(PlanetSideGUID(10), 0),
toolDef.Packet.ConstructorData(tool).get
)
"pass PickUpItem as EquipmentInHand (visible pistol slot)" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.PickupItem(PlanetSideGUID(10), Zone.Nowhere, obj, 0, tool))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.EquipmentInHand(pkt)))
}
}
class PickupItemBTest extends ActorTest {
val obj = Player(Avatar("TestCharacter", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
val tool = Tool(GlobalDefinitions.beamer)
tool.GUID = PlanetSideGUID(40)
"pass PickUpItem as ObjectDelete (not visible inventory space)" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.PickupItem(PlanetSideGUID(10), Zone.Nowhere, obj, 6, tool))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ObjectDelete(tool.GUID, 0)))
}
}
class ReloadTest extends ActorTest {
"AvatarService" should {
"pass Reload" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.Reload(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.Reload(PlanetSideGUID(40))))
}
}
}
class ChangeAmmoTest extends ActorTest {
val ammoDef = GlobalDefinitions.energy_cell
val ammoBox = AmmoBox(ammoDef)
"AvatarService" should {
"pass ChangeAmmo" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ChangeAmmo(PlanetSideGUID(10), PlanetSideGUID(40), 0, PlanetSideGUID(40), ammoDef.ObjectId, PlanetSideGUID(41), ammoDef.Packet.ConstructorData(ammoBox).get))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ChangeAmmo(PlanetSideGUID(40), 0, PlanetSideGUID(40), ammoDef.ObjectId, PlanetSideGUID(41), ammoDef.Packet.ConstructorData(ammoBox).get)))
}
}
}
class ChangeFireModeTest extends ActorTest {
val ammoDef = GlobalDefinitions.energy_cell
val ammoBox = AmmoBox(ammoDef)
"AvatarService" should {
"pass ChangeFireMode" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ChangeFireMode(PlanetSideGUID(10), PlanetSideGUID(40), 0))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ChangeFireMode(PlanetSideGUID(40), 0)))
}
}
}
class ChangeFireStateStartTest extends ActorTest {
"AvatarService" should {
"pass ChangeFireState_Start" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ChangeFireState_Start(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ChangeFireState_Start(PlanetSideGUID(40))))
}
}
}
class ChangeFireStateStopTest extends ActorTest {
"AvatarService" should {
"pass ChangeFireState_Stop" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.ChangeFireState_Stop(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.ChangeFireState_Stop(PlanetSideGUID(40))))
}
}
}
class WeaponDryFireTest extends ActorTest {
"AvatarService" should {
"pass WeaponDryFire" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.WeaponDryFire(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.WeaponDryFire(PlanetSideGUID(40))))
}
}
}
class AvatarStowEquipmentTest extends ActorTest {
val tool = Tool(GlobalDefinitions.beamer)
"AvatarService" should {
"pass StowEquipment" in {
ServiceManager.boot(system)
val service = system.actorOf(Props[AvatarService], AvatarServiceTest.TestName)
service ! Service.Join("test")
service ! AvatarServiceMessage("test", AvatarAction.StowEquipment(PlanetSideGUID(10), PlanetSideGUID(11), 2, tool))
expectMsg(AvatarServiceResponse("/test/Avatar", PlanetSideGUID(10), AvatarResponse.StowEquipment(PlanetSideGUID(11), 2, tool)))
}
}
}
/*
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 Zone needs to be set up and initialized properly with a ZoneActor.
The ZoneActor builds the GUID Actor and the ZonePopulationActor.
ALL of these Actors will talk to each other.
The lines of communication can short circuit if the next Actor does not have the correct information.
Putting Actor startup in the main class, outside of the body of the test, helps.
Frequent pauses to allow everything to sort their messages also helps.
Even with all this work, the tests have a high chance of failure just due to being asynchronous.
*/
class AvatarReleaseTest extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "release-test-service")
val zone = new Zone("test", new ZoneMap("test-map"), 0) { override def SetupNumberPools() = { AddPool("dynamic", 1 to 10) } }
val taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "release-test-zone")
zone.Actor ! Zone.Init()
val obj = Player(Avatar("TestCharacter", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
obj.Continent = "test"
obj.Release
"AvatarService" should {
"pass Release" in {
expectNoMsg(100 milliseconds) //spacer
service ! Service.Join("test")
taskResolver ! GUIDTask.RegisterObjectTask(obj)(zone.GUID)
assert(zone.Corpses.isEmpty)
zone.Population ! Zone.Corpse.Add(obj)
expectNoMsg(200 milliseconds) //spacer
assert(zone.Corpses.size == 1)
assert(obj.HasGUID)
val guid = obj.GUID
service ! AvatarServiceMessage("test", AvatarAction.Release(obj, zone, Some(1 second))) //alive for one second
val reply1 = receiveOne(200 milliseconds)
assert(reply1.isInstanceOf[AvatarServiceResponse])
val reply1msg = reply1.asInstanceOf[AvatarServiceResponse]
assert(reply1msg.toChannel == "/test/Avatar")
assert(reply1msg.avatar_guid == guid)
assert(reply1msg.replyMessage.isInstanceOf[AvatarResponse.Release])
assert(reply1msg.replyMessage.asInstanceOf[AvatarResponse.Release].player == obj)
val reply2 = receiveOne(2 seconds)
assert(reply2.isInstanceOf[AvatarServiceResponse])
val reply2msg = reply2.asInstanceOf[AvatarServiceResponse]
assert(reply2msg.toChannel.equals("/test/Avatar"))
assert(reply2msg.avatar_guid == Service.defaultPlayerGUID)
assert(reply2msg.replyMessage.isInstanceOf[AvatarResponse.ObjectDelete])
assert(reply2msg.replyMessage.asInstanceOf[AvatarResponse.ObjectDelete].item_guid == guid)
expectNoMsg(1 seconds)
assert(zone.Corpses.isEmpty)
assert(!obj.HasGUID)
}
}
}
class AvatarReleaseEarly1Test extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "release-test-service")
val zone = new Zone("test", new ZoneMap("test-map"), 0) { override def SetupNumberPools() = { AddPool("dynamic", 1 to 10) } }
val taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "release-test-zone")
zone.Actor ! Zone.Init()
val obj = Player(Avatar("TestCharacter1", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
obj.Continent = "test"
obj.Release
"AvatarService" should {
"pass Release" in {
expectNoMsg(100 milliseconds) //spacer
service ! Service.Join("test")
taskResolver ! GUIDTask.RegisterObjectTask(obj)(zone.GUID)
assert(zone.Corpses.isEmpty)
zone.Population ! Zone.Corpse.Add(obj)
expectNoMsg(200 milliseconds) //spacer
assert(zone.Corpses.size == 1)
assert(obj.HasGUID)
val guid = obj.GUID
service ! AvatarServiceMessage("test", AvatarAction.Release(obj, zone)) //3+ minutes!
val reply1 = receiveOne(200 milliseconds)
assert(reply1.isInstanceOf[AvatarServiceResponse])
val reply1msg = reply1.asInstanceOf[AvatarServiceResponse]
assert(reply1msg.toChannel == "/test/Avatar")
assert(reply1msg.avatar_guid == guid)
assert(reply1msg.replyMessage.isInstanceOf[AvatarResponse.Release])
assert(reply1msg.replyMessage.asInstanceOf[AvatarResponse.Release].player == obj)
service ! AvatarServiceMessage.Corpse(RemoverActor.HurrySpecific(List(obj), zone)) //IMPORTANT: ONE ENTRY
val reply2 = receiveOne(200 milliseconds)
assert(reply2.isInstanceOf[AvatarServiceResponse])
val reply2msg = reply2.asInstanceOf[AvatarServiceResponse]
assert(reply2msg.toChannel.equals("/test/Avatar"))
assert(reply2msg.avatar_guid == Service.defaultPlayerGUID)
assert(reply2msg.replyMessage.isInstanceOf[AvatarResponse.ObjectDelete])
assert(reply2msg.replyMessage.asInstanceOf[AvatarResponse.ObjectDelete].item_guid == guid)
expectNoMsg(1 seconds)
assert(zone.Corpses.isEmpty)
assert(!obj.HasGUID)
}
}
}
class AvatarReleaseEarly2Test extends ActorTest {
ServiceManager.boot(system) ! ServiceManager.Register(RandomPool(1).props(Props[TaskResolver]), "taskResolver")
val service = system.actorOf(Props[AvatarService], "release-test-service")
val zone = new Zone("test", new ZoneMap("test-map"), 0) { override def SetupNumberPools() = { AddPool("dynamic", 1 to 10) } }
val taskResolver = system.actorOf(Props[TaskResolver], "release-test-resolver")
zone.Actor = system.actorOf(Props(classOf[ZoneActor], zone), "release-test-zone")
zone.Actor ! Zone.Init()
val objAlt = Player(Avatar("TestCharacter2", PlanetSideEmpire.NC, CharacterGender.Male, 1, CharacterVoice.Voice1)) //necessary clutter
val obj = Player(Avatar("TestCharacter1", PlanetSideEmpire.VS, CharacterGender.Female, 1, CharacterVoice.Voice1))
obj.Continent = "test"
obj.Release
"AvatarService" should {
"pass Release" in {
expectNoMsg(100 milliseconds) //spacer
service ! Service.Join("test")
taskResolver ! GUIDTask.RegisterObjectTask(obj)(zone.GUID)
assert(zone.Corpses.isEmpty)
zone.Population ! Zone.Corpse.Add(obj)
expectNoMsg(200 milliseconds) //spacer
assert(zone.Corpses.size == 1)
assert(obj.HasGUID)
val guid = obj.GUID
service ! AvatarServiceMessage("test", AvatarAction.Release(obj, zone)) //3+ minutes!
val reply1 = receiveOne(200 milliseconds)
assert(reply1.isInstanceOf[AvatarServiceResponse])
val reply1msg = reply1.asInstanceOf[AvatarServiceResponse]
assert(reply1msg.toChannel == "/test/Avatar")
assert(reply1msg.avatar_guid == guid)
assert(reply1msg.replyMessage.isInstanceOf[AvatarResponse.Release])
assert(reply1msg.replyMessage.asInstanceOf[AvatarResponse.Release].player == obj)
service ! AvatarServiceMessage.Corpse(RemoverActor.HurrySpecific(List(objAlt, obj), zone)) //IMPORTANT: TWO ENTRIES
val reply2 = receiveOne(100 milliseconds)
assert(reply2.isInstanceOf[AvatarServiceResponse])
val reply2msg = reply2.asInstanceOf[AvatarServiceResponse]
assert(reply2msg.toChannel.equals("/test/Avatar"))
assert(reply2msg.avatar_guid == Service.defaultPlayerGUID)
assert(reply2msg.replyMessage.isInstanceOf[AvatarResponse.ObjectDelete])
assert(reply2msg.replyMessage.asInstanceOf[AvatarResponse.ObjectDelete].item_guid == guid)
expectNoMsg(1 seconds)
assert(zone.Corpses.isEmpty)
assert(!obj.HasGUID)
}
}
}
object AvatarServiceTest {
import java.util.concurrent.atomic.AtomicInteger
private val number = new AtomicInteger(1)
def TestName : String = {
s"service${number.getAndIncrement()}"
}
}

118
common/src/test/scala/service/LocalServiceTest.scala Normal file
View file

@ -0,0 +1,118 @@
package service
// Copyright (c) 2017 PSForever
import akka.actor.Props
import base.ActorTest
import net.psforever.objects.serverobject.PlanetSideServerObject
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types.{PlanetSideEmpire, Vector3}
import services.Service
import services.local._
class LocalService1Test extends ActorTest {
"LocalService" should {
"construct" in {
system.actorOf(Props[LocalService], "service")
assert(true)
}
}
}
class LocalService2Test extends ActorTest {
"LocalService" should {
"subscribe" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
assert(true)
}
}
}
class LocalService3Test extends ActorTest {
"LocalService" should {
"subscribe to a specific channel" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! Service.Leave()
assert(true)
}
}
}
class LocalService4Test extends ActorTest {
"LocalService" should {
"subscribe" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! Service.LeaveAll()
assert(true)
}
}
}
class LocalService5Test extends ActorTest {
"LocalService" should {
"pass an unhandled message" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! "hello"
expectNoMsg()
}
}
}
class DoorClosesTest extends ActorTest {
"LocalService" should {
"pass DoorCloses" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.DoorCloses(PlanetSideGUID(10), PlanetSideGUID(40)))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.DoorCloses(PlanetSideGUID(40))))
}
}
}
class HackClearTest extends ActorTest {
val obj = new PlanetSideServerObject() {
def Faction = PlanetSideEmpire.NEUTRAL
def Definition = null
GUID = PlanetSideGUID(40)
}
"LocalService" should {
"pass HackClear" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.HackClear(PlanetSideGUID(10), obj, 0L, 1000L))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.HackClear(PlanetSideGUID(40), 0L, 1000L)))
}
}
}
class ProximityTerminalEffectTest extends ActorTest {
"LocalService" should {
"pass ProximityTerminalEffect" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.ProximityTerminalEffect(PlanetSideGUID(10), PlanetSideGUID(40), true))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.ProximityTerminalEffect(PlanetSideGUID(40), true)))
}
}
}
class TriggerSoundTest extends ActorTest {
import net.psforever.packet.game.TriggeredSound
"LocalService" should {
"pass TriggerSound" in {
val service = system.actorOf(Props[LocalService], "service")
service ! Service.Join("test")
service ! LocalServiceMessage("test", LocalAction.TriggerSound(PlanetSideGUID(10), TriggeredSound.LockedOut, Vector3(1.1f, 2.2f, 3.3f), 0, 0.75f))
expectMsg(LocalServiceResponse("/test/Local", PlanetSideGUID(10), LocalResponse.TriggerSound(TriggeredSound.LockedOut, Vector3(1.1f, 2.2f, 3.3f), 0, 0.75f)))
}
}
}
object LocalServiceTest {
//decoy
}

540
common/src/test/scala/service/RemoverActorTest.scala Normal file
View file

@ -0,0 +1,540 @@
// Copyright (c) 2017 PSForever
package service
import akka.actor.{ActorRef, Props}
import akka.routing.RandomPool
import akka.testkit.TestProbe
import base.ActorTest
import net.psforever.objects.PlanetSideGameObject
import net.psforever.objects.definition.{EquipmentDefinition, ObjectDefinition}
import net.psforever.objects.equipment.Equipment
import net.psforever.objects.guid.TaskResolver
import net.psforever.objects.zones.{Zone, ZoneMap}
import net.psforever.packet.game.PlanetSideGUID
import services.{RemoverActor, ServiceManager}
import scala.concurrent.duration._
class StandardRemoverActorTest extends ActorTest {
ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
"RemoverActor" should {
"handle a simple task" in {
expectNoMsg(500 milliseconds)
val probe = TestProbe()
val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere)
val reply1 = probe.receiveOne(200 milliseconds)
assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
val reply2 = probe.receiveOne(200 milliseconds)
assert(reply2.isInstanceOf[RemoverActorTest.InitialJobAlert])
probe.expectNoMsg(1 seconds) //delay
val reply3 = probe.receiveOne(300 milliseconds)
assert(reply3.isInstanceOf[RemoverActorTest.FirstJobAlert])
val reply4 = probe.receiveOne(300 milliseconds)
assert(reply4.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
val reply5 = probe.receiveOne(300 milliseconds)
assert(reply5.isInstanceOf[RemoverActorTest.SecondJobAlert])
val reply6 = probe.receiveOne(500 milliseconds)
assert(reply6.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
val reply7 = probe.receiveOne(500 milliseconds)
assert(reply7.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
}
}
}
//class DelayedRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
//
// "RemoverActor" should {
// "handle a simple task (timed)" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(100 milliseconds))
//
// val reply1 = probe.receiveOne(200 milliseconds)
// assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
// val reply2 = probe.receiveOne(200 milliseconds)
// assert(reply2.isInstanceOf[RemoverActorTest.InitialJobAlert])
// //no delay
// val reply3 = probe.receiveOne(300 milliseconds)
// assert(reply3.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4 = probe.receiveOne(300 milliseconds)
// assert(reply4.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5 = probe.receiveOne(300 milliseconds)
// assert(reply5.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6 = probe.receiveOne(300 milliseconds)
// assert(reply6.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7 = probe.receiveOne(300 milliseconds)
// assert(reply7.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// }
// }
//}
//
//class ExcludedRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// val AlternateTestObject = new PlanetSideGameObject() { def Definition = new ObjectDefinition(0) { } }
//
// "RemoverActor" should {
// "allow only specific objects" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(AlternateTestObject, Zone.Nowhere)
//
// val reply1 = probe.receiveOne(200 milliseconds)
// assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
// expectNoMsg(2 seconds)
// //RemoverActor is stalled because it received an object that it was not allowed to act upon
// }
// }
//}
//
//class MultipleRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
//
// "RemoverActor" should {
// "work on parallel tasks" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere)
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere)
//
// val replies = probe.receiveN(14, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// var fja : Int = 0
// var cta : Int = 0
// var sja : Int = 0
// var dta : Int = 0
// var dtr : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case RemoverActorTest.FirstJobAlert() => fja += 1
// case RemoverActorTest.ClearanceTestAlert() => cta += 1
// case RemoverActorTest.SecondJobAlert() => sja += 1
// case RemoverActorTest.DeletionTaskAlert() => dta += 1
// case RemoverActorTest.DeletionTaskRunAlert() => dtr += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2 && fja == 2 && cta == 2 && sja == 2 && dta == 2 && dtr == 2)
// }
// }
//}
//
//class HurrySpecificRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
//
// "RemoverActor" should {
// "be able to hurry certain tasks" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(10 minutes)) //TEN MINUTE WAIT
//
// val reply1 = probe.receiveOne(200 milliseconds)
// assert(reply1.isInstanceOf[RemoverActorTest.InclusionTestAlert])
// val reply2 = probe.receiveOne(200 milliseconds)
// assert(reply2.isInstanceOf[RemoverActorTest.InitialJobAlert])
// probe.expectNoMsg(3 seconds) //long delay, longer than standard but not yet 10 minutes
// remover ! RemoverActor.HurrySpecific(List(RemoverActorTest.TestObject), Zone.Nowhere) //hurried
// val reply3 = probe.receiveOne(300 milliseconds)
// assert(reply3.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4 = probe.receiveOne(300 milliseconds)
// assert(reply4.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5 = probe.receiveOne(300 milliseconds)
// assert(reply5.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6 = probe.receiveOne(500 milliseconds)
// assert(reply6.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7 = probe.receiveOne(500 milliseconds)
// assert(reply7.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// }
// }
//}
//
//class HurrySelectionRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
//
// "RemoverActor" should {
// "be able to hurry certain tasks, but let others finish normally" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(10 seconds))
//
// val replies = probe.receiveN(4, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2)
// probe.expectNoMsg(3 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.HurrySpecific(List(RemoverActorTest.TestObject), Zone.Nowhere) //hurried
// //first
// val reply3a = probe.receiveOne(300 milliseconds)
// assert(reply3a.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4a = probe.receiveOne(300 milliseconds)
// assert(reply4a.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5a = probe.receiveOne(300 milliseconds)
// assert(reply5a.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6a = probe.receiveOne(500 milliseconds)
// assert(reply6a.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7a = probe.receiveOne(500 milliseconds)
// assert(reply7a.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// //second
// remover ! RemoverActor.HurrySpecific(List(TestObject2), Zone.Nowhere) //hurried
// val reply3b = probe.receiveOne(300 milliseconds)
// assert(reply3b.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4b = probe.receiveOne(300 milliseconds)
// assert(reply4b.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5b = probe.receiveOne(300 milliseconds)
// assert(reply5b.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6b = probe.receiveOne(500 milliseconds)
// assert(reply6b.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7b = probe.receiveOne(500 milliseconds)
// assert(reply7b.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// }
// }
//}
//
//class HurryMultipleRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
// final val TestObject3 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(3) } }
//
// "RemoverActor" should {
// "be able to hurry certain tasks, but only valid ones" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(5 seconds))
//
// val replies = probe.receiveN(4, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2)
// probe.expectNoMsg(3 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.HurrySpecific(List(RemoverActorTest.TestObject, TestObject3), Zone.Nowhere) //multiple hurried, only one valid
// //first
// val reply3a = probe.receiveOne(300 milliseconds)
// assert(reply3a.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4a = probe.receiveOne(300 milliseconds)
// assert(reply4a.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5a = probe.receiveOne(300 milliseconds)
// assert(reply5a.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6a = probe.receiveOne(500 milliseconds)
// assert(reply6a.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7a = probe.receiveOne(500 milliseconds)
// assert(reply7a.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// //second
// remover ! RemoverActor.HurrySpecific(List(TestObject2), Zone.Nowhere) //hurried
// val reply3b = probe.receiveOne(300 milliseconds)
// assert(reply3b.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4b = probe.receiveOne(300 milliseconds)
// assert(reply4b.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5b = probe.receiveOne(300 milliseconds)
// assert(reply5b.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6b = probe.receiveOne(500 milliseconds)
// assert(reply6b.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7b = probe.receiveOne(500 milliseconds)
// assert(reply7b.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// }
// }
//}
//
//class HurryByZoneRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
// final val TestObject3 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(3) } }
// final val zone = new Zone("test", new ZoneMap("test-map"), 11)
//
// "RemoverActor" should {
// "be able to hurry certain tasks by their zone" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, zone, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject3, Zone.Nowhere, Some(5 seconds))
//
// val replies1 = probe.receiveN(6, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies1.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 3 && ija == 3)
// probe.expectNoMsg(3 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.HurrySpecific(List(), Zone.Nowhere) //multiple hurried, only the two entries with Zone.Nowhere
// //
// val replies2 = probe.receiveN(10, 5 seconds)
// var fja : Int = 0
// var cta : Int = 0
// var sja : Int = 0
// var dta : Int = 0
// var dtr : Int = 0
// replies2.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case RemoverActorTest.FirstJobAlert() => fja += 1
// case RemoverActorTest.ClearanceTestAlert() => cta += 1
// case RemoverActorTest.SecondJobAlert() => sja += 1
// case RemoverActorTest.DeletionTaskAlert() => dta += 1
// case RemoverActorTest.DeletionTaskRunAlert() => dtr += 1
// case msg => assert(false, s"$msg")
// }
// assert(fja == 2 && cta == 2 && sja == 2 && dta == 2 && dtr == 2)
// //final
// remover ! RemoverActor.HurrySpecific(List(), zone) //hurried
// val reply3b = probe.receiveOne(300 milliseconds)
// assert(reply3b.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4b = probe.receiveOne(300 milliseconds)
// assert(reply4b.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5b = probe.receiveOne(300 milliseconds)
// assert(reply5b.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6b = probe.receiveOne(500 milliseconds)
// assert(reply6b.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7b = probe.receiveOne(500 milliseconds)
// assert(reply7b.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// }
// }
//}
//
//class HurryAllRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
// final val TestObject3 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(3) } }
//
// "RemoverActor" should {
// "be able to hurry all tasks to completion" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(20 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(15 seconds))
// remover ! RemoverActor.AddTask(TestObject3, Zone.Nowhere, Some(10 seconds))
//
// val replies1 = probe.receiveN(6, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies1.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 3 && ija == 3)
// probe.expectNoMsg(3 seconds) //long delay, longer than standard but not yet longer than any of the tasks
// remover ! RemoverActor.HurryAll() //all hurried
// //
// val replies2 = probe.receiveN(15, 5 seconds)
// var fja : Int = 0
// var cta : Int = 0
// var sja : Int = 0
// var dta : Int = 0
// var dtr : Int = 0
// replies2.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case RemoverActorTest.FirstJobAlert() => fja += 1
// case RemoverActorTest.ClearanceTestAlert() => cta += 1
// case RemoverActorTest.SecondJobAlert() => sja += 1
// case RemoverActorTest.DeletionTaskAlert() => dta += 1
// case RemoverActorTest.DeletionTaskRunAlert() => dtr += 1
// case msg => assert(false, s"$msg")
// }
// assert(fja == 3 && cta == 3 && sja == 3 && dta == 3 && dtr == 3)
// }
// }
//}
//
//class ClearSelectionRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
//
// "RemoverActor" should {
// "be able to clear certain tasks" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(5 seconds))
//
// val replies = probe.receiveN(4, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2)
// probe.expectNoMsg(4 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.ClearSpecific(List(RemoverActorTest.TestObject), Zone.Nowhere) //cleared
// //
// val reply3 = probe.receiveOne(2 seconds)
// assert(reply3.isInstanceOf[RemoverActorTest.FirstJobAlert])
// val reply4 = probe.receiveOne(300 milliseconds)
// assert(reply4.isInstanceOf[RemoverActorTest.ClearanceTestAlert])
// val reply5 = probe.receiveOne(300 milliseconds)
// assert(reply5.isInstanceOf[RemoverActorTest.SecondJobAlert])
// val reply6 = probe.receiveOne(500 milliseconds)
// assert(reply6.isInstanceOf[RemoverActorTest.DeletionTaskAlert])
// val reply7 = probe.receiveOne(500 milliseconds)
// assert(reply7.isInstanceOf[RemoverActorTest.DeletionTaskRunAlert])
// //wait
// probe.expectNoMsg(2 seconds) //nothing more to do
// }
// }
//}
//
//class ClearAllRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
//
// "RemoverActor" should {
// "be able to clear all tasks, with no more work on them" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(5 seconds))
//
// val replies = probe.receiveN(4, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2)
// probe.expectNoMsg(4 seconds) //long delay, longer than standard but not yet 5 seconds
// remover ! RemoverActor.ClearAll() //cleared
// //wait
// probe.expectNoMsg(3 seconds) //nothing more to do
// }
// }
//}
//
//class EarlyDeathRemoverActorTest extends ActorTest {
// ServiceManager.boot ! ServiceManager.Register(RandomPool(2).props(Props[TaskResolver]), "taskResolver")
// final val TestObject2 = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(2) } }
//
// "RemoverActor" should {
// "be able to hurry certain tasks" in {
// expectNoMsg(500 milliseconds)
// val probe = TestProbe()
// val remover = system.actorOf(Props(classOf[RemoverActorTest.TestRemover], probe), "test-remover")
// remover ! RemoverActor.AddTask(RemoverActorTest.TestObject, Zone.Nowhere, Some(5 seconds))
// remover ! RemoverActor.AddTask(TestObject2, Zone.Nowhere, Some(5 seconds))
//
// val replies = probe.receiveN(4, 5 seconds)
// var ita : Int = 0
// var ija : Int = 0
// replies.collect {
// case RemoverActorTest.InclusionTestAlert() => ita += 1
// case RemoverActorTest.InitialJobAlert() => ija += 1
// case msg => assert(false, s"$msg")
// }
// assert(ita == 2 && ija == 2)
// probe.expectNoMsg(2 seconds)
// remover ! akka.actor.PoisonPill
// //
// val replies2 = probe.receiveN(8, 5 seconds)
// var fja : Int = 0
// var cta : Int = 0
// var sja : Int = 0
// var dta : Int = 0
// var dtr : Int = 0
// replies2.collect {
// case RemoverActorTest.FirstJobAlert() => fja += 1
// case RemoverActorTest.ClearanceTestAlert() => cta += 1
// case RemoverActorTest.SecondJobAlert() => sja += 1
// case RemoverActorTest.DeletionTaskAlert() => dta += 1
// case RemoverActorTest.DeletionTaskRunAlert() => dtr += 1
// case msg => assert(false, s"$msg")
// }
// assert(fja == 2 && cta == 0 && sja == 2 && dta == 2 && dtr == 2) //no clearance tests
// }
// }
//}
object RemoverActorTest {
final val TestObject = new Equipment() { def Definition = new EquipmentDefinition(0) { GUID = PlanetSideGUID(1) } }
final case class InclusionTestAlert()
final case class InitialJobAlert()
final case class FirstJobAlert()
final case class SecondJobAlert()
final case class ClearanceTestAlert()
final case class DeletionTaskAlert()
final case class DeletionTaskRunAlert()
class TestRemover(probe : TestProbe) extends RemoverActor {
import net.psforever.objects.guid.{Task, TaskResolver}
val FirstStandardDuration = 1 seconds
val SecondStandardDuration = 100 milliseconds
def InclusionTest(entry : RemoverActor.Entry) : Boolean = {
probe.ref ! InclusionTestAlert()
entry.obj.isInstanceOf[Equipment]
}
def InitialJob(entry : RemoverActor.Entry) : Unit = {
probe.ref ! InitialJobAlert()
}
def FirstJob(entry : RemoverActor.Entry) : Unit = {
probe.ref ! FirstJobAlert()
}
override def SecondJob(entry : RemoverActor.Entry) : Unit = {
probe.ref ! SecondJobAlert()
super.SecondJob(entry)
}
def ClearanceTest(entry : RemoverActor.Entry) : Boolean = {
probe.ref ! ClearanceTestAlert()
true
}
def DeletionTask(entry : RemoverActor.Entry) : TaskResolver.GiveTask = {
probe.ref ! DeletionTaskAlert()
TaskResolver.GiveTask(new Task() {
private val localProbe = probe
override def isComplete = Task.Resolution.Success
def Execute(resolver : ActorRef) : Unit = {
localProbe.ref ! DeletionTaskRunAlert()
resolver ! scala.util.Success(this)
}
})
}
}
}

258
common/src/test/scala/service/VehicleServiceTest.scala Normal file
View file

@ -0,0 +1,258 @@
// Copyright (c) 2017 PSForever
package service
import akka.actor.Props
import base.ActorTest
import net.psforever.objects._
import net.psforever.packet.game.PlanetSideGUID
import net.psforever.types._
import services.{Service, ServiceManager}
import services.vehicle._
class VehicleService1Test extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"construct" in {
system.actorOf(Props[VehicleService], "v-service")
assert(true)
}
}
}
class VehicleService2Test extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"subscribe" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
assert(true)
}
}
}
class VehicleService3Test extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"subscribe to a specific channel" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! Service.Leave()
assert(true)
}
}
}
class VehicleService4Test extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"subscribe" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! Service.LeaveAll()
assert(true)
}
}
}
class VehicleService5Test extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass an unhandled message" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! "hello"
expectNoMsg()
}
}
}
class OwnershipTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass Awareness" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.Ownership(PlanetSideGUID(10), PlanetSideGUID(11)))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.Ownership(PlanetSideGUID(11))))
}
}
}
class ChildObjectStateTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass ChildObjectState" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.ChildObjectState(PlanetSideGUID(10), PlanetSideGUID(11), 1.2f, 3.4f))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.ChildObjectState(PlanetSideGUID(11), 1.2f, 3.4f)))
}
}
}
class DeployRequestTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass DeployRequest" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.DeployRequest(PlanetSideGUID(10), PlanetSideGUID(11), DriveState.Mobile, 0, false, Vector3(1.2f, 3.4f, 5.6f)))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.DeployRequest(PlanetSideGUID(11), DriveState.Mobile, 0, false, Vector3(1.2f, 3.4f, 5.6f))))
}
}
}
class DismountVehicleTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass DismountVehicle" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.DismountVehicle(PlanetSideGUID(10), BailType.Normal, false))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.DismountVehicle(BailType.Normal, false)))
}
}
}
class InventoryStateTest extends ActorTest {
ServiceManager.boot(system)
val tool = Tool(GlobalDefinitions.beamer)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(13)
val cdata = tool.Definition.Packet.ConstructorData(tool).get
"VehicleService" should {
"pass InventoryState" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.InventoryState(PlanetSideGUID(10), tool, PlanetSideGUID(11), 0, cdata))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.InventoryState(tool, PlanetSideGUID(11), 0, cdata)))
}
}
}
class InventoryState2Test extends ActorTest {
ServiceManager.boot(system)
val tool = Tool(GlobalDefinitions.beamer)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(13)
val cdata = tool.Definition.Packet.ConstructorData(tool).get
"VehicleService" should {
"pass InventoryState2" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.InventoryState2(PlanetSideGUID(10), PlanetSideGUID(11), PlanetSideGUID(12), 13))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.InventoryState2(PlanetSideGUID(11), PlanetSideGUID(12), 13)))
}
}
}
class KickPassengerTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass KickPassenger" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.KickPassenger(PlanetSideGUID(10), 0, false, PlanetSideGUID(11)))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.KickPassenger(0, false, PlanetSideGUID(11))))
}
}
}
class LoadVehicleTest extends ActorTest {
ServiceManager.boot(system)
val vehicle = Vehicle(GlobalDefinitions.quadstealth)
val cdata = vehicle.Definition.Packet.ConstructorData(vehicle).get
"VehicleService" should {
"pass LoadVehicle" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.LoadVehicle(PlanetSideGUID(10), vehicle, 12, PlanetSideGUID(11), cdata))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.LoadVehicle(vehicle, 12, PlanetSideGUID(11), cdata)))
}
}
}
class MountVehicleTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass MountVehicle" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.MountVehicle(PlanetSideGUID(10), PlanetSideGUID(11), 0))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.MountVehicle(PlanetSideGUID(11), 0)))
}
}
}
class SeatPermissionsTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass SeatPermissions" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.SeatPermissions(PlanetSideGUID(10), PlanetSideGUID(11), 0, 12L))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.SeatPermissions(PlanetSideGUID(11), 0, 12L)))
}
}
}
class StowEquipmentTest extends ActorTest {
ServiceManager.boot(system)
val tool = Tool(GlobalDefinitions.beamer)
tool.GUID = PlanetSideGUID(12)
tool.AmmoSlots.head.Box.GUID = PlanetSideGUID(13)
val toolDef = tool.Definition
val cdata = tool.Definition.Packet.DetailedConstructorData(tool).get
"StowEquipment" should {
"pass StowEquipment" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.StowEquipment(PlanetSideGUID(10), PlanetSideGUID(11), 0, tool))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.StowEquipment(PlanetSideGUID(11), 0, toolDef.ObjectId, tool.GUID, cdata)))
}
}
}
class UnstowEquipmentTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass UnstowEquipment" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.UnstowEquipment(PlanetSideGUID(10), PlanetSideGUID(11)))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.UnstowEquipment(PlanetSideGUID(11))))
}
}
}
class VehicleStateTest extends ActorTest {
ServiceManager.boot(system)
"VehicleService" should {
"pass VehicleState" in {
val service = system.actorOf(Props[VehicleService], "v-service")
service ! Service.Join("test")
service ! VehicleServiceMessage("test", VehicleAction.VehicleState(PlanetSideGUID(10), PlanetSideGUID(11), 0, Vector3(1.2f, 3.4f, 5.6f), Vector3(7.8f, 9.1f, 2.3f), Some(Vector3(4.5f, 6.7f, 8.9f)), Option(1), 2, 3, 4, false, true))
expectMsg(VehicleServiceResponse("/test/Vehicle", PlanetSideGUID(10), VehicleResponse.VehicleState(PlanetSideGUID(11), 0, Vector3(1.2f, 3.4f, 5.6f), Vector3(7.8f, 9.1f, 2.3f), Some(Vector3(4.5f, 6.7f, 8.9f)), Option(1), 2, 3, 4, false, true)))
}
}
}
object VehicleServiceTest {
//decoy
}