diff --git a/common/src/main/scala/net/psforever/objects/GlobalDefinitions.scala b/common/src/main/scala/net/psforever/objects/GlobalDefinitions.scala index 917fc452..dba9b469 100644 --- a/common/src/main/scala/net/psforever/objects/GlobalDefinitions.scala +++ b/common/src/main/scala/net/psforever/objects/GlobalDefinitions.scala @@ -1251,7 +1251,7 @@ object GlobalDefinitions { fury.Seats += 0 -> new SeatDefinition() fury.Seats(0).Bailable = true fury.Seats(0).ControlledWeapon = 1 - fury.MountPoints += 0 -> 0 + fury.MountPoints += 1 -> 0 fury.MountPoints += 2 -> 0 fury.Weapons += 1 -> fury_weapon_systema fury.TrunkSize = InventoryTile(11, 11) @@ -1262,7 +1262,7 @@ object GlobalDefinitions { quadassault.Seats += 0 -> new SeatDefinition() quadassault.Seats(0).Bailable = true quadassault.Seats(0).ControlledWeapon = 1 - quadassault.MountPoints += 0 -> 0 + quadassault.MountPoints += 1 -> 0 quadassault.MountPoints += 2 -> 0 quadassault.Weapons += 1 -> quadassault_weapon_system quadassault.TrunkSize = InventoryTile(11, 11) @@ -1273,7 +1273,7 @@ object GlobalDefinitions { quadstealth.CanCloak = true quadstealth.Seats += 0 -> new SeatDefinition() quadstealth.Seats(0).Bailable = true - quadstealth.MountPoints += 0 -> 0 + quadstealth.MountPoints += 1 -> 0 quadstealth.MountPoints += 2 -> 0 quadstealth.CanCloak = true quadstealth.TrunkSize = InventoryTile(11, 11) diff --git a/common/src/main/scala/net/psforever/objects/Vehicle.scala b/common/src/main/scala/net/psforever/objects/Vehicle.scala index ab1608b2..19f0101d 100644 --- a/common/src/main/scala/net/psforever/objects/Vehicle.scala +++ b/common/src/main/scala/net/psforever/objects/Vehicle.scala @@ -71,10 +71,14 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ this.owner } + def Owner_=(owner : PlanetSideGUID) : Option[PlanetSideGUID] = Owner_=(Some(owner)) + + def Owner_=(owner : Player) : Option[PlanetSideGUID] = Owner_=(Some(owner.GUID)) + def Owner_=(owner : Option[PlanetSideGUID]) : Option[PlanetSideGUID] = { owner match { case Some(_) => - if(Definition.CanBeOwned) { + if(Definition.CanBeOwned) { //e.g., base turrets this.owner = owner } case None => @@ -102,7 +106,7 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ def Shields_=(strength : Int) : Int = { this.shields = strength - strength + Shields } def MaxShields : Int = { @@ -252,12 +256,11 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ * @return a weapon, or `None` */ def ControlledWeapon(wepNumber : Int) : Option[Equipment] = { - val slot = this.weapons.get(wepNumber) - if(slot.isDefined) { - slot.get.Equipment - } - else { - None + weapons.get(wepNumber) match { + case Some(mount) => + mount.Equipment + case None => + None } } @@ -284,11 +287,11 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ } /** - * Given a valid seat number, retrieve an index where a weapon controlled from this seat is attached. + * 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[Tool] = { + def WeaponControlledFromSeat(seatNumber : Int) : Option[Equipment] = { Seat(seatNumber) match { case Some(seat) => wepFromSeat(seat) @@ -297,7 +300,7 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ } } - private def wepFromSeat(seat : Seat) : Option[Tool] = { + private def wepFromSeat(seat : Seat) : Option[Equipment] = { seat.ControlledWeapon match { case Some(index) => wepFromSeat(index) @@ -306,10 +309,10 @@ class Vehicle(private val vehicleDef : VehicleDefinition) extends PlanetSideServ } } - private def wepFromSeat(wepIndex : Int) : Option[Tool] = { + private def wepFromSeat(wepIndex : Int) : Option[Equipment] = { weapons.get(wepIndex) match { case Some(wep) => - wep.Equipment.asInstanceOf[Option[Tool]] + wep.Equipment case None => None } diff --git a/pslogin/src/main/scala/scripts/GUIDTask.scala b/common/src/main/scala/net/psforever/objects/guid/GUIDTask.scala similarity index 99% rename from pslogin/src/main/scala/scripts/GUIDTask.scala rename to common/src/main/scala/net/psforever/objects/guid/GUIDTask.scala index 0d04585b..7425322b 100644 --- a/pslogin/src/main/scala/scripts/GUIDTask.scala +++ b/common/src/main/scala/net/psforever/objects/guid/GUIDTask.scala @@ -1,5 +1,5 @@ // Copyright (c) 2017 PSForever -package scripts +package net.psforever.objects.guid /** * The basic compiled tasks for assigning (registering) and revoking (unregistering) globally unique identifiers.
@@ -20,7 +20,6 @@ object GUIDTask { import akka.actor.ActorRef import net.psforever.objects.entity.IdentifiableEntity import net.psforever.objects.equipment.Equipment - import net.psforever.objects.guid.{Task, TaskResolver} import net.psforever.objects.{EquipmentSlot, Player, Tool, Vehicle} import scala.annotation.tailrec @@ -279,4 +278,4 @@ object GUIDTask { } } } -} \ No newline at end of file +} diff --git a/common/src/main/scala/net/psforever/objects/guid/pool/ExclusivePool.scala b/common/src/main/scala/net/psforever/objects/guid/pool/ExclusivePool.scala index 93081c54..87f1050d 100644 --- a/common/src/main/scala/net/psforever/objects/guid/pool/ExclusivePool.scala +++ b/common/src/main/scala/net/psforever/objects/guid/pool/ExclusivePool.scala @@ -5,7 +5,7 @@ import net.psforever.objects.guid.selector.NumberSelector import scala.util.{Failure, Success, Try} -class ExclusivePool(numbers : List[Int]) extends SimplePool(numbers) { +class ExclusivePool(override val numbers : List[Int]) extends SimplePool(numbers) { private val pool : Array[Int] = Array.ofDim[Int](numbers.length) numbers.indices.foreach(i => { pool(i) = i }) diff --git a/common/src/main/scala/net/psforever/objects/guid/pool/SimplePool.scala b/common/src/main/scala/net/psforever/objects/guid/pool/SimplePool.scala index 1b30ed4a..fa2f1fb7 100644 --- a/common/src/main/scala/net/psforever/objects/guid/pool/SimplePool.scala +++ b/common/src/main/scala/net/psforever/objects/guid/pool/SimplePool.scala @@ -5,7 +5,7 @@ import net.psforever.objects.guid.selector.{NumberSelector, StrictInOrderSelecto import scala.util.{Success, Try} -class SimplePool(private val numbers : List[Int]) extends NumberPool { +class SimplePool(val numbers : List[Int]) extends NumberPool { if(numbers.count(_ < 0) > 0) { throw new IllegalArgumentException("negative numbers not allowed in number pool") } diff --git a/common/src/main/scala/net/psforever/objects/inventory/AccessibleInventory.scala b/common/src/main/scala/net/psforever/objects/inventory/AccessibleInventory.scala deleted file mode 100644 index d0d5e15e..00000000 --- a/common/src/main/scala/net/psforever/objects/inventory/AccessibleInventory.scala +++ /dev/null @@ -1,13 +0,0 @@ -// Copyright (c) 2017 PSForever -package net.psforever.objects.inventory - -import net.psforever.objects.Player -import net.psforever.packet.game.PlanetSideGUID - -trait AccessibleInventory { - def Inventory : GridInventory - - def CanAccess(who : Player) : Boolean - def Access(who : PlanetSideGUID) : Boolean - def Unaccess : Boolean -} \ No newline at end of file diff --git a/common/src/main/scala/net/psforever/objects/serverobject/doors/Door.scala b/common/src/main/scala/net/psforever/objects/serverobject/doors/Door.scala index ae63affd..6ba5abc5 100644 --- a/common/src/main/scala/net/psforever/objects/serverobject/doors/Door.scala +++ b/common/src/main/scala/net/psforever/objects/serverobject/doors/Door.scala @@ -11,7 +11,6 @@ import net.psforever.packet.game.UseItemMessage */ class Door(private val ddef : DoorDefinition) extends PlanetSideServerObject { private var openState : Boolean = false - private var lockState : Boolean = false def Open : Boolean = openState @@ -20,25 +19,15 @@ class Door(private val ddef : DoorDefinition) extends PlanetSideServerObject { Open } - def Locked : Boolean = lockState - - def Locked_=(lock : Boolean) : Boolean = { - lockState = lock - Locked - } - def Use(player : Player, msg : UseItemMessage) : Door.Exchange = { - if(!lockState && !openState) { + if(!openState) { openState = true Door.OpenEvent() } - else if(openState) { + else { openState = false Door.CloseEvent() } - else { - Door.NoEvent() - } } def Definition : DoorDefinition = ddef diff --git a/common/src/main/scala/net/psforever/objects/serverobject/terminals/Terminal.scala b/common/src/main/scala/net/psforever/objects/serverobject/terminals/Terminal.scala index 57532c54..c6cba9f0 100644 --- a/common/src/main/scala/net/psforever/objects/serverobject/terminals/Terminal.scala +++ b/common/src/main/scala/net/psforever/objects/serverobject/terminals/Terminal.scala @@ -13,9 +13,7 @@ import net.psforever.types.{ExoSuitType, TransactionType, Vector3} * @param tdef the `ObjectDefinition` that constructs this object and maintains some of its immutable fields */ class Terminal(tdef : TerminalDefinition) extends PlanetSideServerObject { - /** - * An entry that maintains a reference to the `Player`, and the player's GUID and location when the message was received. - */ + /** An entry that maintains a reference to the `Player`, and the player's GUID and location when the message was received. */ private var hackedBy : Option[(Player, PlanetSideGUID, Vector3)] = None def HackedBy : Option[(Player, PlanetSideGUID, Vector3)] = hackedBy diff --git a/common/src/main/scala/net/psforever/objects/vehicles/AccessPermissionGroup.scala b/common/src/main/scala/net/psforever/objects/vehicles/AccessPermissionGroup.scala index 5a99956e..70165977 100644 --- a/common/src/main/scala/net/psforever/objects/vehicles/AccessPermissionGroup.scala +++ b/common/src/main/scala/net/psforever/objects/vehicles/AccessPermissionGroup.scala @@ -19,4 +19,4 @@ object AccessPermissionGroup extends Enumeration { Passenger, Trunk = Value -} \ No newline at end of file +} diff --git a/common/src/main/scala/net/psforever/objects/zones/Zone.scala b/common/src/main/scala/net/psforever/objects/zones/Zone.scala index 7bf7d22c..dbd2501d 100644 --- a/common/src/main/scala/net/psforever/objects/zones/Zone.scala +++ b/common/src/main/scala/net/psforever/objects/zones/Zone.scala @@ -136,11 +136,14 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) { * The replacement will not occur if the current system is populated or if its synchronized reference has been created. * @return synchronized reference to the globally unique identifier system */ - def GUID(hub : NumberPoolHub) : ActorRef = { + def GUID(hub : NumberPoolHub) : Boolean = { if(actor == ActorRef.noSender && guid.Pools.map({case ((_, pool)) => pool.Count}).sum == 0) { guid = hub + true + } + else { + false } - Actor } /** @@ -215,7 +218,7 @@ class Zone(private val zoneId : String, zoneMap : ZoneMap, zoneNumber : Int) { def Transport : ActorRef = transport def MakeBases(num : Int) : List[Base] = { - bases = (0 to num).map(id => new Base(id)).toList + bases = (1 to num).map(id => new Base(id)).toList bases } diff --git a/common/src/main/scala/net/psforever/objects/zones/ZoneMap.scala b/common/src/main/scala/net/psforever/objects/zones/ZoneMap.scala index 96cc0928..dbec207c 100644 --- a/common/src/main/scala/net/psforever/objects/zones/ZoneMap.scala +++ b/common/src/main/scala/net/psforever/objects/zones/ZoneMap.scala @@ -50,7 +50,9 @@ class ZoneMap(private val name : String) { def LocalBases : Int = numBases def LocalBases_=(num : Int) : Int = { - numBases = math.max(0, num) + if(num > 0) { + numBases = num + } LocalBases } diff --git a/common/src/test/scala/objects/ActorTest.scala b/common/src/test/scala/objects/ActorTest.scala index 5b08b920..cdb7ca00 100644 --- a/common/src/test/scala/objects/ActorTest.scala +++ b/common/src/test/scala/objects/ActorTest.scala @@ -6,7 +6,7 @@ import akka.testkit.{ImplicitSender, TestKit} import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike} import org.specs2.specification.Scope -abstract class ActorTest(sys : ActorSystem) extends TestKit(sys) with Scope with ImplicitSender with WordSpecLike with Matchers with BeforeAndAfterAll { +abstract class ActorTest(sys : ActorSystem = ActorSystem("system")) extends TestKit(sys) with Scope with ImplicitSender with WordSpecLike with Matchers with BeforeAndAfterAll { override def afterAll { TestKit.shutdownActorSystem(system) } diff --git a/common/src/test/scala/objects/ConverterTest.scala b/common/src/test/scala/objects/ConverterTest.scala index 3b946fba..90e92a44 100644 --- a/common/src/test/scala/objects/ConverterTest.scala +++ b/common/src/test/scala/objects/ConverterTest.scala @@ -287,7 +287,7 @@ class ConverterTest extends Specification { fury.Position = Vector3(3674.8438f, 2732f, 91.15625f) fury.Orientation = Vector3(0.0f, 0.0f, 90.0f) fury.WeaponControlledFromSeat(0).get.GUID = PlanetSideGUID(400) - fury.WeaponControlledFromSeat(0).get.AmmoSlots.head.Box = hellfire_ammo_box + fury.WeaponControlledFromSeat(0).get.asInstanceOf[Tool].AmmoSlots.head.Box = hellfire_ammo_box fury.Definition.Packet.ConstructorData(fury).isSuccess mustEqual true ok //TODO write more of this test diff --git a/common/src/test/scala/objects/DoorTest.scala b/common/src/test/scala/objects/DoorTest.scala new file mode 100644 index 00000000..d969e229 --- /dev/null +++ b/common/src/test/scala/objects/DoorTest.scala @@ -0,0 +1,91 @@ +// Copyright (c) 2017 PSForever +package objects + +import akka.actor.{ActorRef, Props} +import net.psforever.objects.{GlobalDefinitions, Player} +import net.psforever.objects.serverobject.doors.{Door, DoorControl} +import net.psforever.packet.game.{PlanetSideGUID, UseItemMessage} +import net.psforever.types.{CharacterGender, PlanetSideEmpire, Vector3} +import org.specs2.mutable.Specification + +import scala.concurrent.duration.Duration + +class DoorTest extends Specification { + "Door" should { + "construct" in { + Door(GlobalDefinitions.door) + ok + } + + "starts as closed (false)" in { + val door = Door(GlobalDefinitions.door) + door.Open mustEqual false + } + + "can be opened and closed (1; manual)" in { + val door = Door(GlobalDefinitions.door) + door.Open mustEqual false + door.Open = true + door.Open mustEqual true + door.Open = false + door.Open mustEqual false + } + + "can beopened and closed (2; toggle)" in { + val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + 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 door = Door(GlobalDefinitions.door) + door.Open mustEqual false + door.Use(player, msg) + door.Open mustEqual true + door.Use(player, msg) + door.Open mustEqual false + } + } +} + +class DoorControl1Test extends ActorTest() { + "DoorControl" should { + "construct" in { + val door = Door(GlobalDefinitions.door) + door.Actor = system.actorOf(Props(classOf[DoorControl], door), "door") + assert(door.Actor != ActorRef.noSender) + } + } +} + +class DoorControl2Test extends ActorTest() { + "DoorControl" should { + "open on use" in { + val door = Door(GlobalDefinitions.door) + door.Actor = system.actorOf(Props(classOf[DoorControl], door), "door") + val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + val msg = UseItemMessage(PlanetSideGUID(1), 0, PlanetSideGUID(2), 0L, false, Vector3(0f,0f,0f),Vector3(0f,0f,0f),0,0,0,0L) //faked + assert(!door.Open) + + door.Actor ! Door.Use(player, msg) + val reply = receiveOne(Duration.create(500, "ms")) + assert(reply.isInstanceOf[Door.DoorMessage]) + val reply2 = reply.asInstanceOf[Door.DoorMessage] + assert(reply2.player == player) + assert(reply2.msg == msg) + assert(reply2.response == Door.OpenEvent()) + assert(door.Open) + } + } +} + +class DoorControl3Test extends ActorTest() { + "DoorControl" should { + "do nothing if given garbage" in { + val door = Door(GlobalDefinitions.door) + door.Actor = system.actorOf(Props(classOf[DoorControl], door), "door") + assert(!door.Open) + + door.Actor ! "trash" + val reply = receiveOne(Duration.create(500, "ms")) + assert(reply.isInstanceOf[Door.NoEvent]) + assert(!door.Open) + } + } +} diff --git a/common/src/test/scala/objects/GUIDTaskTest.scala b/common/src/test/scala/objects/GUIDTaskTest.scala new file mode 100644 index 00000000..1ea187de --- /dev/null +++ b/common/src/test/scala/objects/GUIDTaskTest.scala @@ -0,0 +1,245 @@ +// Copyright (c) 2017 PSForever +package objects + +import java.util.logging.LogManager + +import akka.actor.{ActorRef, ActorSystem, Props} +import akka.testkit.TestProbe +import net.psforever.objects._ +import net.psforever.objects.entity.IdentifiableEntity +import net.psforever.objects.guid.actor.{NumberPoolActor, UniqueNumberSystem} +import net.psforever.objects.guid.selector.RandomSelector +import net.psforever.objects.guid.source.LimitedNumberSource +import net.psforever.objects.guid.{GUIDTask, NumberPoolHub, Task, TaskResolver} +import net.psforever.types.{CharacterGender, PlanetSideEmpire} + +class GUIDTaskRegister1Test extends ActorTest() { + "RegisterObjectTask" in { + val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup + val obj = new GUIDTaskTest.TestObject + + assert(!obj.HasGUID) + taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.RegisterObjectTask(obj)(uns))) + probe.expectMsg(scala.util.Success) + assert(obj.HasGUID) + } +} + +class GUIDTaskRegister2Test extends ActorTest() { + "RegisterEquipment -> RegisterObjectTask" in { + val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup + val obj = AmmoBox(GlobalDefinitions.energy_cell) + + assert(!obj.HasGUID) + taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.RegisterEquipment(obj)(uns))) + probe.expectMsg(scala.util.Success) + assert(obj.HasGUID) + } +} + +class GUIDTaskRegister3Test extends ActorTest() { + "RegisterEquipment -> RegisterTool" in { + val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup + val obj = Tool(GlobalDefinitions.beamer) + obj.AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.energy_cell) + + assert(!obj.HasGUID) + assert(!obj.AmmoSlots.head.Box.HasGUID) + taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.RegisterEquipment(obj)(uns))) + probe.expectMsg(scala.util.Success) + assert(obj.HasGUID) + assert(obj.AmmoSlots.head.Box.HasGUID) + } +} + +class GUIDTaskRegister4Test extends ActorTest() { + "RegisterVehicle" in { + val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup + val obj = Vehicle(GlobalDefinitions.fury) + val obj_wep = obj.WeaponControlledFromSeat(0).get + val obj_wep_ammo = (obj.WeaponControlledFromSeat(0).get.asInstanceOf[Tool].AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.hellfire_ammo)).get + obj.Trunk += 30 -> AmmoBox(GlobalDefinitions.hellfire_ammo) + val obj_trunk_ammo = obj.Trunk.Items(0).obj + + assert(!obj.HasGUID) + assert(!obj_wep.HasGUID) + assert(!obj_wep_ammo.HasGUID) + assert(!obj_trunk_ammo.HasGUID) + taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.RegisterVehicle(obj)(uns))) + probe.expectMsg(scala.util.Success) + assert(obj.HasGUID) + assert(obj_wep.HasGUID) + assert(obj_wep_ammo.HasGUID) + assert(obj_trunk_ammo.HasGUID) + } +} + +class GUIDTaskRegister5Test extends ActorTest() { + "RegisterAvatar" in { + val (_, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup + val obj = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + val obj_wep = Tool(GlobalDefinitions.beamer) + obj.Slot(0).Equipment = obj_wep + val obj_wep_ammo = AmmoBox(GlobalDefinitions.energy_cell) + obj_wep.AmmoSlots.head.Box = obj_wep_ammo + val obj_inv_ammo = AmmoBox(GlobalDefinitions.energy_cell) + obj.Slot(6).Equipment = obj_inv_ammo + val obj_locker = obj.Slot(5).Equipment.get + val obj_locker_ammo = AmmoBox(GlobalDefinitions.energy_cell) + obj_locker.asInstanceOf[LockerContainer].Inventory += 0 -> obj_locker_ammo + + assert(!obj.HasGUID) + assert(!obj_wep.HasGUID) + assert(!obj_wep_ammo.HasGUID) + assert(!obj_inv_ammo.HasGUID) + assert(!obj_locker.HasGUID) + assert(!obj_locker_ammo.HasGUID) + taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.RegisterAvatar(obj)(uns))) + probe.expectMsg(scala.util.Success) + assert(obj.HasGUID) + assert(obj_wep.HasGUID) + assert(obj_wep_ammo.HasGUID) + assert(obj_inv_ammo.HasGUID) + assert(obj_locker.HasGUID) + assert(obj_locker_ammo.HasGUID) + } +} + +class GUIDTaskUnregister1Test extends ActorTest() { + "UnregisterObjectTask" in { + val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup + val obj = new GUIDTaskTest.TestObject + guid.register(obj, "dynamic") + + assert(obj.HasGUID) + taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.UnregisterObjectTask(obj)(uns))) + probe.expectMsg(scala.util.Success) + assert(!obj.HasGUID) + } +} + +class GUIDTaskUnregister2Test extends ActorTest() { + "UnregisterEquipment -> UnregisterObjectTask" in { + val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup + val obj = AmmoBox(GlobalDefinitions.energy_cell) + guid.register(obj, "dynamic") + + assert(obj.HasGUID) + taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.UnregisterEquipment(obj)(uns))) + probe.expectMsg(scala.util.Success) + assert(!obj.HasGUID) + } +} + +class GUIDTaskUnregister3Test extends ActorTest() { + "UnregisterEquipment -> UnregisterTool" in { + val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup + val obj = Tool(GlobalDefinitions.beamer) + obj.AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.energy_cell) + guid.register(obj, "dynamic") + guid.register(obj.AmmoSlots.head.Box, "dynamic") + + assert(obj.HasGUID) + assert(obj.AmmoSlots.head.Box.HasGUID) + taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.UnregisterEquipment(obj)(uns))) + probe.expectMsg(scala.util.Success) + assert(!obj.HasGUID) + assert(!obj.AmmoSlots.head.Box.HasGUID) + } +} + +class GUIDTaskUnregister4Test extends ActorTest() { + "RegisterVehicle" in { + val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup + val obj = Vehicle(GlobalDefinitions.fury) + val obj_wep = obj.WeaponControlledFromSeat(0).get + val obj_wep_ammo = (obj.WeaponControlledFromSeat(0).get.asInstanceOf[Tool].AmmoSlots.head.Box = AmmoBox(GlobalDefinitions.hellfire_ammo)).get + obj.Trunk += 30 -> AmmoBox(GlobalDefinitions.hellfire_ammo) + val obj_trunk_ammo = obj.Trunk.Items(0).obj + guid.register(obj, "dynamic") + guid.register(obj_wep, "dynamic") + guid.register(obj_wep_ammo, "dynamic") + guid.register(obj_trunk_ammo, "dynamic") + + assert(obj.HasGUID) + assert(obj_wep.HasGUID) + assert(obj_wep_ammo.HasGUID) + assert(obj_trunk_ammo.HasGUID) + taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.UnregisterVehicle(obj)(uns))) + probe.expectMsg(scala.util.Success) + assert(!obj.HasGUID) + assert(!obj_wep.HasGUID) + assert(!obj_wep_ammo.HasGUID) + assert(!obj_trunk_ammo.HasGUID) + } +} + +class GUIDTaskUnregister5Test extends ActorTest() { + "UnregisterAvatar" in { + val (guid, uns, taskResolver, probe) = GUIDTaskTest.CommonTestSetup + val obj = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + val obj_wep = Tool(GlobalDefinitions.beamer) + obj.Slot(0).Equipment = obj_wep + val obj_wep_ammo = AmmoBox(GlobalDefinitions.energy_cell) + obj_wep.AmmoSlots.head.Box = obj_wep_ammo + val obj_inv_ammo = AmmoBox(GlobalDefinitions.energy_cell) + obj.Slot(6).Equipment = obj_inv_ammo + val obj_locker = obj.Slot(5).Equipment.get + val obj_locker_ammo = AmmoBox(GlobalDefinitions.energy_cell) + obj_locker.asInstanceOf[LockerContainer].Inventory += 0 -> obj_locker_ammo + guid.register(obj, "dynamic") + guid.register(obj_wep, "dynamic") + guid.register(obj_wep_ammo, "dynamic") + guid.register(obj_inv_ammo, "dynamic") + guid.register(obj_locker, "dynamic") + guid.register(obj_locker_ammo, "dynamic") + + assert(obj.HasGUID) + assert(obj_wep.HasGUID) + assert(obj_wep_ammo.HasGUID) + assert(obj_inv_ammo.HasGUID) + assert(obj_locker.HasGUID) + assert(obj_locker_ammo.HasGUID) + taskResolver ! TaskResolver.GiveTask(new GUIDTaskTest.RegisterTestTask(probe.ref), List(GUIDTask.UnregisterAvatar(obj)(uns))) + probe.expectMsg(scala.util.Success) + assert(!obj.HasGUID) + assert(!obj_wep.HasGUID) + assert(!obj_wep_ammo.HasGUID) + assert(!obj_inv_ammo.HasGUID) + assert(!obj_locker.HasGUID) + assert(!obj_locker_ammo.HasGUID) + } +} + +object GUIDTaskTest { + class TestObject extends IdentifiableEntity + + class RegisterTestTask(probe : ActorRef) extends Task { + def Execute(resolver : ActorRef) : Unit = { + probe ! scala.util.Success + resolver ! scala.util.Success(this) + } + } + + def CommonTestSetup(implicit system : ActorSystem) : (NumberPoolHub, ActorRef, ActorRef, TestProbe) = { + import akka.actor.Props + import akka.routing.RandomPool + import akka.testkit.TestProbe + + val guid : NumberPoolHub = new NumberPoolHub(new LimitedNumberSource(110)) + guid.AddPool("dynamic", (1 to 100).toList).Selector = new RandomSelector //TODO name is hardcoded for now + val uns = system.actorOf(RandomPool(25).props(Props(classOf[UniqueNumberSystem], guid, GUIDTaskTest.AllocateNumberPoolActors(guid))), "uns") + val taskResolver = system.actorOf(RandomPool(15).props(Props[TaskResolver]), "resolver") + LogManager.getLogManager.reset() //suppresses any internal loggers created by the above elements + (guid, uns, taskResolver, TestProbe()) + } + + /** + * @see `UniqueNumberSystem.AllocateNumberPoolActors(NumberPoolHub)(implicit ActorContext)` + */ + def AllocateNumberPoolActors(poolSource : NumberPoolHub)(implicit system : ActorSystem) : Map[String, ActorRef] = { + poolSource.Pools.map({ case ((pname, pool)) => + pname -> system.actorOf(Props(classOf[NumberPoolActor], pool), pname) + }).toMap + } +} diff --git a/common/src/test/scala/objects/IFFLockTest.scala b/common/src/test/scala/objects/IFFLockTest.scala new file mode 100644 index 00000000..54be04d1 --- /dev/null +++ b/common/src/test/scala/objects/IFFLockTest.scala @@ -0,0 +1,66 @@ +// Copyright (c) 2017 PSForever +package objects + +import akka.actor.{ActorRef, Props} +import net.psforever.objects.serverobject.CommonMessages +import net.psforever.objects.{GlobalDefinitions, Player} +import net.psforever.objects.serverobject.locks.{IFFLock, IFFLockControl} +import net.psforever.packet.game.PlanetSideGUID +import net.psforever.types.{CharacterGender, PlanetSideEmpire} +import org.specs2.mutable.Specification + +class IFFLockTest extends Specification { + "IFFLock" should { + "construct" in { + IFFLock(GlobalDefinitions.lock_external) + ok + } + + //TODO internal hacking logic will be re-written later + } +} + +class IFFLockControl1Test extends ActorTest() { + "IFFLockControl" should { + "construct" in { + val lock = IFFLock(GlobalDefinitions.lock_external) + lock.Actor = system.actorOf(Props(classOf[IFFLockControl], lock), "lock-control") + assert(lock.Actor != ActorRef.noSender) + } + } +} + +class IFFLockControl2Test extends ActorTest() { + "IFFLockControl" should { + "can hack" in { + val lock = IFFLock(GlobalDefinitions.lock_external) + lock.Actor = system.actorOf(Props(classOf[IFFLockControl], lock), "lock-control") + val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player.GUID = PlanetSideGUID(1) + assert(lock.HackedBy.isEmpty) + + lock.Actor ! CommonMessages.Hack(player) + Thread.sleep(500L) //blocking + assert(lock.HackedBy.nonEmpty) //TODO rewrite later + } + } +} + +class IFFLockControl3Test extends ActorTest() { + "IFFLockControl" should { + "can hack" in { + val lock = IFFLock(GlobalDefinitions.lock_external) + lock.Actor = system.actorOf(Props(classOf[IFFLockControl], lock), "lock-control") + val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player.GUID = PlanetSideGUID(1) + assert(lock.HackedBy.isEmpty) + + lock.Actor ! CommonMessages.Hack(player) + Thread.sleep(500L) //blocking + assert(lock.HackedBy.nonEmpty) //TODO rewrite later + lock.Actor ! CommonMessages.ClearHack() + Thread.sleep(500L) //blocking + assert(lock.HackedBy.isEmpty) //TODO rewrite + } + } +} diff --git a/common/src/test/scala/objects/VehicleTest.scala b/common/src/test/scala/objects/VehicleTest.scala index 11b1d65a..d898a66e 100644 --- a/common/src/test/scala/objects/VehicleTest.scala +++ b/common/src/test/scala/objects/VehicleTest.scala @@ -1,9 +1,11 @@ // Copyright (c) 2017 PSForever package objects -import net.psforever.objects.{GlobalDefinitions, Vehicle} +import net.psforever.objects.{GlobalDefinitions, Player, Vehicle} import net.psforever.objects.definition.SeatDefinition -import net.psforever.objects.vehicles.{Seat, SeatArmorRestriction, VehicleLockState} +import net.psforever.objects.vehicles.{AccessPermissionGroup, Seat, SeatArmorRestriction, VehicleLockState} +import net.psforever.packet.game.PlanetSideGUID +import net.psforever.types.{CharacterGender, ExoSuitType, PlanetSideEmpire} import org.specs2.mutable._ class VehicleTest extends Specification { @@ -37,8 +39,7 @@ class VehicleTest extends Specification { fury.Seats(0).Bailable mustEqual true fury.Seats(0).ControlledWeapon mustEqual Some(1) fury.MountPoints.size mustEqual 2 - fury.MountPoints.get(0) mustEqual Some(0) - fury.MountPoints.get(1) mustEqual None + fury.MountPoints.get(1) mustEqual Some(0) fury.MountPoints.get(2) mustEqual Some(0) fury.Weapons.size mustEqual 1 fury.Weapons.get(0) mustEqual None @@ -63,6 +64,58 @@ class VehicleTest extends Specification { seat.isOccupied mustEqual false seat.Occupant mustEqual None } + + "player can sit" in { + val seat = new Seat(seat_def) + seat.Occupant.isDefined mustEqual false + + val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player1.ExoSuit = ExoSuitType.MAX + seat.Occupant = player1 + seat.Occupant.isDefined mustEqual true + seat.Occupant.contains(player1) mustEqual true + } + + "one occupant at a time" in { + val seat = new Seat(seat_def) + seat.Occupant.isDefined mustEqual false + + val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player1.ExoSuit = ExoSuitType.MAX + seat.Occupant = player1 + seat.Occupant.isDefined mustEqual true + seat.Occupant.contains(player1) mustEqual true + + val player2 = Player("test2", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player2.ExoSuit = ExoSuitType.MAX + seat.Occupant = player2 + seat.Occupant.isDefined mustEqual true + seat.Occupant.contains(player1) mustEqual true + } + + "one player must get out of seat before other can get in" in { + val seat = new Seat(seat_def) + seat.Occupant.isDefined mustEqual false + + val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player1.ExoSuit = ExoSuitType.MAX + seat.Occupant = player1 + seat.Occupant.isDefined mustEqual true + seat.Occupant.contains(player1) mustEqual true + + val player2 = Player("test2", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player2.ExoSuit = ExoSuitType.MAX + seat.Occupant = player2 + seat.Occupant.isDefined mustEqual true + seat.Occupant.contains(player2) mustEqual false + seat.Occupant.contains(player1) mustEqual true + + seat.Occupant = None + seat.Occupant.isDefined mustEqual false + seat.Occupant = player2 + seat.Occupant.isDefined mustEqual true + seat.Occupant.contains(player2) mustEqual true + } } "Vehicle" should { @@ -93,11 +146,111 @@ class VehicleTest extends Specification { fury_vehicle.Trunk.Width mustEqual 11 fury_vehicle.Trunk.Height mustEqual 11 fury_vehicle.Trunk.Offset mustEqual 30 - fury_vehicle.GetSeatFromMountPoint(0) mustEqual Some(0) - fury_vehicle.GetSeatFromMountPoint(1) mustEqual None + fury_vehicle.GetSeatFromMountPoint(1) mustEqual Some(0) fury_vehicle.GetSeatFromMountPoint(2) mustEqual Some(0) fury_vehicle.Decal mustEqual 0 fury_vehicle.Health mustEqual fury_vehicle.Definition.MaxHealth } + + "can be owned by a player" in { + val fury_vehicle = Vehicle(GlobalDefinitions.fury) + fury_vehicle.Owner.isDefined mustEqual false + + val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player1.GUID = PlanetSideGUID(1) + fury_vehicle.Owner = player1 + fury_vehicle.Owner.isDefined mustEqual true + fury_vehicle.Owner.contains(PlanetSideGUID(1)) mustEqual true + } + + "ownership depends on who last was granted it" in { + val fury_vehicle = Vehicle(GlobalDefinitions.fury) + fury_vehicle.Owner.isDefined mustEqual false + + val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player1.GUID = PlanetSideGUID(1) + fury_vehicle.Owner = player1 + fury_vehicle.Owner.isDefined mustEqual true + fury_vehicle.Owner.contains(PlanetSideGUID(1)) mustEqual true + + val player2 = Player("test2", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player2.GUID = PlanetSideGUID(2) + fury_vehicle.Owner = player2 + fury_vehicle.Owner.isDefined mustEqual true + fury_vehicle.Owner.contains(PlanetSideGUID(2)) mustEqual true + } + + "can use mount point to get seat number" in { + val fury_vehicle = Vehicle(GlobalDefinitions.fury) + fury_vehicle.GetSeatFromMountPoint(0) mustEqual None + fury_vehicle.GetSeatFromMountPoint(1) mustEqual Some(0) + fury_vehicle.GetSeatFromMountPoint(2) mustEqual Some(0) + fury_vehicle.GetSeatFromMountPoint(3) mustEqual None + } + + "has four permission groups" in { + val fury_vehicle = Vehicle(GlobalDefinitions.fury) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id) mustEqual Some(VehicleLockState.Locked) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Gunner.id) mustEqual Some(VehicleLockState.Empire) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Passenger.id) mustEqual Some(VehicleLockState.Empire) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Trunk.id) mustEqual Some(VehicleLockState.Locked) + } + + "set new permission level" in { + val fury_vehicle = Vehicle(GlobalDefinitions.fury) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id) mustEqual Some(VehicleLockState.Locked) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id, VehicleLockState.Group.id) mustEqual Some(VehicleLockState.Group) + } + + "set the same permission level" in { + val fury_vehicle = Vehicle(GlobalDefinitions.fury) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id) mustEqual Some(VehicleLockState.Locked) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id, VehicleLockState.Locked.id) mustEqual None + } + + "alternate permission level indices" in { + val fury_vehicle = Vehicle(GlobalDefinitions.fury) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id) mustEqual fury_vehicle.PermissionGroup(10) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Gunner.id) mustEqual fury_vehicle.PermissionGroup(11) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Passenger.id) mustEqual fury_vehicle.PermissionGroup(12) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Trunk.id) mustEqual fury_vehicle.PermissionGroup(13) + + (AccessPermissionGroup.Driver.id + 10) mustEqual 10 + fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id, VehicleLockState.Group.id) mustEqual Some(VehicleLockState.Group) + fury_vehicle.PermissionGroup(AccessPermissionGroup.Driver.id) mustEqual fury_vehicle.PermissionGroup(10) + } + + "can determine permission group from seat" in { + val harasser_vehicle = Vehicle(GlobalDefinitions.two_man_assault_buggy) + harasser_vehicle.SeatPermissionGroup(0) mustEqual Some(AccessPermissionGroup.Driver) + harasser_vehicle.SeatPermissionGroup(1) mustEqual Some(AccessPermissionGroup.Gunner) + harasser_vehicle.SeatPermissionGroup(2) mustEqual None + //TODO test for AccessPermissionGroup.Passenger later + } + + "can find a passenger in a seat" in { + val harasser_vehicle = Vehicle(GlobalDefinitions.two_man_assault_buggy) + val player1 = Player("test1", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player1.GUID = PlanetSideGUID(1) + val player2 = Player("test2", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + player2.GUID = PlanetSideGUID(2) + harasser_vehicle.Seat(0).get.Occupant = player1 //don't worry about ownership for now + harasser_vehicle.Seat(1).get.Occupant = player2 + + harasser_vehicle.PassengerInSeat(player1) mustEqual Some(0) + harasser_vehicle.PassengerInSeat(player2) mustEqual Some(1) + harasser_vehicle.Seat(0).get.Occupant = None + harasser_vehicle.PassengerInSeat(player1) mustEqual None + harasser_vehicle.PassengerInSeat(player2) mustEqual Some(1) + } + + "can find a weapon controlled from seat" in { + val harasser_vehicle = Vehicle(GlobalDefinitions.two_man_assault_buggy) + val chaingun_p = harasser_vehicle.Weapons(2).Equipment + chaingun_p.isDefined mustEqual true + + harasser_vehicle.WeaponControlledFromSeat(0) mustEqual None + harasser_vehicle.WeaponControlledFromSeat(1) mustEqual chaingun_p + } } } diff --git a/common/src/test/scala/objects/ZoneTest.scala b/common/src/test/scala/objects/ZoneTest.scala new file mode 100644 index 00000000..268f99da --- /dev/null +++ b/common/src/test/scala/objects/ZoneTest.scala @@ -0,0 +1,104 @@ +// Copyright (c) 2017 PSForever +package objects + +import akka.actor.ActorRef +import net.psforever.objects.entity.IdentifiableEntity +import net.psforever.objects.equipment.Equipment +import net.psforever.objects.guid.NumberPoolHub +import net.psforever.objects.guid.source.LimitedNumberSource +import net.psforever.objects.zones.{Zone, ZoneMap} +import net.psforever.objects.{GlobalDefinitions, Vehicle} +import org.specs2.mutable.Specification + +class ZoneTest extends Specification { + "ZoneMap" should { + //TODO these are temporary tests as the current ZoneMap is a kludge + "construct" in { + new ZoneMap("map13") + ok + } + + "references bases by a positive building id (defaults to 0)" in { + val map = new ZoneMap("map13") + map.LocalBases mustEqual 0 + map.LocalBases = 10 + map.LocalBases mustEqual 10 + map.LocalBases = -1 + map.LocalBases mustEqual 10 + } + + "associates objects to bases (doesn't check numbers)" in { + val map = new ZoneMap("map13") + map.ObjectToBase mustEqual Nil + map.ObjectToBase(1, 2) + map.ObjectToBase mustEqual List((1, 2)) + map.ObjectToBase(3, 4) + map.ObjectToBase mustEqual List((1, 2), (3, 4)) + } + + "associates doors to door locks (doesn't check numbers)" in { + val map = new ZoneMap("map13") + map.DoorToLock mustEqual Map.empty + map.DoorToLock(1, 2) + map.DoorToLock mustEqual Map(1 -> 2) + map.DoorToLock(3, 4) + map.DoorToLock mustEqual Map(1 -> 2, 3 -> 4) + } + } + + val map13 = new ZoneMap("map13") + map13.LocalBases = 10 + class TestObject extends IdentifiableEntity + + "Zone" should { + //TODO these are temporary tests as the current Zone is a kludge + "construct" in { + val zone = new Zone("home3", map13, 13) + zone.GUID mustEqual ActorRef.noSender + zone.Ground mustEqual ActorRef.noSender + zone.Transport mustEqual ActorRef.noSender + //zone also has a unique identifier system but it can't be accessed without its the Actor GUID being initialized + zone.EquipmentOnGround mustEqual List.empty[Equipment] + zone.Vehicles mustEqual List.empty[Vehicle] + } + + "can have its unique identifier system changed if no objects were added to it" in { + val zone = new Zone("home3", map13, 13) + val guid1 : NumberPoolHub = new NumberPoolHub(new LimitedNumberSource(100)) + guid1.AddPool("pool1", (0 to 50).toList) + guid1.AddPool("pool2", (51 to 75).toList) + zone.GUID(guid1) mustEqual true + + val obj = new TestObject() + guid1.register(obj, "pool2").isSuccess mustEqual true + guid1.WhichPool(obj) mustEqual Some("pool2") + + val guid2 : NumberPoolHub = new NumberPoolHub(new LimitedNumberSource(150)) + guid2.AddPool("pool3", (0 to 50).toList) + guid2.AddPool("pool4", (51 to 75).toList) + zone.GUID(guid2) mustEqual false + } + + "can keep track of Vehicles" in { + val zone = new Zone("home3", map13, 13) + val fury = Vehicle(GlobalDefinitions.fury) + zone.Vehicles mustEqual List() + zone.AddVehicle(fury) + zone.Vehicles mustEqual List(fury) + } + + "can forget specific vehicles" in { + val zone = new Zone("home3", map13, 13) + val fury = Vehicle(GlobalDefinitions.fury) + val wraith = Vehicle(GlobalDefinitions.quadstealth) + val basilisk = Vehicle(GlobalDefinitions.quadassault) + zone.AddVehicle(wraith) + zone.AddVehicle(fury) + zone.AddVehicle(basilisk) + zone.Vehicles mustEqual List(wraith, fury, basilisk) + + zone.RemoveVehicle(fury) + zone.Vehicles mustEqual List(wraith, basilisk) + } + } +} diff --git a/common/src/test/scala/objects/NumberPoolActorTest.scala b/common/src/test/scala/objects/number/NumberPoolActorTest.scala similarity index 91% rename from common/src/test/scala/objects/NumberPoolActorTest.scala rename to common/src/test/scala/objects/number/NumberPoolActorTest.scala index f40eac43..e9596a0d 100644 --- a/common/src/test/scala/objects/NumberPoolActorTest.scala +++ b/common/src/test/scala/objects/number/NumberPoolActorTest.scala @@ -1,10 +1,11 @@ // Copyright (c) 2017 PSForever -package objects +package objects.number import akka.actor.{ActorSystem, Props} 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 @@ -15,7 +16,7 @@ class NumberPoolActorTest extends ActorTest(ActorSystem("test")) { pool.Selector = new RandomSelector val poolActor = system.actorOf(Props(classOf[NumberPoolActor], pool), name = "poolActor1") poolActor ! NumberPoolActor.GetAnyNumber() - val msg = receiveOne(Duration.create(100, "ms")) + val msg = receiveOne(Duration.create(500, "ms")) assert(msg.isInstanceOf[NumberPoolActor.GiveNumber]) } } @@ -43,7 +44,7 @@ class NumberPoolActorTest2 extends ActorTest(ActorSystem("test")) { expectMsg(NumberPoolActor.GiveNumber(25, None)) poolActor ! NumberPoolActor.GetAnyNumber() - val msg = receiveOne(Duration.create(100, "ms")) + val msg = receiveOne(Duration.create(500, "ms")) assert(msg.isInstanceOf[NumberPoolActor.NoNumber]) } } diff --git a/common/src/test/scala/objects/NumberPoolHubTest.scala b/common/src/test/scala/objects/number/NumberPoolHubTest.scala similarity index 99% rename from common/src/test/scala/objects/NumberPoolHubTest.scala rename to common/src/test/scala/objects/number/NumberPoolHubTest.scala index 10738a18..551d0909 100644 --- a/common/src/test/scala/objects/NumberPoolHubTest.scala +++ b/common/src/test/scala/objects/number/NumberPoolHubTest.scala @@ -1,5 +1,5 @@ // Copyright (c) 2017 PSForever -package objects +package objects.number import net.psforever.objects.entity.IdentifiableEntity import net.psforever.objects.guid.NumberPoolHub diff --git a/common/src/test/scala/objects/NumberPoolTest.scala b/common/src/test/scala/objects/number/NumberPoolTest.scala similarity index 99% rename from common/src/test/scala/objects/NumberPoolTest.scala rename to common/src/test/scala/objects/number/NumberPoolTest.scala index a8bbda2b..f29bbc0a 100644 --- a/common/src/test/scala/objects/NumberPoolTest.scala +++ b/common/src/test/scala/objects/number/NumberPoolTest.scala @@ -1,5 +1,5 @@ // Copyright (c) 2017 PSForever -package objects +package objects.number import net.psforever.objects.guid.pool.{ExclusivePool, GenericPool, SimplePool} import net.psforever.objects.guid.selector.SpecificSelector @@ -191,4 +191,3 @@ class NumberPoolTest extends Specification { } } } - diff --git a/common/src/test/scala/objects/NumberSelectorTest.scala b/common/src/test/scala/objects/number/NumberSelectorTest.scala similarity index 99% rename from common/src/test/scala/objects/NumberSelectorTest.scala rename to common/src/test/scala/objects/number/NumberSelectorTest.scala index 463f9654..e9a9fe2a 100644 --- a/common/src/test/scala/objects/NumberSelectorTest.scala +++ b/common/src/test/scala/objects/number/NumberSelectorTest.scala @@ -1,5 +1,5 @@ // Copyright (c) 2017 PSForever -package objects +package objects.number import net.psforever.objects.guid.selector.{RandomSequenceSelector, _} import org.specs2.mutable.Specification @@ -323,4 +323,3 @@ class NumberSelectorTest extends Specification { } } } - diff --git a/common/src/test/scala/objects/NumberSourceTest.scala b/common/src/test/scala/objects/number/NumberSourceTest.scala similarity index 99% rename from common/src/test/scala/objects/NumberSourceTest.scala rename to common/src/test/scala/objects/number/NumberSourceTest.scala index 08c9f48a..dac0df17 100644 --- a/common/src/test/scala/objects/NumberSourceTest.scala +++ b/common/src/test/scala/objects/number/NumberSourceTest.scala @@ -1,8 +1,8 @@ // Copyright (c) 2017 PSForever -package objects +package objects.number -import net.psforever.objects.guid.key.{LoanedKey, SecureKey} import net.psforever.objects.guid.AvailabilityPolicy +import net.psforever.objects.guid.key.{LoanedKey, SecureKey} import org.specs2.mutable.Specification class NumberSourceTest extends Specification { diff --git a/common/src/test/scala/objects/UniqueNumberSystemTest.scala b/common/src/test/scala/objects/number/UniqueNumberSystemTest.scala similarity index 87% rename from common/src/test/scala/objects/UniqueNumberSystemTest.scala rename to common/src/test/scala/objects/number/UniqueNumberSystemTest.scala index a685b035..be8d3e7f 100644 --- a/common/src/test/scala/objects/UniqueNumberSystemTest.scala +++ b/common/src/test/scala/objects/number/UniqueNumberSystemTest.scala @@ -1,5 +1,5 @@ // Copyright (c) 2017 PSForever -package objects +package objects.number import akka.actor.{ActorRef, ActorSystem, Props} import net.psforever.objects.entity.IdentifiableEntity @@ -7,11 +7,12 @@ 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(ActorSystem("test")) { +class AllocateNumberPoolActors extends ActorTest() { "AllocateNumberPoolActors" in { val src : LimitedNumberSource = LimitedNumberSource(6000) val guid : NumberPoolHub = new NumberPoolHub(src) @@ -27,7 +28,7 @@ class AllocateNumberPoolActors extends ActorTest(ActorSystem("test")) { } } -class UniqueNumberSystemTest extends ActorTest(ActorSystem("test")) { +class UniqueNumberSystemTest extends ActorTest() { "UniqueNumberSystem" should { "constructor" in { val src : LimitedNumberSource = LimitedNumberSource(6000) @@ -37,12 +38,11 @@ class UniqueNumberSystemTest extends ActorTest(ActorSystem("test")) { guid.AddPool("pool3", (5001 to 6000).toList) system.actorOf(Props(classOf[UniqueNumberSystem], guid, UniqueNumberSystemTest.AllocateNumberPoolActors(guid)), "uns") //as long as it constructs ... - } } } -class UniqueNumberSystemTest1 extends ActorTest(ActorSystem("test")) { +class UniqueNumberSystemTest1 extends ActorTest() { class EntityTestClass extends IdentifiableEntity "UniqueNumberSystem" should { @@ -61,7 +61,7 @@ class UniqueNumberSystemTest1 extends ActorTest(ActorSystem("test")) { for(_ <- 1 to 100) { val testObj = new EntityTestClass() uns ! Register(testObj, "pool1") - val msg = receiveOne(Duration.create(100, "ms")) + val msg = receiveOne(Duration.create(500, "ms")) assert(msg.isInstanceOf[Success[_]]) assert(pool1.contains(testObj.GUID.guid)) } @@ -69,7 +69,7 @@ class UniqueNumberSystemTest1 extends ActorTest(ActorSystem("test")) { for(_ <- 1 to 100) { val testObj = new EntityTestClass() uns ! Register(testObj, "pool2") - val msg = receiveOne(Duration.create(100, "ms")) + val msg = receiveOne(Duration.create(500, "ms")) assert(msg.isInstanceOf[Success[_]]) assert(pool2.contains(testObj.GUID.guid)) } @@ -77,7 +77,7 @@ class UniqueNumberSystemTest1 extends ActorTest(ActorSystem("test")) { for(_ <- 1 to 100) { val testObj = new EntityTestClass() uns ! Register(testObj, "pool3") - val msg = receiveOne(Duration.create(100, "ms")) + val msg = receiveOne(Duration.create(500, "ms")) assert(msg.isInstanceOf[Success[_]]) assert(pool3.contains(testObj.GUID.guid)) } @@ -86,7 +86,7 @@ class UniqueNumberSystemTest1 extends ActorTest(ActorSystem("test")) { } } -class UniqueNumberSystemTest2 extends ActorTest(ActorSystem("test")) { +class UniqueNumberSystemTest2 extends ActorTest() { class EntityTestClass extends IdentifiableEntity "UniqueNumberSystem" should { @@ -102,14 +102,14 @@ class UniqueNumberSystemTest2 extends ActorTest(ActorSystem("test")) { assert(src.CountUsed == 0) uns ! Register(testObj, "pool1") - val msg1 = receiveOne(Duration.create(100, "ms")) + val msg1 = receiveOne(Duration.create(500, "ms")) assert(msg1.isInstanceOf[Success[_]]) assert(testObj.HasGUID) assert(src.CountUsed == 1) val id = testObj.GUID.guid uns ! Register(testObj, "pool2") //different pool; makes no difference - val msg2 = receiveOne(Duration.create(100, "ms")) + val msg2 = receiveOne(Duration.create(500, "ms")) assert(msg2.isInstanceOf[Success[_]]) assert(testObj.HasGUID) assert(src.CountUsed == 1) @@ -119,7 +119,7 @@ class UniqueNumberSystemTest2 extends ActorTest(ActorSystem("test")) { //a log.warn should have been generated during this test } -class UniqueNumberSystemTest3 extends ActorTest(ActorSystem("test")) { +class UniqueNumberSystemTest3 extends ActorTest() { class EntityTestClass extends IdentifiableEntity "UniqueNumberSystem" should { @@ -135,7 +135,7 @@ class UniqueNumberSystemTest3 extends ActorTest(ActorSystem("test")) { assert(src.CountUsed == 0) uns ! Register(testObj, "pool4") - val msg1 = receiveOne(Duration.create(100, "ms")) + val msg1 = receiveOne(Duration.create(500, "ms")) assert(msg1.isInstanceOf[Failure[_]]) assert(!testObj.HasGUID) assert(src.CountUsed == 0) @@ -143,7 +143,7 @@ class UniqueNumberSystemTest3 extends ActorTest(ActorSystem("test")) { } } -class UniqueNumberSystemTest4 extends ActorTest(ActorSystem("test")) { +class UniqueNumberSystemTest4 extends ActorTest() { class EntityTestClass extends IdentifiableEntity "UniqueNumberSystem" should { @@ -158,18 +158,18 @@ class UniqueNumberSystemTest4 extends ActorTest(ActorSystem("test")) { val testObj1 = new EntityTestClass() uns ! Register(testObj1, "pool4") - val msg1 = receiveOne(Duration.create(100, "ms")) + val msg1 = receiveOne(Duration.create(500, "ms")) assert(msg1.isInstanceOf[Success[_]]) //pool4 is now empty val testObj2 = new EntityTestClass() uns ! Register(testObj2, "pool4") - val msg2 = receiveOne(Duration.create(100, "ms")) + val msg2 = receiveOne(Duration.create(500, "ms")) assert(msg2.isInstanceOf[Failure[_]]) } } } -class UniqueNumberSystemTest5 extends ActorTest(ActorSystem("test")) { +class UniqueNumberSystemTest5 extends ActorTest() { class EntityTestClass extends IdentifiableEntity "UniqueNumberSystem" should { @@ -186,14 +186,14 @@ class UniqueNumberSystemTest5 extends ActorTest(ActorSystem("test")) { assert(src.CountUsed == 0) uns ! Register(testObj, "pool2") - val msg1 = receiveOne(Duration.create(100, "ms")) + val msg1 = receiveOne(Duration.create(500, "ms")) assert(msg1.isInstanceOf[Success[_]]) assert(testObj.HasGUID) assert(pool2.contains(testObj.GUID.guid)) assert(src.CountUsed == 1) uns ! Unregister(testObj) - val msg2 = receiveOne(Duration.create(100, "ms")) + val msg2 = receiveOne(Duration.create(500, "ms")) assert(msg2.isInstanceOf[Success[_]]) assert(!testObj.HasGUID) assert(src.CountUsed == 0) @@ -201,7 +201,7 @@ class UniqueNumberSystemTest5 extends ActorTest(ActorSystem("test")) { } } -class UniqueNumberSystemTest6 extends ActorTest(ActorSystem("test")) { +class UniqueNumberSystemTest6 extends ActorTest() { class EntityTestClass extends IdentifiableEntity "UniqueNumberSystem" should { @@ -217,7 +217,7 @@ class UniqueNumberSystemTest6 extends ActorTest(ActorSystem("test")) { assert(src.CountUsed == 0) uns ! Unregister(testObj) - val msg1 = receiveOne(Duration.create(100, "ms")) + val msg1 = receiveOne(Duration.create(500, "ms")) assert(msg1.isInstanceOf[Success[_]]) assert(!testObj.HasGUID) assert(src.CountUsed == 0) @@ -225,7 +225,7 @@ class UniqueNumberSystemTest6 extends ActorTest(ActorSystem("test")) { } } -class UniqueNumberSystemTest7 extends ActorTest(ActorSystem("test")) { +class UniqueNumberSystemTest7 extends ActorTest() { class EntityTestClass extends IdentifiableEntity "UniqueNumberSystem" should { @@ -242,7 +242,7 @@ class UniqueNumberSystemTest7 extends ActorTest(ActorSystem("test")) { assert(src.CountUsed == 0) uns ! Unregister(testObj) - val msg1 = receiveOne(Duration.create(100, "ms")) + val msg1 = receiveOne(Duration.create(500, "ms")) assert(msg1.isInstanceOf[Failure[_]]) assert(testObj.HasGUID) assert(src.CountUsed == 0) @@ -250,7 +250,7 @@ class UniqueNumberSystemTest7 extends ActorTest(ActorSystem("test")) { } } -class UniqueNumberSystemTest8 extends ActorTest(ActorSystem("test")) { +class UniqueNumberSystemTest8 extends ActorTest() { class EntityTestClass extends IdentifiableEntity "UniqueNumberSystem" should { @@ -267,7 +267,7 @@ class UniqueNumberSystemTest8 extends ActorTest(ActorSystem("test")) { assert(src.CountUsed == 0) uns ! Unregister(testObj) - val msg1 = receiveOne(Duration.create(100, "ms")) + val msg1 = receiveOne(Duration.create(500, "ms")) assert(msg1.isInstanceOf[Failure[_]]) assert(testObj.HasGUID) assert(src.CountUsed == 0) @@ -285,4 +285,3 @@ object UniqueNumberSystemTest { }).toMap } } - diff --git a/common/src/test/scala/objects/terminal/CertTerminalTest.scala b/common/src/test/scala/objects/terminal/CertTerminalTest.scala new file mode 100644 index 00000000..96b83668 --- /dev/null +++ b/common/src/test/scala/objects/terminal/CertTerminalTest.scala @@ -0,0 +1,47 @@ +// Copyright (c) 2017 PSForever +package objects.terminal + +import akka.actor.ActorRef +import net.psforever.objects.serverobject.terminals.Terminal +import net.psforever.objects.{GlobalDefinitions, Player} +import net.psforever.packet.game.{ItemTransactionMessage, PlanetSideGUID} +import net.psforever.types._ +import org.specs2.mutable.Specification + +class CertTerminalTest extends Specification { + "Cert_Terminal" should { + val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + + "construct" in { + val terminal = Terminal(GlobalDefinitions.cert_terminal) + terminal.Actor mustEqual ActorRef.noSender + } + + "player can learn a certification ('medium_assault')" in { + val terminal = Terminal(GlobalDefinitions.cert_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "medium_assault", 0, PlanetSideGUID(0)) + terminal.Request(player, msg) mustEqual Terminal.LearnCertification(CertificationType.MediumAssault, 2) + } + + "player can not learn a fake certification ('juggling')" in { + val terminal = Terminal(GlobalDefinitions.cert_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "juggling", 0, PlanetSideGUID(0)) + + terminal.Request(player, msg) mustEqual Terminal.NoDeal() + } + + "player can forget a certification ('medium_assault')" in { + val terminal = Terminal(GlobalDefinitions.cert_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Sell, 0, "medium_assault", 0, PlanetSideGUID(0)) + + terminal.Request(player, msg) mustEqual Terminal.SellCertification(CertificationType.MediumAssault, 2) + } + + "player can not forget a fake certification ('juggling')" in { + val terminal = Terminal(GlobalDefinitions.cert_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Sell, 0, "juggling", 0, PlanetSideGUID(0)) + + terminal.Request(player, msg) mustEqual Terminal.NoDeal() + } + } +} diff --git a/common/src/test/scala/objects/terminal/OrderTerminalTest.scala b/common/src/test/scala/objects/terminal/OrderTerminalTest.scala new file mode 100644 index 00000000..c5e41100 --- /dev/null +++ b/common/src/test/scala/objects/terminal/OrderTerminalTest.scala @@ -0,0 +1,85 @@ +// Copyright (c) 2017 PSForever +package objects.terminal + +import akka.actor.ActorRef +import net.psforever.objects.serverobject.terminals.Terminal +import net.psforever.objects.{AmmoBox, GlobalDefinitions, Player, Tool} +import net.psforever.packet.game.{ItemTransactionMessage, PlanetSideGUID} +import net.psforever.types._ +import org.specs2.mutable.Specification + +class OrderTerminalTest extends Specification { + "Order_Terminal" should { + val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + + "construct" in { + val terminal = Terminal(GlobalDefinitions.order_terminal) + terminal.Actor mustEqual ActorRef.noSender + } + + "player can buy a box of ammunition ('9mmbullet_AP')" in { + val terminal = Terminal(GlobalDefinitions.order_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "9mmbullet_AP", 0, PlanetSideGUID(0)) + val reply = terminal.Request(player, msg) + reply.isInstanceOf[Terminal.BuyEquipment] mustEqual true + val reply2 = reply.asInstanceOf[Terminal.BuyEquipment] + reply2.item.isInstanceOf[AmmoBox] mustEqual true + reply2.item.asInstanceOf[AmmoBox].Definition mustEqual GlobalDefinitions.bullet_9mm_AP + reply2.item.asInstanceOf[AmmoBox].Capacity mustEqual 50 + } + + "player can buy a weapon ('suppressor')" in { + val terminal = Terminal(GlobalDefinitions.order_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "suppressor", 0, PlanetSideGUID(0)) + val reply = terminal.Request(player, msg) + reply.isInstanceOf[Terminal.BuyEquipment] mustEqual true + val reply2 = reply.asInstanceOf[Terminal.BuyEquipment] + reply2.item.isInstanceOf[Tool] mustEqual true + reply2.item.asInstanceOf[Tool].Definition mustEqual GlobalDefinitions.suppressor + } + + "player can buy a box of vehicle ammunition ('105mmbullet')" in { + val terminal = Terminal(GlobalDefinitions.order_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 3, "105mmbullet", 0, PlanetSideGUID(0)) + val reply = terminal.Request(player, msg) + reply.isInstanceOf[Terminal.BuyEquipment] mustEqual true + val reply2 = reply.asInstanceOf[Terminal.BuyEquipment] + reply2.item.isInstanceOf[AmmoBox] mustEqual true + reply2.item.asInstanceOf[AmmoBox].Definition mustEqual GlobalDefinitions.bullet_105mm + reply2.item.asInstanceOf[AmmoBox].Capacity mustEqual 100 + } + + "player can buy a support tool ('bank')" in { + val terminal = Terminal(GlobalDefinitions.order_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 2, "bank", 0, PlanetSideGUID(0)) + val reply = terminal.Request(player, msg) + reply.isInstanceOf[Terminal.BuyEquipment] mustEqual true + val reply2 = reply.asInstanceOf[Terminal.BuyEquipment] + reply2.item.isInstanceOf[Tool] mustEqual true + reply2.item.asInstanceOf[Tool].Definition mustEqual GlobalDefinitions.bank + } + + "player can buy different armor ('lite_armor')" in { + val terminal = Terminal(GlobalDefinitions.order_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 1, "lite_armor", 0, PlanetSideGUID(0)) + + terminal.Request(player, msg) mustEqual Terminal.BuyExosuit(ExoSuitType.Agile) + } + + "player can not buy fake equipment ('sabot')" in { + val terminal = Terminal(GlobalDefinitions.order_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 0, "sabot", 0, PlanetSideGUID(0)) + + terminal.Request(player, msg) mustEqual Terminal.NoDeal() + } + + //TODO loudout tests + + "player can not buy equipment from the wrong page ('9mmbullet_AP', page 1)" in { + val terminal = Terminal(GlobalDefinitions.order_terminal) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Buy, 1, "9mmbullet_AP", 0, PlanetSideGUID(0)) + + terminal.Request(player, msg) mustEqual Terminal.NoDeal() + } + } +} diff --git a/common/src/test/scala/objects/terminal/TerminalControlTest.scala b/common/src/test/scala/objects/terminal/TerminalControlTest.scala new file mode 100644 index 00000000..c5d8b062 --- /dev/null +++ b/common/src/test/scala/objects/terminal/TerminalControlTest.scala @@ -0,0 +1,73 @@ +// Copyright (c) 2017 PSForever +package objects.terminal + +import akka.actor.Props +import net.psforever.objects.serverobject.terminals.{Terminal, TerminalControl} +import net.psforever.objects.{GlobalDefinitions, Player} +import net.psforever.packet.game.{ItemTransactionMessage, PlanetSideGUID} +import net.psforever.types._ +import objects.ActorTest + +import scala.concurrent.duration.Duration + +class TerminalControlTest extends ActorTest() { + "TerminalControl" should { + "construct (cert terminal)" in { + val terminal = Terminal(GlobalDefinitions.cert_terminal) + terminal.Actor = system.actorOf(Props(classOf[TerminalControl], terminal), "test-cert-term") + } + } +} + +//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() { + "TerminalControl can be used to learn a certification ('medium_assault')" in { + val terminal = Terminal(GlobalDefinitions.cert_terminal) + terminal.Actor = system.actorOf(Props(classOf[TerminalControl], terminal), "test-cert-term") + val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "medium_assault", 0, PlanetSideGUID(0)) + + terminal.Actor ! Terminal.Request(player, msg) + val reply = receiveOne(Duration.create(500, "ms")) + assert(reply.isInstanceOf[Terminal.TerminalMessage]) + val reply2 = reply.asInstanceOf[Terminal.TerminalMessage] + assert(reply2.player == player) + assert(reply2.msg == msg) + assert(reply2.response == Terminal.LearnCertification(CertificationType.MediumAssault, 2)) + } +} + +class CertTerminalControl2Test extends ActorTest() { + "TerminalControl can be used to warn about not learning a fake certification ('juggling')" in { + val terminal = Terminal(GlobalDefinitions.cert_terminal) + terminal.Actor = system.actorOf(Props(classOf[TerminalControl], terminal), "test-cert-term") + val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Learn, 0, "juggling", 0, PlanetSideGUID(0)) + + terminal.Actor ! Terminal.Request(player, msg) + val reply = receiveOne(Duration.create(500, "ms")) + assert(reply.isInstanceOf[Terminal.TerminalMessage]) + val reply2 = reply.asInstanceOf[Terminal.TerminalMessage] + assert(reply2.player == player) + assert(reply2.msg == msg) + assert(reply2.response == Terminal.NoDeal()) + } +} + +class CertTerminalControl3Test extends ActorTest() { + "TerminalControl can be used to forget a certification ('medium_assault')" in { + val terminal = Terminal(GlobalDefinitions.cert_terminal) + terminal.Actor = system.actorOf(Props(classOf[TerminalControl], terminal), "test-cert-term") + val player = Player("test", PlanetSideEmpire.TR, CharacterGender.Male, 0, 0) + val msg = ItemTransactionMessage(PlanetSideGUID(1), TransactionType.Sell, 0, "medium_assault", 0, PlanetSideGUID(0)) + + terminal.Actor ! Terminal.Request(player, msg) + val reply = receiveOne(Duration.create(500, "ms")) + assert(reply.isInstanceOf[Terminal.TerminalMessage]) + val reply2 = reply.asInstanceOf[Terminal.TerminalMessage] + assert(reply2.player == player) + assert(reply2.msg == msg) + assert(reply2.response == Terminal.SellCertification(CertificationType.MediumAssault, 2)) + } +} diff --git a/pslogin/src/main/scala/WorldSessionActor.scala b/pslogin/src/main/scala/WorldSessionActor.scala index 9948e6d7..45345fa2 100644 --- a/pslogin/src/main/scala/WorldSessionActor.scala +++ b/pslogin/src/main/scala/WorldSessionActor.scala @@ -12,7 +12,7 @@ import MDCContextAware.Implicits._ import services.ServiceManager.Lookup import net.psforever.objects._ import net.psforever.objects.equipment._ -import net.psforever.objects.guid.{Task, TaskResolver} +import net.psforever.objects.guid.{GUIDTask, Task, TaskResolver} import net.psforever.objects.inventory.{GridInventory, InventoryItem} import net.psforever.objects.serverobject.{CommonMessages, PlanetSideServerObject} import net.psforever.objects.serverobject.doors.Door @@ -22,7 +22,6 @@ import net.psforever.objects.vehicles.{AccessPermissionGroup, Seat, VehicleLockS import net.psforever.objects.zones.{InterstellarCluster, Zone} import net.psforever.packet.game.objectcreate._ import net.psforever.types._ -import scripts.GUIDTask import services._ import services.avatar._ import services.local._ @@ -552,7 +551,7 @@ class WorldSessionActor extends Actor with MDCContextAware { val box = item.obj.asInstanceOf[AmmoBox] sendResponse(PacketCoding.CreateGamePacket(0, InventoryStateMessage(box.GUID, 0, vehicle_guid, box.Capacity.toLong))) }) - case None => ; //no weapons to update + case _ => ; //no weapons to update } val player_guid : PlanetSideGUID = tplayer.GUID sendResponse(PacketCoding.CreateGamePacket(0, ObjectAttachMessage(vehicle_guid, player_guid, seat_num))) diff --git a/pslogin/src/main/scala/services/vehicle/VehicleServiceResponse.scala b/pslogin/src/main/scala/services/vehicle/VehicleServiceResponse.scala index c8012873..6decd460 100644 --- a/pslogin/src/main/scala/services/vehicle/VehicleServiceResponse.scala +++ b/pslogin/src/main/scala/services/vehicle/VehicleServiceResponse.scala @@ -8,4 +8,3 @@ final case class VehicleServiceResponse(toChannel : String, avatar_guid : PlanetSideGUID, replyMessage : VehicleResponse.Response ) extends GenericEventBusMsg - diff --git a/pslogin/src/main/scala/services/vehicle/support/DeconstructionActor.scala b/pslogin/src/main/scala/services/vehicle/support/DeconstructionActor.scala index 6ad68310..441da912 100644 --- a/pslogin/src/main/scala/services/vehicle/support/DeconstructionActor.scala +++ b/pslogin/src/main/scala/services/vehicle/support/DeconstructionActor.scala @@ -3,10 +3,10 @@ package services.vehicle.support import akka.actor.{Actor, ActorRef, Cancellable} import net.psforever.objects.Vehicle +import net.psforever.objects.guid.GUIDTask import net.psforever.objects.vehicles.Seat import net.psforever.objects.zones.Zone import net.psforever.packet.game.PlanetSideGUID -import scripts.GUIDTask import services.ServiceManager import services.ServiceManager.Lookup import services.vehicle.{VehicleAction, VehicleServiceMessage}