forked from nova/jmonkey-test
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.
190 lines
4.8 KiB
190 lines
4.8 KiB
package wow.doge.mygame.game
|
|
|
|
import akka.actor.typed.scaladsl.Behaviors
|
|
import wow.doge.mygame.state.PlayerMovementState
|
|
import com.jme3.scene.Geometry
|
|
|
|
import wow.doge.mygame.events.EventBus
|
|
import wow.doge.mygame.events.Events
|
|
import wow.doge.mygame.state.ImMovementActor
|
|
import com.jme3.scene.CameraNode
|
|
import com.jme3.scene.Node
|
|
import com.jme3.renderer.Camera
|
|
import wow.doge.mygame.executors.Schedulers
|
|
import wow.doge.mygame.game.nodes.PlayerNode
|
|
import com.softwaremill.macwire._
|
|
|
|
import wow.doge.mygame.implicits._
|
|
|
|
object GameAppActor {
|
|
import Methods._
|
|
|
|
sealed trait Command
|
|
case object XD extends Command
|
|
case object Stop extends Command
|
|
def apply(app: GameApp, schedulers: Schedulers) =
|
|
Behaviors.setup[Command] { ctx =>
|
|
ctx.log.info("Hello from GameAppActor")
|
|
// lazy val b = new Box(1, 1, 1)
|
|
// lazy val geom = new Geometry("Box", b)
|
|
// lazy val playerNode = new Node("PlayerNode")
|
|
// lazy val camNode = new CameraNode("CameraNode", app.getCamera())
|
|
// lazy val players = createPlayer(geom, app.getCamera())
|
|
|
|
// ctx.pipeToSelf(
|
|
// app.enqueueF(() => ())(monix.execution.Scheduler.io("aege"))
|
|
// ) {
|
|
// case x =>
|
|
// println("SENDEDEEEEEd")
|
|
// XD
|
|
// }
|
|
// ctx.pipeToSelf(
|
|
// createPlayer(
|
|
// geom,
|
|
// app.getCamera(),
|
|
// schedulers.jme
|
|
// )
|
|
// ) {
|
|
// case x =>
|
|
// println(x)
|
|
// XD
|
|
// }
|
|
val subscribingActor = ctx.spawn(SubscribingActor(), "subscriber-1")
|
|
|
|
val tickEventBus =
|
|
ctx.spawn(Behaviors.logMessages(EventBus[Events.Tick]()), "eventBus1")
|
|
|
|
tickEventBus ! EventBus.Subscribe(subscribingActor)
|
|
|
|
tickEventBus ! EventBus.Publish(Events.PhysicsTick, ctx.self)
|
|
|
|
// {
|
|
// app
|
|
// .getInputManager()
|
|
// .observableAction("Left")
|
|
// .map { action =>
|
|
// action.binding.name match {
|
|
// case "Left" => Task(println("Pressed left"))
|
|
// }
|
|
// }
|
|
// }
|
|
// binding match {
|
|
// case "Left" =>
|
|
|
|
def playerNodeFactory =
|
|
PlayerNode(
|
|
modelPath = os.rel / "Models" / "Jaime" / "Jaime.j3o",
|
|
cam = app.camera
|
|
) _
|
|
// (assetManager = app.assetManager)
|
|
{
|
|
lazy val playerNode = playerNodeFactory(app.assetManager)
|
|
|
|
lazy val actor = ctx.spawn(
|
|
ImMovementActor(ImMovementActor.Props(app, playerNode)),
|
|
"imMovementActor"
|
|
)
|
|
lazy val state = wire[PlayerMovementState]
|
|
app.stateManager.attach(state)
|
|
}
|
|
|
|
Thread.sleep(2000)
|
|
|
|
app
|
|
.getRootNode()
|
|
.depthFirst(s =>
|
|
// s match {
|
|
// case node: Node =>
|
|
// println("node" + s.getName() + " children " + node.getChildren())
|
|
// case g: Geometry => println(s.getName())
|
|
// }
|
|
println(s.getName())
|
|
)
|
|
|
|
println("----------------")
|
|
|
|
{
|
|
app
|
|
.getRootNode()
|
|
.observableDepthFirst()
|
|
.map(s => s.getName())
|
|
// .takeWhileInclusive(_.getName() != "level")
|
|
.onErrorHandle(e => e.getMessage())
|
|
.foreach(println)(schedulers.async)
|
|
|
|
}
|
|
|
|
println("----------------")
|
|
|
|
{
|
|
app
|
|
.getRootNode()
|
|
.observableBreadthFirst()
|
|
.map(s => s.getName())
|
|
// .takeWhileInclusive(_.getName() != "level")
|
|
.onErrorHandle(e => e.getMessage())
|
|
.foreach(println)(schedulers.async)
|
|
|
|
}
|
|
|
|
// app.start()
|
|
// Behaviors.same
|
|
Behaviors.receiveMessage { msg =>
|
|
msg match {
|
|
case XD =>
|
|
ctx.log.info("RECEEEEEIVED")
|
|
ctx.log.info(app.camera.toString())
|
|
Behaviors.same
|
|
case Stop =>
|
|
ctx.log.info("Received stop")
|
|
Behaviors.stopped
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
object Methods {
|
|
def createPlayer(
|
|
geom: Geometry,
|
|
cam: Camera
|
|
): Node = {
|
|
val playerNode = new Node("PlayerNode")
|
|
lazy val camNode = new CameraNode("CameraNode", cam)
|
|
playerNode
|
|
.child(camNode)
|
|
.child(geom)
|
|
playerNode
|
|
}
|
|
|
|
def old() = {
|
|
// val movementActor =
|
|
// ctx.spawn(
|
|
// MovementActor(MovementActor.Props(app, geom)),
|
|
// "movementActor"
|
|
// // DispatcherSelector.fromConfig("jme-dispatcher")
|
|
// )
|
|
|
|
// val movementActorTimer = ctx.spawn(
|
|
// MovementActorTimer(movementActor),
|
|
// "movementActorTimer"
|
|
// )
|
|
}
|
|
}
|
|
|
|
object SubscribingActor {
|
|
def apply() =
|
|
Behaviors.receive[Events.PhysicsTick.type] { (ctx, msg) =>
|
|
ctx.log.debug(s"received event $msg")
|
|
Behaviors.same
|
|
}
|
|
}
|
|
// new PlayerMovementState(
|
|
// // movementActor,
|
|
// // movementActorTimer,
|
|
// imMovementActor,
|
|
// // geom,
|
|
// // camNode,
|
|
// playerNode
|
|
// // ctx.self
|
|
// )
|