You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
115 lines
4.1 KiB
115 lines
4.1 KiB
package wow.doge.mygame.game.entities.player.behaviors
|
|
|
|
import scala.concurrent.Future
|
|
|
|
import akka.actor.typed.Behavior
|
|
import akka.actor.typed.PostStop
|
|
import akka.actor.typed.scaladsl.AskPattern._
|
|
import akka.actor.typed.scaladsl.Behaviors
|
|
import akka.util.Timeout
|
|
import cats.syntax.show._
|
|
import monix.bio.UIO
|
|
import monix.reactive.Observable
|
|
import wow.doge.mygame.game.entities.CharacterStats
|
|
import wow.doge.mygame.game.entities.StatsActor
|
|
import wow.doge.mygame.game.entities.character.CharacterStates._
|
|
import wow.doge.mygame.game.entities.player.PlayerActorSupervisor
|
|
import wow.doge.mygame.implicits._
|
|
import wow.doge.mygame.subsystems.movement.ImMovementActor
|
|
|
|
class IdleBehaviorFactory(
|
|
env: PlayerActorSupervisor.Env,
|
|
nextStateFn: AliveSubstate => Behavior[PlayerActorSupervisor.Command],
|
|
deadState: Behavior[PlayerActorSupervisor.Command],
|
|
consumptionMultiplier: Int => Int
|
|
)(implicit timeout: Timeout) {
|
|
import IdleBehaviorFactory.IdleBehavior
|
|
import env._
|
|
|
|
implicit val sched = ctx.system.scheduler
|
|
|
|
def behavior =
|
|
IdleBehavior(
|
|
Behaviors
|
|
.receiveMessage[PlayerActorSupervisor.Command] {
|
|
case PlayerActorSupervisor.MoveLeft(pressed) =>
|
|
children.movementActor ! ImMovementActor.MoveLeft(pressed)
|
|
if (pressed)
|
|
nextStateFn(AliveSubstate.Moving(Walking))
|
|
else nextStateFn(AliveSubstate.Idle)
|
|
case PlayerActorSupervisor.TakeDamage(value, replyTo) =>
|
|
implicit val ec = props.scheduler.value
|
|
for {
|
|
res <-
|
|
children.statsActor.ask(StatsActor.TakeDamageResult(value, _))
|
|
_ <- Future.successful(
|
|
ctx.self ! PlayerActorSupervisor.StatsResponse(res, replyTo)
|
|
)
|
|
} yield ()
|
|
Behaviors.same
|
|
case PlayerActorSupervisor.ConsumeStamina(value, replyTo) =>
|
|
implicit val ec = props.scheduler.value
|
|
val newValue =
|
|
CharacterStats.DamageStamina(consumptionMultiplier(value.toInt))
|
|
for {
|
|
response <- children.statsActor.ask(
|
|
StatsActor.ConsumeStaminaResult(newValue, _)
|
|
)
|
|
_ =
|
|
ctx.self ! PlayerActorSupervisor
|
|
.StatsResponse(response, replyTo)
|
|
} yield ()
|
|
Behaviors.same
|
|
case PlayerActorSupervisor.CurrentStats(replyTo) =>
|
|
children.statsActor ! StatsActor.CurrentStats(replyTo)
|
|
Behaviors.same
|
|
case PlayerActorSupervisor.Heal(value) =>
|
|
children.statsActor ! StatsActor.HealResult(value)
|
|
Behaviors.same
|
|
case PlayerActorSupervisor.GetStatus(replyTo) =>
|
|
replyTo ! PlayerActorSupervisor.Status.Alive
|
|
Behaviors.same
|
|
case PlayerActorSupervisor.GetStatsObservable(replyTo) =>
|
|
import monix.{eval => me}
|
|
replyTo !
|
|
UIO(
|
|
Observable
|
|
.repeatEvalF(
|
|
me.Task.deferFuture(props.statsQueue.poll())
|
|
)
|
|
.publish(props.fxScheduler.value)
|
|
.refCount
|
|
)
|
|
|
|
Behaviors.same
|
|
case PlayerActorSupervisor.StatsResponse(response, replyTo) =>
|
|
response match {
|
|
case (dead, stats) =>
|
|
if (dead) ctx.self ! PlayerActorSupervisor.Die
|
|
props.statsQueue
|
|
.offer(stats)
|
|
.foreach { _ =>
|
|
pprint.log(show"Published stats $stats")
|
|
replyTo ! ()
|
|
}(props.scheduler.value)
|
|
}
|
|
Behaviors.same
|
|
// nextStateFn(InCombat(Moving(Walking)))
|
|
case PlayerActorSupervisor.Die => deadState
|
|
case PlayerActorSupervisor.LogError(ex) =>
|
|
ctx.log.error(ex.getMessage)
|
|
Behaviors.same
|
|
}
|
|
.receiveSignal {
|
|
case (_, PostStop) =>
|
|
ctx.log.infoP("stopped")
|
|
Behaviors.same
|
|
}
|
|
)
|
|
}
|
|
|
|
object IdleBehaviorFactory {
|
|
final case class IdleBehavior(
|
|
value: Behavior[PlayerActorSupervisor.Command]
|
|
)
|
|
}
|