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.
207 lines
5.6 KiB
207 lines
5.6 KiB
package wow.doge.mygame.state
|
|
|
|
import javax.script.ScriptEngine
|
|
|
|
import akka.actor.typed.ActorRef
|
|
import akka.actor.typed.Behavior
|
|
import akka.actor.typed.SpawnProtocol
|
|
import akka.actor.typed.scaladsl.AbstractBehavior
|
|
import akka.actor.typed.scaladsl.ActorContext
|
|
import akka.actor.typed.scaladsl.Behaviors
|
|
import ammonite.Main
|
|
import ammonite.main.Defaults
|
|
import ammonite.runtime.Storage.Folder
|
|
import ammonite.util.Res.Success
|
|
import com.jme3.app.state.AppState
|
|
|
|
class ScriptingEngineState(
|
|
sse: ScalaScriptingEngine,
|
|
kse: KotlinScriptingEngine
|
|
) extends MyBaseState {
|
|
|
|
// implicit val actorSystem =
|
|
// ActorSystem.create(MyActorSystem(), "rootActor")
|
|
// implicit val timeout: Timeout = Timeout(3.seconds)
|
|
// val scalaScriptActor: Future[ActorRef[ScalaScriptBehavior.Command]] =
|
|
// actorSystem.ask(
|
|
// SpawnProtocol.Spawn(
|
|
// ScalaScriptBehavior(sse.runner),
|
|
// name = "ScalaScriptCompilerActor",
|
|
// Props.empty,
|
|
// _
|
|
// )
|
|
// )
|
|
override def stop(): Unit = {}
|
|
|
|
// override protected def cleanup(app: Application): Unit = {
|
|
// // actorSystem.terminate()
|
|
// }
|
|
|
|
// override protected def initialize(app: Application): Unit = {
|
|
// super.initialize(app)
|
|
|
|
// }
|
|
override def init() = {
|
|
// Future {
|
|
// while (true) {
|
|
// // super.update(tpf)
|
|
// val (res, k) = sse.runner.runScript(
|
|
// // os.Path(getClass().getResource("/hello.sc").getPath),
|
|
// os.pwd / "src" / "main" / "resources" / "hello.sc",
|
|
// Seq.empty
|
|
// // Seq(("start", None))
|
|
// // Scripts.groupArgs(List(""))
|
|
// )
|
|
// val ms = res.map(_.asInstanceOf[GameScript])
|
|
// ms.map(_.start())
|
|
|
|
// val res2 = kse.engine.eval(
|
|
// os.read(os.pwd / "src" / "main" / "resources" / "hello.main.kts")
|
|
// )
|
|
// // val res2 = engine.eval(getClass().getResource("/hello.main.kts").getPath)
|
|
// // val invoker = engine.asInstanceOf[Invocable]
|
|
// // val scr = invoker.getInterface(res2, classOf[GameScript])
|
|
// val scr = res2.asInstanceOf[GameScript]
|
|
// scr.start()
|
|
// Thread.sleep(2000)
|
|
// }
|
|
// }
|
|
// Future {
|
|
// sse.runner
|
|
// .runScript(
|
|
// os.pwd / "src" / "main" / "resources" / "hello2.sc",
|
|
// Seq.empty
|
|
// )
|
|
// ._1
|
|
// .map(_.asInstanceOf[MyBaseState])
|
|
// .map(s => stateManager.attach(s))
|
|
|
|
// ()
|
|
|
|
// }
|
|
|
|
// val res = scalaScriptActor
|
|
// .map(
|
|
// _.ask(ref =>
|
|
// ScalaScriptBehavior.Compile(
|
|
// ref,
|
|
// os.pwd / "src" / "main" / "resources" / "hello2.sc"
|
|
// // os.Path(getClass().getResource("/hello2.sc").getPath)
|
|
// )
|
|
// )(Timeout(10.seconds), actorSystem.scheduler)
|
|
// )
|
|
// .flatten
|
|
|
|
// res.foreach(_ match {
|
|
// case AppStateResult(state) => {
|
|
// stateManager.attach(state)
|
|
// }
|
|
// case wow.doge.mygame.state.ScalaScriptBehavior.Error(reason) =>
|
|
// println("error")
|
|
// })
|
|
|
|
}
|
|
|
|
override def update(tpf: Float): Unit = {}
|
|
|
|
override protected def onEnable(): Unit = {}
|
|
|
|
override protected def onDisable(): Unit = {}
|
|
|
|
}
|
|
|
|
object MyActorSystem {
|
|
def apply(): Behavior[SpawnProtocol.Command] =
|
|
Behaviors.setup { context =>
|
|
// Start initial tasks
|
|
// context.spawn(...)
|
|
|
|
SpawnProtocol()
|
|
}
|
|
}
|
|
class ScalaScriptingEngine(
|
|
val runner: Main = ammonite
|
|
.Main(
|
|
// predefCode = """
|
|
// import coursierapi.MavenRepository
|
|
|
|
// interp.repositories.update(
|
|
// interp.repositories() ::: List(
|
|
// MavenRepository.of("file://home/rohan/.m2/repository")
|
|
// )
|
|
// )
|
|
|
|
// @
|
|
|
|
// """,
|
|
defaultPredef = false,
|
|
storageBackend = new Folder(Defaults.ammoniteHome, isRepl = false)
|
|
)
|
|
) {}
|
|
|
|
class KotlinScriptingEngine(val engine: ScriptEngine) {
|
|
// val manager = new ScriptEngineManager()
|
|
// val engine = manager.getEngineByExtension("main.kts")
|
|
}
|
|
|
|
object ScalaScriptBehavior {
|
|
sealed trait Result
|
|
final case class AppStateResult(state: AppState) extends Result
|
|
final case class Error(reason: String) extends Result
|
|
|
|
sealed trait Command
|
|
final case class Compile(sender: ActorRef[Result], path: os.Path)
|
|
extends Command
|
|
// final case class CompileScripts(sender: ActorRef[Result], paths: os.Path*)
|
|
// extends Command
|
|
def apply(
|
|
runner: Main = ammonite
|
|
.Main(
|
|
storageBackend = new Folder(
|
|
// os.pwd / "target"
|
|
Defaults.ammoniteHome,
|
|
isRepl = false
|
|
)
|
|
)
|
|
) =
|
|
Behaviors.setup(ctx => new ScalaScriptActor(runner, ctx))
|
|
private class ScalaScriptActor(
|
|
val runner: Main,
|
|
context: ActorContext[Command]
|
|
) extends AbstractBehavior[Command](context) {
|
|
|
|
override def onMessage(msg: Command): Behavior[Command] = {
|
|
msg match {
|
|
case Compile(sender, path) =>
|
|
context.log.debug(s"Received $path")
|
|
val res = getScript(path)
|
|
println(res)
|
|
sender ! res
|
|
Behaviors.same
|
|
// case CompileScripts(sender, paths) =>
|
|
}
|
|
}
|
|
|
|
def getScript(path: os.Path): Result = {
|
|
runner
|
|
.runScript(
|
|
path,
|
|
Seq.empty
|
|
)
|
|
._1 match {
|
|
case ammonite.util.Res.Exception(t, msg) => Error(msg)
|
|
|
|
case Success(obj) =>
|
|
obj match {
|
|
case s: MyBaseState => AppStateResult(s)
|
|
case _ => Error("Unknown script type")
|
|
// AppStateResult(s.asInstanceOf[AppState])
|
|
}
|
|
|
|
case _ => Error("Failed to run script")
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|