PSForever/PSF-BotServer
1
0
Fork 0
mirror of https://github.com/2revoemag/PSF-BotServer.git synced 2026-01-20 02:24:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

hack testing; RepairMessage is suitable for a progress bar for now but it needs replacing with the correct operation and the last part feels wrong

Browse source
This commit is contained in:
FateJH 2017-10-03 20:32:21 -04:00
parent 7fcac7fc25
commit 249eb96cc5
2 changed files with 72 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
common/src/main/scala/net/psforever/objects/doors/DoorCloseControl.scala
View file

@ -3,29 +3,58 @@ package net.psforever.objects.doors
import akka.actor.{Actor, ActorRef, Cancellable}
import net.psforever.packet.game.PlanetSideGUID
import scala.concurrent.duration._
import scala.collection.mutable.ListBuffer
import scala.annotation.tailrec
class DoorCloseControl(implicit val environment : ActorRef) extends Actor {
import DoorCloseControl._
private var doorCloser : Cancellable = DefaultCloser
private var doorCloserTrigger : Cancellable = DefaultCloser
private var openDoors : List[DoorEntry] = Nil
def receive : Receive = {
case DoorIsOpen(guid, time) =>
if(openDoors.isEmpty) {
//doorCloser = context.system.scheduler.scheduleOnce(timeout, environment, Door.DoorMessage())
openDoors = openDoors :+ DoorEntry(guid, time)
if(doorCloserTrigger.isCancelled) {
import scala.concurrent.ExecutionContext.Implicits.global
doorCloserTrigger = context.system.scheduler.scheduleOnce(timeout, self, DoorCloseControl.CloseTheDoor())
}
else {
openDoors = openDoors :+ DoorEntry(guid, time)
case CloseTheDoor() =>
doorCloserTrigger.cancel
val now : Long = System.nanoTime
recursiveCloseDoors(openDoors.iterator, now) match {
case entry :: rest =>
openDoors = entry :: rest
import scala.concurrent.ExecutionContext.Implicits.global
doorCloserTrigger = context.system.scheduler.scheduleOnce((now - entry.opened_at_time + timeout_time)*1000 milliseconds, self, DoorCloseControl.CloseTheDoor())
case Nil =>
openDoors = Nil
}
case _ => ;
}
@tailrec private def recursiveCloseDoors(iter : Iterator[DoorEntry], now : Long) : List[DoorEntry] = {
if(!iter.hasNext) {
Nil
}
else {
val entry = iter.next
if(now - entry.opened_at_time < timeout_time) {
entry +: iter.toList
}
else {
//TODO close this door entry
recursiveCloseDoors(iter, now)
}
}
}
}
object DoorCloseControl {
private final val timeout : Long = 5000L
private final val timeout_time = 5000
private final val timeout : FiniteDuration = timeout_time milliseconds
private final val DefaultCloser : Cancellable = new Cancellable() {
override def cancel : Boolean = true
@ -36,5 +65,5 @@ object DoorCloseControl {
final case class DoorIsOpen(door_guid : PlanetSideGUID, opened_at_time : Long = System.nanoTime())
final case class CloseTheDoor(door_guid : PlanetSideGUID)
private final case class CloseTheDoor()
}

35
pslogin/src/main/scala/WorldSessionActor.scala
View file

@ -37,8 +37,10 @@ class WorldSessionActor extends Actor with MDCContextAware {
var taskResolver : ActorRef = Actor.noSender
var galaxy : ActorRef = Actor.noSender
var continent : Zone = null
var progressBarValue : Option[Float] = None
var clientKeepAlive : Cancellable = WorldSessionActor.DefaultCancellable
var progressBarUpdate : Cancellable = WorldSessionActor.DefaultCancellable
override def postStop() = {
if(clientKeepAlive != null)
@ -547,6 +549,25 @@ class WorldSessionActor extends Actor with MDCContextAware {
continent.Actor ! Zone.DropItemOnGround(item, item.Position, item.Orientation) //restore
}
case ItemHacking(tplayer, target, tool_guid, delta) =>
progressBarUpdate.cancel
if(progressBarValue.isDefined) {
val progressBarVal : Float = progressBarValue.get + delta
sendResponse(PacketCoding.CreateGamePacket(0, RepairMessage(target.GUID, progressBarVal.toInt)))
if(progressBarVal > 100) {
progressBarValue = None
log.info(s"We've hacked the item $target! Now what?")
sendResponse(PacketCoding.CreateGamePacket(0, ChangeFireStateMessage_Stop(tool_guid)))
//TODO now what?
}
else {
progressBarValue = Some(progressBarVal)
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
progressBarUpdate = context.system.scheduler.scheduleOnce(250 milliseconds, self, ItemHacking(tplayer, target, tool_guid, delta))
}
}
case ResponseToSelf(pkt) =>
log.info(s"Received a direct message: $pkt")
sendResponse(pkt)
@ -791,6 +812,7 @@ class WorldSessionActor extends Actor with MDCContextAware {
case msg @ ChangeFireStateMessage_Stop(item_guid) =>
log.info("ChangeFireState_Stop: " + msg)
progressBarUpdate.cancel
case msg @ EmoteMsg(avatar_guid, emote) =>
log.info("Emote: " + msg)
@ -979,6 +1001,18 @@ class WorldSessionActor extends Actor with MDCContextAware {
door.Actor ! Door.Use(player, msg) //let door open freely
}
case Some(panel : IFFLock) =>
player.Slot(player.DrawnSlot).Equipment match {
case Some(tool : SimpleItem) =>
if(tool.Definition == GlobalDefinitions.remote_electronics_kit) {
progressBarValue = Some(-2.66f)
self ! WorldSessionActor.ItemHacking(player, panel, tool.GUID, 2.66f)
}
case _ => ;
}
log.info("Hacking a door~")
//TODO get player hack level (for now, presume 15s in internals of 4/s)
case Some(obj : PlanetSideGameObject) =>
if(itemType != 121) {
sendResponse(PacketCoding.CreateGamePacket(0, UseItemMessage(avatar_guid, unk1, object_guid, unk2, unk3, unk4, unk5, unk6, unk7, unk8, itemType)))
@ -1569,6 +1603,7 @@ object WorldSessionActor {
private final case class PlayerFailedToLoad(tplayer : Player)
private final case class ListAccountCharacters()
private final case class SetCurrentAvatar(tplayer : Player)
private final case class ItemHacking(tplayer : Player, target : PlanetSideGameObject, tool_guid : PlanetSideGUID, delta : Float)
/**
* A placeholder `Cancellable` object.