jmonkey-test/src/main/scala/wow/doge/mygame/game/GameModule.scala

package wow.doge.mygame.game

import cats.effect.Resource
import com.jme3.system.AppSettings
import monix.bio.Task
import io.odin.Logger
import akka.actor.typed.ActorRef
import akka.actor.typed.SpawnProtocol
import wow.doge.mygame.game.subsystems.input.GameInputHandler
import monix.bio.IO
import monix.bio.Fiber
import monix.execution.Scheduler
import com.jme3.app.StatsAppState
import wow.doge.mygame.executors.Schedulers
class GameAppResource(
    logger: Logger[Task],
    jmeScheduler: Scheduler,
    schedulers: Schedulers
) {
  def get: Resource[Task, (GameApp, Fiber[Throwable, Unit])] =
    Resource.make(
      for {
        _ <- logger.info("Creating game app")
        app <- Task(new GameApp(schedulers, new StatsAppState()))
        _ <- Task {
          val settings = new AppSettings(true)
          settings.setVSync(true)
          settings.setUseInput(true)
          // new FlyCamAppState
          // settings.setFrameRate(250)
          app.setSettings(settings)
          // JMERunner.runner = app
          app
        }
        fib <- Task(app.start()).executeOn(jmeScheduler).start
      } yield (app -> fib)
    )(logger.info("Closing game app") >> _._2.cancel)
}

trait GameModule {

  def gameAppResource(
      logger: Logger[Task],
      jmeScheduler: Scheduler,
      schedulers: Schedulers
  ): Resource[Task, (GameApp, Fiber[Throwable, Unit])] =
    Resource.make(
      (for {
        _ <- logger.info("Creating game app")
        app <- Task(new GameApp(schedulers))
        _ <- Task {
          val settings = new AppSettings(true)
          settings.setVSync(true)
          // settings.setFrameRate(250)
          app.setSettings(settings)
          // JMERunner.runner = app
          app
        }
        fib <- Task(app.start()).executeOn(jmeScheduler).start
      } yield (app -> fib))
    )(_._2.cancel)

  def inputHandlerSystemResource(
      props: GameInputHandler.Props
  ): Resource[Task, Task[Unit]] =
    Resource.liftF {
      Task.evalAsync(props.begin)
    }
  def gameSystemsResource(
      spawnProtocol: ActorRef[SpawnProtocol.Command],
      gameSystems: Task[Unit]*
  ): Resource[Task, List[Unit]] =
    Resource.liftF(IO.defer(Task.parSequence(gameSystems)))
}