More refactoring ahead of split into multiple modules

Author: scalatron

Scalatron/src/scalatron/botwar/AugmentedDynamics.scala

@@ -20,7 +20,9 @@ case object AugmentedDynamics extends ((State,Random,Iterable[(Entity.Id,Iterabl
             // inform the plug-ins that the game is over
             masterBots.foreach(bot => try {
                 bot.variety match {
-                    case player: Bot.Player => player.controlFunction(Protocol.ServerOpcode.Goodbye + "(energy=" + bot.energy + ")")
+                    case player: Bot.Player =>
+                        // TODO: isolate this into the untrusted execution context
+                        player.entityController.respond(Protocol.ServerOpcode.Goodbye + "(energy=" + bot.energy + ")")
                     case _ => throw new IllegalStateException("expected master bot")
                 }
             } catch {
@@ -240,7 +242,7 @@ case object AugmentedDynamics extends ((State,Random,Iterable[(Entity.Id,Iterabl
                                 .updated(Protocol.PropertyName.Debug, logMessage + "\n" + disable.text)
                             val updatedVariety =
                                 thisPlayer.copy(
-                                controlFunction = (in: String) => "Log(text=" + logMessage + ")", // make sure it's never called again (but note that sibling minibots/bots use their own ref)
+                                entityController = thisPlayer.entityController.withReplacedControlFunction( (in: String) => "Log(text=" + logMessage + ")"), // make sure it's never called again (but note that sibling minibots/bots use their own ref)
                                 stateMap = updatedStateMap)
                             val updatedThisBot = thisBot.updateVariety(updatedVariety)
                             updatedBoard = updatedBoard.updateBot(updatedThisBot)
@@ -397,7 +399,7 @@ case object AugmentedDynamics extends ((State,Random,Iterable[(Entity.Id,Iterabl
                                 bonk()
                             } else {
                                 // master on slave
-                                if(movingPlayer.plugin == steppedOnPlayer.plugin) {
+                                if(movingPlayer.entityController == steppedOnPlayer.entityController) {
                                     // master on own slave -- re-absorb
                                     updatedBoard = updatedBoard.removeBot(steppedOnBot.id)
                                     val energyDelta = steppedOnBot.energy
@@ -415,7 +417,7 @@ case object AugmentedDynamics extends ((State,Random,Iterable[(Entity.Id,Iterabl
                         } else {
                             if(steppedOnPlayer.isMaster) {
                                 // slave on master -- always disappears
-                                if(movingPlayer.plugin == steppedOnPlayer.plugin) {
+                                if(movingPlayer.entityController == steppedOnPlayer.entityController) {
                                     // slave on own master -- gets re-absorbed
                                     updatedBoard = updatedBoard.removeBot(movingBot.id)
                                     val energyDelta = movingBot.energy

Scalatron/src/scalatron/botwar/Board.scala

@@ -3,7 +3,7 @@
   */
 package scalatron.botwar
 
-import scalatron.core.{Simulation, Plugin}
+import scalatron.core.{Simulation, EntityController}
 import Simulation.Time
 import scala.util.Random
 import BoardParams.Perimeter
@@ -88,10 +88,10 @@ case class Board(
     def addBot(pos: XY, extent: XY, creationTime: Time, energy: Int, variety: Bot.Variety) : Board =
         copy(nextId = nextId + 1, bots = bots.updated(nextId, Bot(nextId, pos, extent, creationTime, Time.SomtimeInThePast, energy, variety)))
 
-    def addBotThatIsMaster(pos: XY, creationTime: Time, controlFunction: (String => String), plugin: Plugin) : Board =
+    def addBotThatIsMaster(pos: XY, creationTime: Time, entityController: EntityController) : Board =
         copy(nextId = nextId + 1, bots = bots.updated(nextId,
             Bot(nextId, pos, XY.One, creationTime, Time.SomtimeInThePast, Constants.Energy.Initial,
-                Bot.Player(controlFunction, plugin, Bot.MasterGeneration, nextId, (0,2), 0L, "", Iterable.empty, Map(Protocol.PropertyName.Name -> plugin.name))
+                Bot.Player(entityController, Bot.MasterGeneration, nextId, (0,2), 0L, "", Iterable.empty, Map(Protocol.PropertyName.Name -> entityController.name))
         )))
 
     def sprinkle(count: Int, rnd: Random, creationTime: Time, boardSize: XY, variety: Bot.Variety) =
@@ -156,7 +156,8 @@ object Board
         time: Time,
         stepsPerRound: Int,
         roundIndex: Int,
-        randomSeed: Int, combinedPlugins: Iterable[Plugin]
+        randomSeed: Int,
+        entityControllers: Iterable[EntityController]
     )(
         implicit executionContextForUntrustedCode: ExecutionContext
     )
@@ -169,47 +170,37 @@ object Board
         updatedBoard = spawnPerimeterWalls(boardParams.perimeter, updatedBoard, time, boardSize)
         updatedBoard = spawnRandomWalls(rnd, updatedBoard, time, boardSize, boardParams.wallCount)
 
-
-
-        // generate players' control functions -- use Akka to work this out
+        // initialize the entity controllers' control functions -- use Akka to work this out
         // isolate the control function factory invocation via the untrusted thread pool
-        val future = Future.traverse(combinedPlugins)(plugin => Future {
-            // initialize plugins
+        val future = Future.traverse(entityControllers)(entityController => Future {
             try {
-                val controlFunction = plugin.controlFunctionFactory.apply()
-
                 // invoke Welcome()
-                controlFunction(
+                entityController.respond(
                     Protocol.ServerOpcode.Welcome + "(" +
-                        "name=" + plugin.name + "," +
+                        "name=" + entityController.name + "," +
                         "apocalypse=" + stepsPerRound + "," +
                         "round=" + roundIndex +
                         ")")
-
-                Some((plugin, controlFunction))
             } catch {
                 case t: Throwable =>
-                    System.err.println("error: exception while instantiating control function of plugin '" + plugin.name + "': " + t)
+                    System.err.println("error: exception while instantiating control function of plugin '" + entityController.name + "': " + t)
                     None
             }
         })
 
         // Note: an overall timeout across all bots is a temporary solution - we want timeouts PER BOT
-        val pluginsAndControlFunctions =
-            try {
-                val result = Await.result(future, 2000 millis)      // generous timeout - note that this is over ALL plug-ins
-                result.flatten     // remove failed instantiations
-            } catch {
-                case t: TimeoutException =>
-                    System.err.println("warning: timeout while instantiating control function of one of the plugins")
-                    Iterable.empty          // temporary - disables ALL bots, which is not the intention
-            }
-
+        try {
+            Await.result(future, 2000 millis)      // generous timeout - note that this is over ALL plug-ins
+        } catch {
+            case t: TimeoutException =>
+                System.err.println("warning: timeout while instantiating control function of one of the plugins")
+                Iterable.empty          // temporary - disables ALL bots, which is not the intention
+        }
 
         // spawn players
-        pluginsAndControlFunctions.foreach( pluginAndControlFunction => {
+        entityControllers.foreach( entityController => {
             val position = updatedBoard.emptyRandomPos(rnd, boardSize)
-            updatedBoard = updatedBoard.addBotThatIsMaster(position, time, pluginAndControlFunction._2, pluginAndControlFunction._1)
+            updatedBoard = updatedBoard.addBotThatIsMaster(position, time, entityController)
         } )
 
         updatedBoard

Scalatron/src/scalatron/botwar/BotWar.scala

@@ -7,39 +7,27 @@ import renderer.Renderer
 import scalatron.botwar.BotWarSimulation.SimState
 import java.awt.event.{WindowEvent, WindowAdapter, KeyEvent, KeyListener}
 import akka.dispatch.ExecutionContext
-import akka.actor.ActorSystem
 import scalatron.core._
 
 
 /** BotWar: an implementation of the Scalatron Game trait.
   * Main.main() feeds this instance to Scalatron.run(). */
 case object BotWar extends Game
 {
-    val name = Constants.GameName
-
     def gameSpecificPackagePath = "scalatron.botwar.botPlugin"
 
-    def runVisually(
-        pluginPath: String,
-        argMap: Map[String,String],
-        rounds: Int,
-        tournamentState: TournamentState,   // receives tournament round results
-        secureMode: Boolean,
-        verbose: Boolean
-    )(
-        actorSystem: ActorSystem,
-        executionContextForUntrustedCode: ExecutionContext
-    )
-    {
+    def runVisually(rounds: Int, scalatron: ScalatronInward) {
+        val argMap = scalatron.argMap
+
         // determine the permanent configuration for the game
-        val permanentConfig = PermanentConfig.fromArgMap(secureMode, argMap)
+        val permanentConfig = PermanentConfig.fromArgMap(scalatron.secureMode, argMap)
 
         // pop up the display window, taking command line args into account
         val display = Display.create(argMap)
         display.show()
 
         // create a renderer; we'll use it to paint the display
-        val renderer = Renderer(permanentConfig, tournamentState)
+        val renderer = Renderer(permanentConfig, scalatron)
 
         // add a keyboard listener to allow the user to configure the app while it runs
         val keyListener = new KeyListener {
@@ -67,9 +55,9 @@ case object BotWar extends Game
 
         // the simulation runner will invoke this callback, which we use to update the display
         val stepCallback = (state: SimState) => {
-            tournamentState.updateMostRecentState(state)
+            scalatron.postStepCallback(state)
 
-            val executionContextForTrustedCode = actorSystem.dispatcher
+            val executionContextForTrustedCode = scalatron.actorSystem.dispatcher
             renderer.draw(display.renderTarget, state.gameState)(executionContextForTrustedCode)
 
             // enforce maxFPS (max frames per second) by putting this thread to sleep if appropriate
@@ -82,24 +70,15 @@ case object BotWar extends Game
             !appShouldExit && !renderer.interactivelyAdjustableSettings.abortThisRound
         }
 
-        // the simulation runner will invoke this callback, which we use to update the display
-        val resultCallback = (state: SimState, tournamentRoundResult: TournamentRoundResult) => {
-            tournamentState.updateMostRecentState(state)
-            tournamentState.addResult(tournamentRoundResult)
-        }
-
-
-        var pluginCollection = PluginCollection(pluginPath, gameSpecificPackagePath, verbose)
 
         // now perform game runs ad infinitum
         var roundIndex = 0
         while(!appShouldExit && roundIndex < rounds) {
             // load plugins, either from scratch or incrementally (changed plug-ins only)
-            pluginCollection = pluginCollection.incrementalRescan // or: fullRescan
-            val plugins = pluginCollection.plugins
+            val entityControllers = scalatron.freshEntityControllers
 
             // update the game configuration based on the plug-ins that are loaded
-            val gameConfig = Config.create(permanentConfig, roundIndex, plugins, argMap)
+            val gameConfig = Config.create(permanentConfig, roundIndex, entityControllers, argMap)
             val factory = BotWarSimulation.Factory(gameConfig)
 
             // prepare a random seed for this game round. Options:
@@ -108,8 +87,8 @@ case object BotWar extends Game
             val randomSeed = System.currentTimeMillis.intValue  // or: round
 
             // run game
-            val runner = Simulation.Runner(factory, stepCallback, resultCallback)
-            runner(plugins, randomSeed)(actorSystem, executionContextForUntrustedCode)
+            val runner = Simulation.Runner(factory, stepCallback, scalatron.postRoundCallback)
+            runner(entityControllers, randomSeed)(scalatron.actorSystem, scalatron.executionContextForUntrustedCode)
 
             roundIndex += 1
 
@@ -121,19 +100,14 @@ case object BotWar extends Game
 
 
     def runHeadless(
-        pluginPath: String,
-        argMap: Map[String,String],
         rounds: Int,
-        tournamentState: TournamentState,   // receives tournament round results
-        secureMode: Boolean,
-        verbose: Boolean
-    )(
-        actorSystem: ActorSystem,
-        executionContextForUntrustedCode: ExecutionContext
+        scalatron: ScalatronInward
     )
     {
+        val argMap = scalatron.argMap
+
         // determine the permanent configuration for the game
-        val permanentConfig = PermanentConfig.fromArgMap(secureMode, argMap)
+        val permanentConfig = PermanentConfig.fromArgMap(scalatron.secureMode, argMap)
 
         // determine the maximum frames/second (to throttle CPU usage or sim loop; min: 1 fps)
         val maxFPS = argMap.get("-maxfps").map(_.toInt).getOrElse(50).max(1)
@@ -142,7 +116,7 @@ case object BotWar extends Game
 
         // the simulation runner will invoke this callback, which we use to update the display
         val stepCallback = (state: SimState) => {
-            tournamentState.updateMostRecentState(state)
+            scalatron.postStepCallback(state)
 
             // enforce maxFPS (max frames per second) by putting this thread to sleep if appropriate
             val currentTime = System.currentTimeMillis
@@ -154,25 +128,16 @@ case object BotWar extends Game
             true
         }
 
-        // the simulation runner will invoke this callback, which we use to update the tournament state
-        val resultCallback = (state: SimState, tournamentRoundResult: TournamentRoundResult) => {
-            tournamentState.updateMostRecentState(state)
-            tournamentState.addResult(tournamentRoundResult)
-        }
-
-        var pluginCollection = PluginCollection(pluginPath, gameSpecificPackagePath, verbose)
-
         // now perform game runs ad infinitum
         var roundIndex = 0
         while(roundIndex < rounds) {
             val startTime = System.currentTimeMillis()
 
             // load plugins, either from scratch or incrementally (changed plug-ins only)
-            pluginCollection = pluginCollection.incrementalRescan // or: fullRescan
-            val plugins = pluginCollection.plugins
+            val entityControllers = scalatron.freshEntityControllers
 
             // update the game configuration based on the plug-ins that are loaded
-            val gameConfig = Config.create(permanentConfig, roundIndex, plugins, argMap)
+            val gameConfig = Config.create(permanentConfig, roundIndex, entityControllers, argMap)
             val factory = BotWarSimulation.Factory(gameConfig)
 
             // prepare a random seed for this game round. Options:
@@ -181,8 +146,8 @@ case object BotWar extends Game
             val randomSeed = System.currentTimeMillis.intValue  // or: round
 
             // run game
-            val runner = Simulation.Runner(factory, stepCallback, resultCallback)
-            runner(plugins, randomSeed)(actorSystem, executionContextForUntrustedCode)
+            val runner = Simulation.Runner(factory, stepCallback, scalatron.postRoundCallback)
+            runner(entityControllers, randomSeed)(scalatron.actorSystem, scalatron.executionContextForUntrustedCode)
 
             roundIndex += 1
 
@@ -196,13 +161,13 @@ case object BotWar extends Game
 
 
     /** Starts a headless game simulation using the given plug-in collection.
-      * @param plugins the collection of plug-ins to use as control function factories.
+      * @param entityControllers the collection of plug-ins to use as control function factories.
       * @param secureMode if true, certain bot processing restrictions apply
       * @param argMap the command line arguments
       * @return the initial simulation state
       */
     def startHeadless(
-        plugins: Iterable[Plugin.FromJarFile],
+        entityControllers: Iterable[EntityController],
         secureMode: Boolean,
         argMap: Map[String,String]
     )(
@@ -214,7 +179,7 @@ case object BotWar extends Game
         val roundIndex = 0
 
         // determine the per-round configuration for the game
-        val gameConfig : Config = Config.create(permanentConfig, roundIndex, plugins, argMap)
+        val gameConfig : Config = Config.create(permanentConfig, roundIndex, entityControllers, argMap)
 
         // update the game configuration based on the plug-ins that are loaded
 
@@ -225,21 +190,20 @@ case object BotWar extends Game
         // (b) deterministically incremented (beneficial for testing purposes)
         val randomSeed = System.currentTimeMillis.intValue  // or: round
 
-        factory.createInitialState(randomSeed, plugins)(executionContextForUntrustedCode)
+        factory.createInitialState(randomSeed, entityControllers, executionContextForUntrustedCode)
     }
 
 
     /** Starts a headless game simulation using the given plug-in collection.
-      * @param plugins the collection of plug-ins to use as control function factories.
+      * @param entityControllers the collection of plug-ins to use as control function factories.
       * @return the initial simulation state
       */
     def startHeadless(
-        plugins: Iterable[Plugin.FromJarFile],
-        roundConfig: RoundConfig
-    )(
+        entityControllers: Iterable[EntityController],
+        roundConfig: RoundConfig,
         executionContextForUntrustedCode: ExecutionContext
     ) : SimState = {
-        val gameConfig = Config.create(roundConfig.permanent, roundConfig.roundIndex, plugins, roundConfig.argMap)
+        val gameConfig = Config.create(roundConfig.permanent, roundConfig.roundIndex, entityControllers, roundConfig.argMap)
 
         // update the game configuration based on the plug-ins that are loaded
         val factory = BotWarSimulation.Factory(gameConfig)
@@ -249,19 +213,14 @@ case object BotWar extends Game
         // (b) deterministically incremented (beneficial for testing purposes)
         val randomSeed = System.currentTimeMillis.intValue  // or: round
 
-        factory.createInitialState(randomSeed, plugins)(executionContextForUntrustedCode)
+        factory.createInitialState(randomSeed, entityControllers, executionContextForUntrustedCode)
     }
 
 
     /** Dump the game-specific command line configuration options via println.
       *  "... -x 100 -y 100 -steps 1000" */
-    def printArgList() {
-        Config.printArgList()
-        PermanentConfig.printArgList()
-        Display.printArgList()
-        Renderer.printKeyboardCommands()
-
-        println("  -maxfps <int>            maximum steps/second (to reduce CPU load; default: 50)")
-    }
+    def cmdArgList =
+        Iterable("maxfps <int>" -> "maximum steps/second (to reduce CPU load; default: 50)") ++
+            Config.cmdArgList ++ Display.cmdArgList
 }
 

Scalatron/src/scalatron/botwar/BotWarFactory.scala

@@ -0,0 +1,11 @@
+package scalatron.botwar
+
+import scalatron.core.Game
+
+/** This is the class that will be extracted from the game plug-in by Scalatron in order to obtain a
+  * game factory function.
+  */
+class BotWarFactory {
+    /** This is game factory function that Scalatron will use to instantiate the game instance. */
+    def create() : Game = BotWar
+}