Switch Theme

Making Combinatory: Introduction to KorGE

dev kotlin calcugames

3/2/2025

7 min. read

This will be a short series on how I made the Combinatory video game using the KorGE game engine. I will be going over the basics of the game engine, how I set up the project, and how I implemented the game itself. I will also be going over some of the challenges I faced and how I overcame them.

I have mixed feelings about KorGE. On one hand, it’s great, and has a lot of potential. On the other hand, one person maintains the entire thing, which make bugs like trying to make a working iOS Build take near half a year to even get a response. I mean, soywiz is a great guy, but he’s only one person. I’m sure he’s looking for help, but I’m not sure if I’m ready to take on that kind of responsibility, at least when I have another dozen side projects to work on.

Entry Point

The entry point of the game looks like this:

suspend fun main() = Korge(
    gameId = ID,
    title = TITLE,
    windowSize = SIZE,
    backgroundColor = MAIN_COLOR,
    icon = ICON
) {
    container = sceneContainer(defaultTransition = TRANSITION)
    container.addTo(this)
    loadingSequence(this)

    // UI
    registerScenes()
    title()

    if (Os.CURRENT.isDesktop)
        devMode()
}

The next TRANSITION is the transitioning scene between the loading screen and the main menu, as well as other scene containers in the game. It’s just a default fade transition.

KorGE makes things really nice when it comes to setting up the game. Just open up a container and boom, you’re in the game. No need to worry about setting up OpenGL or anything like that. It’s all done for you.

Loading Sequence

The loading scene looks like this:

class LoadingScene : Scene() {

    override suspend fun SContainer.sceneMain() {
        val text = text("Loading...", 64.0) {
            centerXOnStage()
            y = 100.0
        }

        while (!loaded) {
            text.tween(text::y[height - 100], time = 3.0.seconds, easing = Easing.EASE_IN_OUT)
            text.tween(text::y[100.0], time = 3.0.seconds, easing = Easing.EASE_IN_OUT)
        }
    }

}

KorGE uses Scenes to manage different windows that need to be shown. My loading screen is just a “Loading…” text going up and down until the game is loaded. This could take anywhere from under a second to near a minute, depending on how fast your computer or phone is. I figured this would satisfy the user’s need to be entertained while the game is loading in a simple game.

KorGE’s animation suite is great. It feels like I’m using CSS animations, but in a game engine. I can tween any property of any object, and it will animate smoothly. I can even tween multiple properties at once, and it will still animate smoothly. It’s really nice. The design for using extension functions on properties is highly clever as well. I can just type text::x or text::color and boom, I’m animating the x position or color of the text. It’s amazing.

Level Scene

Finally, I’ll show some of the loading operations for the level scene. It’s pretty complicated, has a lot of variables, and is arguably highly important. I’m also not going to reveal anything.

In short, calculatory, or the open source portion with all the algorithms, converts level data into the LevelZ File Format, which is a level format I created for general use. The game then reads the level data and creates the level from that.

The auto-generated levels, like the Daily Level and the Endless modes, use multiple seeded values (that are internal so you can’t predict them) to generate the level data. The game then reads the level data and creates the level from that.

Calculatory has an algorithm for getting all of the possible path values in each area:

suspend fun findValues(
    grid: Array<DoubleArray>,
    functions: List<Operation>,
    sx: Int,
    sy: Int
): Set<Double> = coroutineScope {
    val size = grid.size

    require(grid.isNotEmpty()) { "Grid must have at least one row" }
    require(grid[0].isNotEmpty()) { "Grid must have at least one column" }
    require(sx in grid.indices) { "Starting X Coordinate must be within the grid" }
    require(sy in grid[0].indices) { "Starting Y Coordinate must be within the grid" }
    require(grid.all { row -> row.size == size }) { "Grid must be square" }

    val channel = Channel<Double>()
    val visited = mutableSetOf<Pair<Int, Int>>()
    val values = mutableSetOf<Double>()

    suspend fun exploreValue(value: Double, cx: Int, cy: Int, operations: List<Operation>) {
        var hasMoved = false

        directions.forEach directions@{ (dx, dy) ->
            val nx = cx + dx
            val ny = cy + dy

            if (nx < 0.0 || nx >= size) return@directions
            if (ny < 0.0 || ny >= size) return@directions

            if (grid[nx][ny] == 0.0) return@directions
            if ((nx to ny) in visited) return@directions

            visited.add(nx to ny)
            val nv = grid[nx][ny]

            operations.forEach { o ->
                val newValue = o(value, nv)
                if (newValue in values) return@forEach

                values.add(newValue)
                channel.send(newValue)

                val remaining = operations.toMutableList()
                remaining.removeAt(remaining.indexOf(o))
                exploreValue(newValue, nx, ny, remaining)

                hasMoved = true
            }

            visited.remove(nx to ny)
        }

        if (!hasMoved || operations.isEmpty())
            channel.send(value)
    }

    val sv = grid[sx][sy]
    launch {
        exploreValue(sv, sx, sy, functions)
        channel.close()
    }

    for (value in channel)
        values.add(value)

    return@coroutineScope values
}

Pretty cool stuff. I’ll show some more later. This was just a short look into the inner workings on the game, which I definetly need to promote more. I’ll be working on that soon. Stay tuned for the next part of the series.