Some work on kotlin game framework.

src/main/kotlin/org/gameflow/BaseTest.kt

@@ -0,0 +1,8 @@
+package org.gameflow
+
+/**
+ * 
+ */
+open class BaseTest {
+
+}

src/main/kotlin/org/gameflow/Component.kt

@@ -0,0 +1,8 @@
+package org.gameflow
+
+/**
+ * 
+ */
+public trait Component {
+
+}

src/main/kotlin/org/gameflow/Faceted.kt

@@ -0,0 +1,47 @@
+package org.gameflow
+
+import java.util.List
+import java.util.ArrayList
+import java.util.Set
+import java.util.HashSet
+import java.util.LinkedHashSet
+import org.gameflow.util.ListenableCollection
+
+/**
+ * 
+ */
+public trait Faceted<T>: Updating, Rendering {
+
+    public val facets: ListenableCollection<Component<T>>
+
+    public final fun addFacet(facet: Component<T>) {
+        facets.add(facet)
+    }
+
+    public final fun removeFacet(facet: Component<T>) {
+        facets.remove(facet)
+    }
+
+    protected final fun updateFacets(seconds : Double) {
+        facets.updateCollection()
+
+        for (facet in facets.elements()) {
+            facet.update(seconds)
+        }
+    }
+
+    protected final fun renderFacets(r : RenderContext) {
+        for (facet in facets.elements()) {
+            facet.render(r)
+        }
+    }
+
+
+    override fun render(r : RenderContext) {
+        renderFacets(r)
+    }
+
+    override fun update(seconds : Double) {
+        updateFacets(seconds)
+    }
+}

src/main/kotlin/org/gameflow/Game.kt

@@ -1,12 +1,88 @@
 package org.gameflow
 
+import java.util.List
+import java.util.Map
+import java.util.HashMap
+import org.gameflow.state.GameState
+import org.gameflow.util.ListenableCollection
+
 /**
  * 
  */
-public open class Game() {
+// TODO: When 'This' is supported, remove G from constructor and replace uses of G with This
+public open class Game<G: Game<G>>() : Faceted<G>, Updating, Rendering {
+
+    private val gameStates: Map<String, GameState<G>> = HashMap<String, GameState<G>>()
+    private var activeGameState: GameState<G>? = null
+    private var newGameStateName: String? = null
+    private var stopped = false
+
+    public override val facets : ListenableCollection<Component<G>> = ListenableCollection<Component<G>>()
+
+    fun addState(gameState: GameState<G>) {
+        gameStates.put(gameState.name, gameState)
+    }
+
+    fun removeState(gameState: GameState<G>) {
+        gameStates.remove(gameState.name)
+    }
+
+    fun changeGameState(newStateName: String) {
+        newGameStateName = newStateName
+    }
+
+    /** Calls init, then starts the game loop.  Call stop to exit it. */
+    public final fun start() {
+        while(!stopped) {
+            doLoop()
+        }
+    }
+
+    /** Runs through the game loop once. */
+    public final fun doLoop() {
+
+    }
+
+    public final fun doUpdate(seconds: Double) {
+        updateGameState(seconds)
+        updateFacets(seconds)
+        update(seconds)
+    }
+
+    public final fun doRender(r : RenderContext) {
+        renderGameState(r)
+        renderFacets(r)
+        render(r)
+    }
+
+    override fun update(seconds : Double) {}
+    override fun render(r : RenderContext) {}
+
+    private fun renderGameState(r: RenderContext) {
+        // Render current game state if present
+        activeGameState?.render(r)
+    }
+
+    private fun updateGameState(seconds : Double) {
+        // Check if game state changed
+        if (newGameStateName != null) {
+            // Get new game state, null the change variable in case the onExit or onEnter methods immediately change the game state again.
+            val newStateName = newGameStateName
+            newGameStateName = null
 
+            // Switch to new game state
+            val gameState = gameStates.get(newStateName)
+            if (gameState == null) throw Exception("No game state named '$newStateName' found.")
+            else {
+                activeGameState?.onExit(this as G)
+                activeGameState = gameState
+                activeGameState?.onEnter(this as G)
+            }
+        }
 
-    fun update(seconds: Double)
+        // Update current game state
+        activeGameState?.update(seconds)
+    }
 
 
 }

src/main/kotlin/org/gameflow/MessageHandling.kt

@@ -0,0 +1,10 @@
+package org.gameflow
+
+/**
+ * Something that handles messages.
+ */
+public trait MessageHandling {
+
+    fun handleMessage(message: Any)
+
+}

src/main/kotlin/org/gameflow/RenderContext.kt

@@ -0,0 +1,7 @@
+package org.gameflow
+
+/**
+ * 
+ */
+public trait RenderContext {
+}

src/main/kotlin/org/gameflow/Rendering.kt

@@ -0,0 +1,12 @@
+package org.gameflow
+
+import java.awt.Graphics2D
+
+/**
+ * 
+ */
+public trait Rendering {
+
+    fun render(r: RenderContext)
+
+}

src/main/kotlin/org/gameflow/Facet.kt → src/main/kotlin/org/gameflow/Updating.kt

@@ -3,9 +3,8 @@ package org.gameflow
 /**
  * 
  */
-public trait Facet {
+public trait Updating {
 
     fun update(seconds: Double)
 
-
 }

src/main/kotlin/org/gameflow/entity/Entity.kt

@@ -1,11 +1,53 @@
 package org.gameflow.entity
 
+import org.gameflow.Updating
+import org.gameflow.Rendering
+import org.gameflow.Faceted
+import org.gameflow.util.ListenableCollection
+import org.gameflow.Component
+import org.gameflow.RenderContext
+
 /**
- * 
+ * A game object, consisting of components.
  */
-public trait Entity {
+public class Entity {
+
+    private val components = ListenableCollection<Component>()
+
+    public final fun addComponent(component: Component) {
+        components.add(component)
+    }
+
+    public final fun removeComponent(component: Component) {
+        components.remove(component)
+    }
+
+    private final fun updateFacets(seconds : Double) {
+        facets.updateCollection()
+
+        for (facet in facets.elements()) {
+            facet.update(seconds)
+        }
+    }
+
+    protected final fun renderFacets(r : RenderContext) {
+        for (facet in facets.elements()) {
+            facet.render(r)
+        }
+    }
+
+
+    final override fun update(seconds : Double) {
+        updateFacets(seconds)
+        onUpdate(seconds)
+    }
 
-    fun update(deltaTime: Double, totalTime: Double)
+    final override fun render(r : RenderContext) {
+        renderFacets(r)
+        onRender(r)
+    }
 
+    protected fun onUpdate(seconds : Double)
 
+    protected fun onRender(r : RenderContext)
 }

src/main/kotlin/org/gameflow/entity/EntityGroup.kt

@@ -0,0 +1,37 @@
+package org.gameflow.entity
+
+import java.util.ArrayList
+import org.gameflow.util.ListenableCollection
+import java.util.Collection
+import org.gameflow.Faceted
+import org.gameflow.Component
+import org.gameflow.RenderContext
+import java.util.concurrent.ConcurrentSkipListSet
+import java.util.Collections
+
+/**
+ * A group of entities.
+ */
+public class EntityGroup : Component {
+
+    private val entities = ConcurrentSkipListSet<Entity>()
+    private val unmodifiableEntities: Collection<Entity> = Collections.unmodifiableCollection<Entity>(entities) !!
+
+    public fun entities() : Collection<Entity> {
+        return unmodifiableEntities
+    }
+
+    public fun add(entity: Entity)  {
+        entities.add(entity)
+    }
+
+    public fun remove(entity: Entity)  {
+        entities.remove(entity)
+    }
+
+    public fun clear() {
+        entities.clear()
+    }
+
+
+}

src/main/kotlin/org/gameflow/state/BaseGameState.kt

@@ -0,0 +1,14 @@
+package org.gameflow.state
+
+import org.gameflow.Game
+
+/**
+ * 
+ */
+public abstract class BaseGameState<G: Game<G>>(override val name: String, override val game: G): GameState<G> {
+    {
+        // Automatically add on construction - is this a good idea?
+        game.addState(this)
+    }
+
+}

src/main/kotlin/org/gameflow/state/GameState.kt

@@ -0,0 +1,19 @@
+package org.gameflow.state
+
+import org.gameflow.Updating
+import org.gameflow.Game
+import org.gameflow.Rendering
+
+
+/**
+ * 
+ */
+public trait GameState<G: Game<G>> : Updating, Rendering {
+
+    val name: String
+    val game: G
+
+    fun onEnter(game: G)
+    fun onExit(game: G)
+
+}