Auto-Repair Tuning (#652)

* difficulty modifiers for repair rate and drain in config

* changed autorepair request-repair pattern to wait until a repair is fulfilled before issuing the next request; moved integration tests for efficiency

* auto-repair accounts for delay between request-reply when schduling next request; base ntu drain is halved; auto-repair mending values adjusted based on wiki times

* moving config call into auto-repair mixin

* deleting the old integration testing code

* obligatory test fixes

* more of the same

* correcting exceptions with calculating subsequent auto-repair time and transfer messaging behavior with WarpGate objects; transfer animation and transfer delivery now have slightly different timing; wrote  bunch of tests that don't work in the standard manner, but do pass
This commit is contained in:
Fate-JH 2021-01-12 14:27:33 -05:00 committed by GitHub
parent 6836c80c9f
commit 563afcdb19
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 749 additions and 258 deletions

View file

@ -1,169 +0,0 @@
// Copyright (c) 2020 PSForever
package objects
import akka.actor.Props
import akka.testkit.TestProbe
import base.FreedContextActorTest
import net.psforever.actors.zone.BuildingActor
import net.psforever.objects.avatar.Avatar
import net.psforever.objects.ballistics.{Projectile, SourceEntry}
import net.psforever.objects.guid.NumberPoolHub
import net.psforever.objects.guid.source.MaxNumberSource
import net.psforever.objects.serverobject.resourcesilo.{ResourceSilo, ResourceSiloControl}
import net.psforever.objects.serverobject.structures.{AutoRepairStats, Building, StructureType}
import net.psforever.objects.serverobject.terminals.{OrderTerminalDefinition, Terminal, TerminalControl}
import net.psforever.objects.vital.Vitality
import net.psforever.objects.vital.base.DamageResolution
import net.psforever.objects.vital.damage.DamageProfile
import net.psforever.objects.vital.interaction.DamageInteraction
import net.psforever.objects.vital.projectile.ProjectileReason
import net.psforever.objects.zones.{Zone, ZoneMap}
import net.psforever.objects.{GlobalDefinitions, Player, Tool}
import net.psforever.services.galaxy.GalaxyService
import net.psforever.services.{InterstellarClusterService, ServiceManager}
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
import scala.concurrent.duration._
class AutoRepairFacilityIntegrationTest extends FreedContextActorTest {
import akka.actor.typed.scaladsl.adapter._
system.spawn(InterstellarClusterService(Nil), InterstellarClusterService.InterstellarClusterServiceKey.id)
ServiceManager.boot(system) ! ServiceManager.Register(Props[GalaxyService](), "galaxy")
expectNoMessage(1000 milliseconds)
val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
val avatarProbe = new TestProbe(system)
val zone = new Zone("test", new ZoneMap("test"), 0) {
override def SetupNumberPools() = {}
GUID(guid)
override def AvatarEvents = avatarProbe.ref
}
val building = Building.Structure(StructureType.Facility)(name = "integ-fac-test-building", guid = 6, map_id = 0, zone, context)
building.Invalidate()
val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
player.Spawn()
val weapon = new Tool(GlobalDefinitions.suppressor)
val terminal = new Terminal(AutoRepairIntegrationTest.terminal_definition)
val silo = new ResourceSilo()
guid.register(player, number = 1)
guid.register(weapon, number = 2)
guid.register(weapon.AmmoSlot.Box, number = 3)
guid.register(terminal, number = 4)
guid.register(silo, number = 5)
guid.register(building, number = 6)
building.Amenities = silo
building.Amenities = terminal
terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
silo.NtuCapacitor = 1000
silo.Actor = system.actorOf(Props(classOf[ResourceSiloControl], silo), "test-silo")
silo.Actor ! "startup"
val wep_fmode = weapon.FireMode
val wep_prof = wep_fmode.Add
val proj = weapon.Projectile
val proj_prof = proj.asInstanceOf[DamageProfile]
val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
val resolved = DamageInteraction(
SourceEntry(terminal),
ProjectileReason(
DamageResolution.Hit,
projectile,
terminal.DamageModel
),
Vector3(1, 0, 0)
)
val applyDamageTo = resolved.calculate()
"AutoRepair" should {
"should activate on damage and trade NTU from the facility's resource silo for repairs" in {
assert(silo.NtuCapacitor == silo.MaxNtuCapacitor)
assert(terminal.Health == terminal.MaxHealth)
terminal.Actor ! Vitality.Damage(applyDamageTo)
avatarProbe.receiveOne(max = 1000 milliseconds) //health update event
assert(terminal.Health < terminal.MaxHealth)
var i = 0 //safety counter
while(terminal.Health < terminal.MaxHealth && i < 100) {
i += 1
avatarProbe.receiveOne(max = 1000 milliseconds) //health update event
}
assert(silo.NtuCapacitor < silo.MaxNtuCapacitor)
assert(terminal.Health == terminal.MaxHealth)
}
}
}
class AutoRepairTowerIntegrationTest extends FreedContextActorTest {
import akka.actor.typed.scaladsl.adapter._
system.spawn(InterstellarClusterService(Nil), InterstellarClusterService.InterstellarClusterServiceKey.id)
ServiceManager.boot(system) ! ServiceManager.Register(Props[GalaxyService](), "galaxy")
expectNoMessage(1000 milliseconds)
val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
val avatarProbe = new TestProbe(system)
val zone = new Zone("test", new ZoneMap("test"), 0) {
override def SetupNumberPools() = {}
GUID(guid)
override def AvatarEvents = avatarProbe.ref
}
val building = Building.Structure(StructureType.Tower)(name = "integ-twr-test-building", guid = 6, map_id = 0, zone, context)
building.Invalidate()
val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
player.Spawn()
val weapon = new Tool(GlobalDefinitions.suppressor)
val terminal = new Terminal(AutoRepairIntegrationTest.terminal_definition)
terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
guid.register(player, number = 1)
guid.register(weapon, number = 2)
guid.register(weapon.AmmoSlot.Box, number = 3)
guid.register(terminal, number = 4)
guid.register(building, number = 6)
building.Amenities = terminal
building.Actor ! BuildingActor.SuppliedWithNtu() //artificial
building.Actor ! BuildingActor.PowerOn() //artificial
val wep_fmode = weapon.FireMode
val wep_prof = wep_fmode.Add
val proj = weapon.Projectile
val proj_prof = proj.asInstanceOf[DamageProfile]
val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
val resolved = DamageInteraction(
SourceEntry(terminal),
ProjectileReason(
DamageResolution.Hit,
projectile,
terminal.DamageModel
),
Vector3(1, 0, 0)
)
val applyDamageTo = resolved.calculate()
"AutoRepair" should {
"should activate on damage and trade NTU from the tower for repairs" in {
assert(terminal.Health == terminal.MaxHealth)
terminal.Actor ! Vitality.Damage(applyDamageTo)
avatarProbe.receiveOne(max = 200 milliseconds) //health update event
assert(terminal.Health < terminal.MaxHealth)
var i = 0 //safety counter
while(terminal.Health < terminal.MaxHealth && i < 100) {
i += 1
avatarProbe.receiveOne(max = 1000 milliseconds) //health update event
}
assert(terminal.Health == terminal.MaxHealth)
}
}
}
object AutoRepairIntegrationTest {
val terminal_definition = new OrderTerminalDefinition(objId = 612) {
Name = "order_terminal"
MaxHealth = 500
Damageable = true
Repairable = true
autoRepair = AutoRepairStats(200, 500, 500, 1)
RepairIfDestroyed = true
}
}

View file

@ -1,418 +0,0 @@
// Copyright (c) 2020 PSForever
package objects
import akka.actor.Props
import akka.testkit.TestProbe
import base.FreedContextActorTest
import net.psforever.actors.commands.NtuCommand
import net.psforever.actors.zone.BuildingActor
import net.psforever.objects.avatar.Avatar
import net.psforever.objects.ballistics.{Projectile, SourceEntry}
import net.psforever.objects.guid.NumberPoolHub
import net.psforever.objects.guid.source.MaxNumberSource
import net.psforever.objects.serverobject.structures.{AutoRepairStats, Building, StructureType}
import net.psforever.objects.serverobject.terminals.{OrderTerminalDefinition, Terminal, TerminalControl}
import net.psforever.objects.vital.Vitality
import net.psforever.objects.vital.base.DamageResolution
import net.psforever.objects.vital.damage.DamageProfile
import net.psforever.objects.vital.interaction.DamageInteraction
import net.psforever.objects.vital.projectile.ProjectileReason
import net.psforever.objects.zones.{Zone, ZoneMap}
import net.psforever.objects.{GlobalDefinitions, Player, Tool}
import net.psforever.services.ServiceManager
import net.psforever.types.{CharacterGender, CharacterVoice, PlanetSideEmpire, Vector3}
import scala.concurrent.duration._
class AutoRepairRequestNtuTest extends FreedContextActorTest {
ServiceManager.boot
val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
player.Spawn()
val weapon = new Tool(GlobalDefinitions.suppressor)
val terminal = new Terminal(AutoRepairTest.terminal_definition)
val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
val zone = new Zone("test", new ZoneMap("test"), 0) {
override def SetupNumberPools() = {}
GUID(guid)
}
val avatarProbe = new TestProbe(system)
zone.AvatarEvents = avatarProbe.ref
guid.register(player, number = 1)
guid.register(weapon, number = 2)
guid.register(weapon.AmmoSlot.Box, number = 3)
guid.register(terminal, number = 4)
val building = Building("test-building", 1, 1, zone, StructureType.Facility)
building.Invalidate()
guid.register(building, number = 6)
val buildingProbe = new TestProbe(system)
building.Actor = buildingProbe.ref
building.Zone = zone
terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
terminal.Owner = building
val wep_fmode = weapon.FireMode
val wep_prof = wep_fmode.Add
val proj = weapon.Projectile
val proj_prof = proj.asInstanceOf[DamageProfile]
val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
val resolved = DamageInteraction(
DamageResolution.Hit,
SourceEntry(terminal),
ProjectileReason(
DamageResolution.Hit,
projectile,
terminal.DamageModel
),
Vector3(1, 0, 0)
)
val applyDamageTo = resolved.calculate()
"AutoRepair" should {
"asks owning building for NTU after damage" in {
assert(terminal.Health == terminal.MaxHealth)
terminal.Actor ! Vitality.Damage(applyDamageTo)
avatarProbe.receiveOne(max = 200 milliseconds) //health update event
assert(terminal.Health < terminal.MaxHealth)
val buildingMsg = buildingProbe.receiveOne(max = 600 milliseconds)
assert(buildingMsg match {
case BuildingActor.Ntu(NtuCommand.Request(drain, _)) =>
drain == terminal.Definition.autoRepair.get.drain
case _ =>
false
})
}
}
}
class AutoRepairRequestNtuRepeatTest extends FreedContextActorTest {
ServiceManager.boot
val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
player.Spawn()
val weapon = new Tool(GlobalDefinitions.suppressor)
val terminal = new Terminal(AutoRepairTest.terminal_definition)
val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
val zone = new Zone("test", new ZoneMap("test"), 0) {
override def SetupNumberPools() = {}
GUID(guid)
}
val avatarProbe = new TestProbe(system)
zone.AvatarEvents = avatarProbe.ref
guid.register(player, number = 1)
guid.register(weapon, number = 2)
guid.register(weapon.AmmoSlot.Box, number = 3)
guid.register(terminal, number = 4)
val building = Building("test-building", 1, 1, zone, StructureType.Facility)
building.Invalidate()
guid.register(building, number = 6)
val buildingProbe = new TestProbe(system)
building.Actor = buildingProbe.ref
building.Zone = zone
terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
terminal.Owner = building
val wep_fmode = weapon.FireMode
val wep_prof = wep_fmode.Add
val proj = weapon.Projectile
val proj_prof = proj.asInstanceOf[DamageProfile]
val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
val resolved = DamageInteraction(
DamageResolution.Hit,
SourceEntry(terminal),
ProjectileReason(
DamageResolution.Hit,
projectile,
terminal.DamageModel
),
Vector3(1, 0, 0)
)
val applyDamageTo = resolved.calculate()
"AutoRepair" should {
"repeatedly asks owning building for NTU after damage" in {
assert(terminal.Health == terminal.MaxHealth)
terminal.Actor ! Vitality.Damage(applyDamageTo)
avatarProbe.receiveOne(max = 200 milliseconds) //health update event
assert(terminal.Health < terminal.MaxHealth)
(0 to 3).foreach { _ =>
val buildingMsg = buildingProbe.receiveOne(max = 1000 milliseconds)
assert(buildingMsg match {
case BuildingActor.Ntu(NtuCommand.Request(drain, _)) =>
drain == terminal.Definition.autoRepair.get.drain
case _ =>
false
})
}
}
}
}
class AutoRepairNoRequestNtuTest extends FreedContextActorTest {
ServiceManager.boot
val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
player.Spawn()
val weapon = new Tool(GlobalDefinitions.suppressor)
val terminal = new Terminal(AutoRepairTest.terminal_definition)
val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
val zone = new Zone("test", new ZoneMap("test"), 0) {
override def SetupNumberPools() = {}
GUID(guid)
}
val avatarProbe = new TestProbe(system)
zone.AvatarEvents = avatarProbe.ref
guid.register(player, number = 1)
guid.register(weapon, number = 2)
guid.register(weapon.AmmoSlot.Box, number = 3)
guid.register(terminal, number = 4)
val building = Building("test-building", 1, 1, zone, StructureType.Facility)
building.Invalidate()
guid.register(building, number = 6)
val buildingProbe = new TestProbe(system)
building.Actor = buildingProbe.ref
building.Zone = zone
terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
terminal.Owner = building
val wep_fmode = weapon.FireMode
val wep_prof = wep_fmode.Add
val proj = weapon.Projectile
val proj_prof = proj.asInstanceOf[DamageProfile]
val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
val resolved = DamageInteraction(
DamageResolution.Hit,
SourceEntry(terminal),
ProjectileReason(
DamageResolution.Hit,
projectile,
terminal.DamageModel
),
Vector3(1, 0, 0)
)
val applyDamageTo = resolved.calculate()
"AutoRepair" should {
"not ask for NTU after damage if it expects no NTU" in {
assert(terminal.Health == terminal.MaxHealth)
terminal.Actor ! BuildingActor.NtuDepleted()
terminal.Actor ! Vitality.Damage(applyDamageTo)
avatarProbe.receiveOne(max = 200 milliseconds) //health update event
assert(terminal.Health < terminal.MaxHealth)
buildingProbe.expectNoMessage(max = 2000 milliseconds)
}
}
}
class AutoRepairRestoreRequestNtuTest extends FreedContextActorTest {
ServiceManager.boot
val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
player.Spawn()
val weapon = new Tool(GlobalDefinitions.suppressor)
val terminal = new Terminal(AutoRepairTest.terminal_definition)
val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
val zone = new Zone("test", new ZoneMap("test"), 0) {
override def SetupNumberPools() = {}
GUID(guid)
}
val avatarProbe = new TestProbe(system)
zone.AvatarEvents = avatarProbe.ref
guid.register(player, number = 1)
guid.register(weapon, number = 2)
guid.register(weapon.AmmoSlot.Box, number = 3)
guid.register(terminal, number = 4)
val building = Building("test-building", 1, 1, zone, StructureType.Facility)
building.Invalidate()
guid.register(building, number = 6)
val buildingProbe = new TestProbe(system)
building.Actor = buildingProbe.ref
building.Zone = zone
terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
terminal.Owner = building
val wep_fmode = weapon.FireMode
val wep_prof = wep_fmode.Add
val proj = weapon.Projectile
val proj_prof = proj.asInstanceOf[DamageProfile]
val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
val resolved = DamageInteraction(
DamageResolution.Hit,
SourceEntry(terminal),
ProjectileReason(
DamageResolution.Hit,
projectile,
terminal.DamageModel
),
Vector3(1, 0, 0)
)
val applyDamageTo = resolved.calculate()
"AutoRepair" should {
"ask for NTU after damage if its expectation of NTU is restored" in {
assert(terminal.Health == terminal.MaxHealth)
terminal.Actor ! BuildingActor.NtuDepleted()
terminal.Actor ! Vitality.Damage(applyDamageTo)
avatarProbe.receiveOne(max = 200 milliseconds) //health update event
assert(terminal.Health < terminal.MaxHealth)
buildingProbe.expectNoMessage(max = 2000 milliseconds)
terminal.Actor ! BuildingActor.SuppliedWithNtu()
val buildingMsg = buildingProbe.receiveOne(max = 600 milliseconds)
assert(buildingMsg match {
case BuildingActor.Ntu(NtuCommand.Request(drain, _)) =>
drain == terminal.Definition.autoRepair.get.drain
case _ =>
false
})
}
}
}
class AutoRepairRepairWithNtuTest extends FreedContextActorTest {
ServiceManager.boot
val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
player.Spawn()
val weapon = new Tool(GlobalDefinitions.suppressor)
val terminal = new Terminal(AutoRepairTest.terminal_definition)
val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
val zone = new Zone("test", new ZoneMap("test"), 0) {
override def SetupNumberPools() = {}
GUID(guid)
}
val avatarProbe = new TestProbe(system)
zone.AvatarEvents = avatarProbe.ref
guid.register(player, number = 1)
guid.register(weapon, number = 2)
guid.register(weapon.AmmoSlot.Box, number = 3)
guid.register(terminal, number = 4)
val building = Building("test-building", 1, 1, zone, StructureType.Facility)
building.Invalidate()
guid.register(building, number = 6)
val buildingProbe = new TestProbe(system)
building.Actor = buildingProbe.ref
building.Zone = zone
terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
terminal.Owner = building
val wep_fmode = weapon.FireMode
val wep_prof = wep_fmode.Add
val proj = weapon.Projectile
val proj_prof = proj.asInstanceOf[DamageProfile]
val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
val resolved = DamageInteraction(
DamageResolution.Hit,
SourceEntry(terminal),
ProjectileReason(
DamageResolution.Hit,
projectile,
terminal.DamageModel
),
Vector3(1, 0, 0)
)
val applyDamageTo = resolved.calculate()
"AutoRepair" should {
"repair some of the damage when it receives NTU" in {
assert(terminal.Health == terminal.MaxHealth)
terminal.Actor ! BuildingActor.NtuDepleted() //don't worry about requests
terminal.Actor ! Vitality.Damage(applyDamageTo)
avatarProbe.receiveOne(max = 200 milliseconds) //health update event
assert(terminal.Health < terminal.MaxHealth)
val reducedHealth = terminal.Health
buildingProbe.expectNoMessage(max = 2000 milliseconds)
terminal.Actor ! NtuCommand.Grant(null, 1)
avatarProbe.receiveOne(max = 200 milliseconds) //health update event
assert(terminal.Health > reducedHealth)
}
}
}
class AutoRepairRepairWithNtuUntilDoneTest extends FreedContextActorTest {
ServiceManager.boot
val player = Player(Avatar(0, "TestCharacter", PlanetSideEmpire.TR, CharacterGender.Male, 0, CharacterVoice.Mute))
player.Spawn()
val weapon = new Tool(GlobalDefinitions.suppressor)
val terminal = new Terminal(AutoRepairTest.terminal_definition)
val guid = new NumberPoolHub(new MaxNumberSource(max = 10))
val zone = new Zone("test", new ZoneMap("test"), 0) {
override def SetupNumberPools() = {}
GUID(guid)
}
val avatarProbe = new TestProbe(system)
zone.AvatarEvents = avatarProbe.ref
guid.register(player, number = 1)
guid.register(weapon, number = 2)
guid.register(weapon.AmmoSlot.Box, number = 3)
guid.register(terminal, number = 4)
val building = Building("test-building", 1, 1, zone, StructureType.Facility)
building.Invalidate()
guid.register(building, number = 6)
val buildingProbe = new TestProbe(system)
building.Actor = buildingProbe.ref
building.Zone = zone
terminal.Actor = context.actorOf(Props(classOf[TerminalControl], terminal), name = "test-terminal")
terminal.Owner = building
val wep_fmode = weapon.FireMode
val wep_prof = wep_fmode.Add
val proj = weapon.Projectile
val proj_prof = proj.asInstanceOf[DamageProfile]
val projectile = Projectile(proj, weapon.Definition, wep_fmode, player, Vector3(2, 0, 0), Vector3.Zero)
val resolved = DamageInteraction(
DamageResolution.Hit,
SourceEntry(terminal),
ProjectileReason(
DamageResolution.Hit,
projectile,
terminal.DamageModel
),
Vector3(1, 0, 0)
)
val applyDamageTo = resolved.calculate()
"AutoRepair" should {
"ask for NTU after damage and repair some of the damage when it receives NTU, until fully-repaired" in {
assert(terminal.Health == terminal.MaxHealth)
terminal.Actor ! Vitality.Damage(applyDamageTo)
avatarProbe.receiveOne(max = 200 milliseconds) //health update event
assert(terminal.Health < terminal.MaxHealth)
var i = 0
while(terminal.Health < terminal.MaxHealth && i < 100) {
i += 1 //safety counter
val buildingMsg = buildingProbe.receiveOne(max = 1000 milliseconds)
buildingMsg match {
case BuildingActor.Ntu(NtuCommand.Request(_, _)) =>
terminal.Actor ! NtuCommand.Grant(null, 1)
case _ => ;
}
}
assert(terminal.Health == terminal.MaxHealth)
}
}
}
object AutoRepairTest {
val terminal_definition = new OrderTerminalDefinition(objId = 612) {
Name = "order_terminal"
MaxHealth = 500
Damageable = true
Repairable = true
autoRepair = AutoRepairStats(1, 500, 500, 1)
RepairIfDestroyed = true
}
}

View file

@ -276,9 +276,9 @@ class ResourceSiloControlUpdate1Test extends ActorTest {
val reply1 = zoneEvents.receiveOne(500 milliseconds)
val reply2 = buildingEvents.receiveOne(500 milliseconds)
assert(obj.NtuCapacitor == 305)
assert(obj.CapacitorDisplay == 4)
assert(obj.CapacitorDisplay == 3)
assert(reply1 match {
case AvatarServiceMessage("nowhere", AvatarAction.PlanetsideAttribute(PlanetSideGUID(1), 45, 4)) => true
case AvatarServiceMessage("nowhere", AvatarAction.PlanetsideAttribute(PlanetSideGUID(1), 45, 3)) => true
case _ => false
})
assert(reply2.isInstanceOf[BuildingActor.MapUpdate])
@ -321,7 +321,7 @@ class ResourceSiloControlUpdate2Test extends ActorTest {
val reply1 = zoneEvents.receiveOne(1000 milliseconds)
val reply2 = buildingEvents.receiveOne(1000 milliseconds)
assert(obj.NtuCapacitor == 205)
assert(obj.CapacitorDisplay == 3)
assert(obj.CapacitorDisplay == 2)
assert(reply1.isInstanceOf[AvatarServiceMessage])
assert(reply1.asInstanceOf[AvatarServiceMessage].forChannel == "nowhere")
assert(reply1.asInstanceOf[AvatarServiceMessage].actionMessage.isInstanceOf[AvatarAction.PlanetsideAttribute])
@ -344,7 +344,7 @@ class ResourceSiloControlUpdate2Test extends ActorTest {
.asInstanceOf[AvatarServiceMessage]
.actionMessage
.asInstanceOf[AvatarAction.PlanetsideAttribute]
.attribute_value == 3
.attribute_value == 2
)
assert(reply2.isInstanceOf[BuildingActor.MapUpdate])
@ -400,18 +400,16 @@ class ResourceSiloControlNoUpdateTest extends ActorTest {
obj.NtuCapacitor = 250
obj.LowNtuWarningOn = false
assert(obj.NtuCapacitor == 250)
assert(obj.CapacitorDisplay == 3)
assert(obj.CapacitorDisplay == 2)
assert(!obj.LowNtuWarningOn)
obj.Actor ! ResourceSilo.UpdateChargeLevel(50)
obj.Actor ! ResourceSilo.UpdateChargeLevel(49)
expectNoMessage(500 milliseconds)
zoneEvents.expectNoMessage(500 milliseconds)
buildingEvents.expectNoMessage(500 milliseconds)
assert(
obj.NtuCapacitor == 299 || obj.NtuCapacitor == 300
) // Just in case the capacitor level drops while waiting for the message check 299 & 300
assert(obj.CapacitorDisplay == 3)
assert(obj.CapacitorDisplay == 2)
assert(obj.NtuCapacitor < 300)
assert(!obj.LowNtuWarningOn)
buildingEvents.expectNoMessage(500 milliseconds)
}
}
}