jmonkey-test/src/main/scala/wow/doge/mygame/game/entities/player/PlayerController.scala

package wow.doge.mygame.game.entities

import akka.actor.typed.ActorRef
import akka.actor.typed.Scheduler
import akka.actor.typed.SpawnProtocol
import akka.util.Timeout
import com.jme3.bullet.BulletAppState
import com.jme3.bullet.control.BetterCharacterControl
import com.jme3.math.FastMath
import com.jme3.renderer.Camera
import com.jme3.scene.CameraNode
import com.jme3.scene.Geometry
import com.jme3.scene.Node
import com.jme3.scene.Spatial
import com.jme3.scene.shape.Box
import com.softwaremill.tagging._
import io.odin.Logger
import monix.bio.IO
import monix.bio.Task
import wow.doge.mygame.AppError
import wow.doge.mygame.game.GameAppTags
import wow.doge.mygame.game.SimpleAppExt
import wow.doge.mygame.implicits._
import wow.doge.mygame.math.ImVector3f
import wow.doge.mygame.subsystems.events.EventsModule.GameEventBus
import wow.doge.mygame.subsystems.events.PlayerEvent
import wow.doge.mygame.subsystems.events.TickEvent
import wow.doge.mygame.subsystems.movement.ImMovementActor
import wow.doge.mygame.utils.AkkaUtils
import wow.doge.mygame.utils.wrappers.jme._
object PlayerControllerTags {
  sealed trait PlayerTag
  sealed trait PlayerCameraNode
  sealed trait PlayerCameraPivotNode
}

object PlayerController {
  sealed trait Error
  case class CouldNotCreatePlayerModel(reason: AssetManager.Error) extends Error

  class Props(
      enqueueR: Function1[() => Unit, Unit],
      rootNode: AppNode2 @@ GameAppTags.RootNode,
      loggerL: Logger[Task],
      // physicsSpace: com.jme3.bullet.PhysicsSpace,
      physicsSpace: PhysicsSpace,
      initialPlayerPos: ImVector3f = ImVector3f.Zero,
      playerEventBus: GameEventBus[PlayerEvent],
      playerPhysicsControl: BetterCharacterControl,
      // appScheduler: monix.execution.Scheduler,
      playerNode: Node @@ PlayerControllerTags.PlayerTag,
      cameraNode: CameraNode @@ PlayerControllerTags.PlayerCameraNode,
      cameraPivotNode: Node @@ PlayerControllerTags.PlayerCameraPivotNode,
      tickEventBus: GameEventBus[TickEvent],
      camera: Camera
  )(implicit
      spawnProtocol: ActorRef[SpawnProtocol.Command],
      timeout: Timeout,
      scheduler: Scheduler
  ) {
    val playerActorBehavior = {
      val movementActorBeh = new ImMovementActor.Props(
        enqueueR,
        camera
      ).behavior(playerPhysicsControl)
      val cameraActorBeh = new PlayerCameraActor.Props(
        cameraPivotNode,
        enqueueR,
        playerNode.getWorldTranslation _
      ).behavior
      new PlayerActorSupervisor.Props(
        playerEventBus,
        tickEventBus,
        movementActorBeh,
        cameraActorBeh
      ).behavior
    }
    val create: IO[AppError, ActorRef[PlayerActorSupervisor.Command]] =
      (for {
        playerActor <-
          AkkaUtils.spawnActorL(playerActorBehavior, "playerActorSupervisor")
        _ <- (for {
            _ <- rootNode += playerNode
            _ <- physicsSpace += playerNode
            _ <- physicsSpace += playerPhysicsControl
            _ = cameraPivotNode += cameraNode
            _ <- rootNode += cameraPivotNode
          } yield ()).mapError(AppError.AppNodeError)
      } yield playerActor)

  }

  def apply(
      app: SimpleAppExt,
      modelPath: os.RelPath,
      cam: Camera
  )(assetManager: AssetManager, bulletAppState: BulletAppState) = {
    val playerPos = ImVector3f.Zero
    val playerPhysicsControl = new BetterCharacterControl(1.5f, 6f, 1f)
      .withJumpForce(ImVector3f(0, 5f, 0))
    val playerNode = new Node("PlayerNode")
      .withChildren(
        assetManager
          .loadModel(modelPath)
          .asInstanceOf[Node]
          .withRotate(0, FastMath.PI, 0)
      )
      .withLocalTranslation(playerPos)
      .withControl(playerPhysicsControl)

    {
      bulletAppState.physicsSpace += playerNode
      bulletAppState.physicsSpace += playerPhysicsControl
    }

    {
      app.rootNode += playerNode
    }

    playerPhysicsControl
  }

  object Defaults {
    def defaultMesh = {
      val b = Box(1, 1, 1)
      val geom = Geometry("playerGeom", b)
      geom
    }
    // def defaultTexture(assetManager: AssetManager) =
    //   MyMaterial(
    //     assetManager = assetManager,
    //     path = os.rel / "Common" / "MatDefs" / "Misc" / "Unshaded.j3md"
    //   )

    //  new CameraControl(cam) {
    //     override def controlUpdate(tpf: Float) = {
    //       this.getCamera().setRotation(spatial.getWorldRotation())
    //       cameraPivotNode.setLocalTranslation(
    //         playerNode.getWorldTranslation()
    //       )
    //       this.getCamera().setLocation(spatial.getWorldTranslation())
    //     }
    //   }

    def defaultCamerNode(
        cam: Camera,
        // playerNode: Node,
        // cameraPivotNode: Node,
        playerPos: ImVector3f
    ) =
      new CameraNode("CameraNode", cam)
        // .withControlDir(ControlDirection.SpatialToCamera)
        .withLocalTranslation(ImVector3f(0, 1.5f, 10))
        .withLookAt(playerPos, ImVector3f.UnitY)

    def defaultPlayerNode(
        playerPos: ImVector3f,
        playerModel: Node,
        // camNode: CameraNode,
        playerPhysicsControl: BetterCharacterControl
    ) =
      Node("PlayerNode")
        .withChildren(playerModel)
        .withLocalTranslation(playerPos)
        .withControl(playerPhysicsControl)
        .taggedWith[PlayerControllerTags.PlayerTag]

    def defaultNpcNode(
        // assetManager: AssetManager,
        npcModel: Spatial,
        initialPos: ImVector3f,
        npcPhysicsControl: BetterCharacterControl,
        npcName: String
    ) =
      // Either
      //   .catchNonFatal(
      Node(npcName)
        .withChildren(
          // defaultMesh.withMaterial(defaultTexture(assetManager))
          npcModel
        )
        .withLocalTranslation(initialPos)
        .withControl(npcPhysicsControl)
    // )

    def defaultPlayerPhysicsControl =
      new BetterCharacterControl(1.5f, 6f, 1f)
        .withJumpForce(ImVector3f(0, 5f, 0))
  }
}