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.
175 lines
5.5 KiB
175 lines
5.5 KiB
package wow.doge.mygame
|
|
|
|
import com.jme3.app.SimpleApplication
|
|
import com.jme3.app.state.AppStateManager
|
|
import scala.reflect.ClassTag
|
|
import com.jme3.app.state.AppState
|
|
import com.jme3.scene.Node
|
|
import com.jme3.scene.Spatial
|
|
import com.simsilica.es.EntityData
|
|
import com.simsilica.es.EntityComponent
|
|
import com.simsilica.es.EntityId
|
|
import akka.actor.typed.ActorRef
|
|
import akka.util.Timeout
|
|
import akka.actor.typed.Scheduler
|
|
import monix.eval.Task
|
|
import com.jme3.input.InputManager
|
|
import com.jme3.input.controls.Trigger
|
|
import com.jme3.input.controls.InputListener
|
|
import com.jme3.math.Vector3f
|
|
import wow.doge.mygame.math.ImVector3f
|
|
import com.jme3.scene.Geometry
|
|
import wow.doge.mygame.state.CardinalDirection
|
|
import wow.doge.mygame.state.CanMove
|
|
import com.jme3.renderer.Camera
|
|
|
|
package object implicits {
|
|
implicit class StateManagerExt(val sm: AppStateManager) extends AnyVal {
|
|
def state[S <: AppState]()(implicit c: ClassTag[S]): S =
|
|
sm.getState(c.runtimeClass.asInstanceOf[Class[S]])
|
|
|
|
}
|
|
|
|
implicit class SimpleApplicationExt(val sa: SimpleApplication)
|
|
extends AnyVal {
|
|
def stateManager() = sa.getStateManager()
|
|
}
|
|
|
|
implicit class NodeExt(val n: Node) extends AnyVal {
|
|
def child(s: Spatial): Node = {
|
|
n.attachChild(s)
|
|
n
|
|
}
|
|
}
|
|
|
|
implicit class EntityDataExt(val ed: EntityData) extends AnyVal {
|
|
|
|
def query = new EntityQuery(ed)
|
|
|
|
// def entities[T <: EntityComponent](entities: Seq[T])
|
|
}
|
|
|
|
implicit class EntityExt(val e: EntityId) extends AnyVal {
|
|
def withComponents(classes: EntityComponent*)(implicit
|
|
ed: EntityData
|
|
): EntityId = {
|
|
ed.setComponents(e, classes: _*)
|
|
e
|
|
}
|
|
}
|
|
|
|
implicit class ActorRefExt[Req](val a: ActorRef[Req]) extends AnyVal {
|
|
import akka.actor.typed.scaladsl.AskPattern._
|
|
def askT[Res](
|
|
replyTo: ActorRef[Res] => Req
|
|
)(implicit timeout: Timeout, scheduler: Scheduler): Task[Res] = {
|
|
Task.deferFuture(a.ask(replyTo)(timeout, scheduler))
|
|
}
|
|
}
|
|
// def ?[Res](replyTo: ActorRef[Res] => Req)(implicit timeout: Timeout, scheduler: Scheduler): Future[Res] = {
|
|
// ask(replyTo)(timeout, scheduler)
|
|
// }
|
|
|
|
implicit class InputManagerExt(val inputManager: InputManager)
|
|
extends AnyVal {
|
|
def withMapping(mapping: String, triggers: Trigger*): InputManager = {
|
|
inputManager.addMapping(mapping, triggers: _*)
|
|
inputManager
|
|
}
|
|
|
|
def withListener(listener: InputListener, mappings: String*) = {
|
|
inputManager.addListener(listener, mappings: _*)
|
|
inputManager
|
|
}
|
|
}
|
|
|
|
implicit class Vector3fExt(val v: Vector3f) extends AnyVal {
|
|
def +=(that: Vector3f) = v.addLocal(that)
|
|
def *=(that: Vector3f) = v.multLocal(that)
|
|
def -=(that: Vector3f) = v.subtractLocal(that)
|
|
def /=(that: Vector3f) = v.divideLocal(that)
|
|
def unary_- = v.negateLocal()
|
|
def immutable = ImVector3f(v.x, v.y, v.z)
|
|
}
|
|
|
|
implicit class ImVector3fExt(val v: ImVector3f) extends AnyVal {
|
|
def +(that: ImVector3f) = v.copy(v.x + that.x, v.y + that.y, v.z + that.z)
|
|
def *(that: ImVector3f) = v.copy(v.x * that.x, v.y * that.y, v.z * that.z)
|
|
def *(f: Float): ImVector3f =
|
|
// v.copy(v.x * f, v.y * f, v.x * f)
|
|
v * ImVector3f(f, f, f)
|
|
def -(that: ImVector3f) = v.copy(v.x - that.x, v.y - that.y, v.z - that.z)
|
|
def /(that: ImVector3f) = v.copy(v.x / that.x, v.y / that.y, v.z / that.z)
|
|
def unary_- = v.copy(-v.x, -v.y, -v.z)
|
|
// def unary_-(that: ImVector3f) = this.copy(this.x, this.y, this.z)
|
|
def mutable = new Vector3f(v.x, v.y, v.z)
|
|
}
|
|
|
|
// implicit val implVector3fForVector3 = new Vector3[Vector3f] {
|
|
// override def +(implicit v: Vector3f, that: com.jme3.math.Vector3f): Unit =
|
|
// v += that
|
|
|
|
// override def *(implicit v: Vector3f, that: Vector3f): Unit = v *= that
|
|
|
|
// override def -(implicit v: Vector3f, that: Vector3f): Unit = v -= that
|
|
|
|
// override def /(implicit v: Vector3f, that: Vector3f): Unit = v /= that
|
|
|
|
// }
|
|
|
|
// implicit val implImVector3fForVector3 = new Vector3[ImVector3f] {
|
|
// override def +(implicit v: ImVector3f, that: ImVector3f): Unit =
|
|
// v + that
|
|
|
|
// override def *(implicit v: ImVector3f, that: ImVector3f): Unit = v * that
|
|
|
|
// override def -(implicit v: ImVector3f, that: ImVector3f): Unit = v - that
|
|
|
|
// override def /(implicit v: ImVector3f, that: ImVector3f): Unit = v / that
|
|
|
|
// }
|
|
|
|
// def test[T](v: T)(implicit ev: Vector3[T]) = {
|
|
// import ev._
|
|
// ev.+
|
|
// }
|
|
|
|
implicit val implCanMoveForGeom = new CanMove[Geometry] {
|
|
override def getDirection(
|
|
cam: Camera,
|
|
cardinalDir: CardinalDirection
|
|
): ImVector3f = {
|
|
val camDir =
|
|
cam.getDirection().immutable * 0.6f
|
|
val camLeft = cam.getLeft().immutable * 0.4f
|
|
|
|
val zero = ImVector3f.ZERO
|
|
val dir = cardinalDir
|
|
val walkDir = {
|
|
val mutWalkDir = new Vector3f()
|
|
if (dir.left) {
|
|
// ctx.log.trace("left")
|
|
mutWalkDir += (zero + camLeft).mutable
|
|
}
|
|
if (dir.right) {
|
|
// ctx.log.trace("right")
|
|
mutWalkDir += (zero + -camLeft).mutable
|
|
}
|
|
if (dir.up) {
|
|
// ctx.log.trace("up")
|
|
mutWalkDir += (zero + camDir).mutable
|
|
}
|
|
if (dir.down) {
|
|
// ctx.log.trace("down")
|
|
mutWalkDir += (zero + -camDir).mutable
|
|
}
|
|
mutWalkDir.immutable
|
|
}
|
|
walkDir
|
|
}
|
|
override def move(geom: Geometry, direction: ImVector3f): Unit = {
|
|
val v = geom.getLocalTranslation()
|
|
geom.setLocalTranslation(v += direction.mutable)
|
|
}
|
|
}
|
|
}
|