Key Concepts #

game:
  pluginConfigs:
    PartyService.gameServerCompatibilityPlugin:
      class: "pragma.party.OrderedGameServerCompatibilityPlugin"
      config:
        versionCompatibility:
          1:
            serverVersion: "gameServerVersion1"
            clientVersions:
              1: "gameClientVersion0"
              2: "gameClientVersion1"
          2:
            serverVersion: "gameServerVersion2"
            clientVersions:
              1: "gameClientVersion1"
              2: "gameClientVersion2"

@Suppress("unused")
class OrderedGameServerCompatibilityPlugin(
    override val service: Service,
    override val contentDataNodeService: ContentDataNodeService,
) :
    GameServerCompatibilityPlugin,
    ConfigurablePlugin<OrderedGameServerCompatibilityPlugin.Config> {
    var logger: Logger =
        LoggerFactory.getLogger(
            OrderedGameServerCompatibilityPlugin::class.simpleName
        )


    constructor(
        service: Service,
        contentDataNodeService: ContentDataNodeService,
        logger: Logger
    ) : this(service, contentDataNodeService) {
        this.logger = logger
    }


    data class ServerVersionInfo(
        val gameServerVersionName: String,
        val gameServerVersionNumber: Int
    )


    private lateinit var clientVersionToServerVersions:
        Map<String, Set<ServerVersionInfo>>


    private var onStartup = true


    class Config private constructor(type: BackendType) :
        PluginConfig<Config>(type) {
        override val description =
            "OrderedGameServerCompatibility plugin configuration."


        var versionCompatibility by
            types.mapOfObject(
                VersionCompatibility::class,
                "map of all the server versions to compatible game client versions"
            )


        companion object : ConfigBackendModeFactory<Config> {
            override fun getFor(type: BackendType): Config {
                return Config(type)
            }
        }
    }


    override suspend fun onConfigChanged(config: Config) {
        val exception = isValid(config)
        if (exception != null) {
            if (onStartup) {
                throw exception
            } else {
                logger.warn(
                    "Could not parse bad configuration: ${exception.message}"
                )
                return
            }
        }
        onStartup = false


        val clientVersionToServerVersions =
            mutableMapOf<String, MutableSet<ServerVersionInfo>>()
        config.versionCompatibility.entries.map {
            val serverVersionName = it.value.serverVersion
            val serverVersionNumber = it.key.toInt()
            it.value.clientVersions.values.forEach { gameClientVersion ->
                val serverVersionInfo =
                    ServerVersionInfo(serverVersionName, serverVersionNumber)
                if (gameClientVersion in clientVersionToServerVersions) {
                    clientVersionToServerVersions[gameClientVersion]!!.add(
                        serverVersionInfo
                    )
                } else {
                    clientVersionToServerVersions[gameClientVersion] =
                        mutableSetOf(serverVersionInfo)
                }
            }
        }


        if (this::clientVersionToServerVersions.isInitialized) {
            val oldServerVersions =
                this.clientVersionToServerVersions.entries
                    .flatMap {
                        it.value.map { serverVersionInfo ->
                            serverVersionInfo.gameServerVersionName
                        }
                    }
                    .toSet()
            val newServerVersions =
                config.versionCompatibility.entries
                    .map { it.value.serverVersion }
                    .toSet()


            val removedServerVersions = oldServerVersions - newServerVersions
            if (removedServerVersions.any()) {
                service.requestRpc(
                    MatchmakingRpc.RemoveGameServerVersionV1Request.newBuilder()
                        .addAllGameServerVersions(removedServerVersions)
                        .build(),
                    MatchmakingRpc.RemoveGameServerVersionV1Response::class
                )
            }
        }


        this.clientVersionToServerVersions = clientVersionToServerVersions
    }


    private fun isValid(config: Config): Exception? {
        val versionCompatibilityKeys = config.versionCompatibility.keys
        val notValidInts =
            versionCompatibilityKeys.any {
                val num = it.toIntOrNull()
                num == null || num <= 0
            }
        if (notValidInts) {
            return Exception("version compatibility keys be a positive integer")
        }


        config.versionCompatibility.entries.forEach {
            val gameClientVersions = it.value.clientVersions
            if (it.key.isEmpty()) {
                return Exception("serverVersion must not be an empty string")
            }
            if (gameClientVersions.isEmpty()) {
                return Exception(
                    "clientVersions must contain at least one value"
                )
            }
            if (
                gameClientVersions.any { clientVersion ->
                    clientVersion.value.isEmpty()
                }
            ) {
                return Exception("clientVersions must not contain empty values")
            }
        }


        if (
            config.versionCompatibility.entries
                .map { it.value.serverVersion }
                .toSet()
                .size != config.versionCompatibility.entries.size
        ) {
            return Exception("serverVersion was repeated")
        }


        return null
    }


    override fun calculateGameServerVersion(
        party: Party,
        newPlayer: PartyPlayer?
    ): String? {
        var possibleGameServerVersion = setOf<ServerVersionInfo>()
        val allPlayers =
            (party.partyMembersByPlayerId.values + newPlayer).filterNotNull()
        allPlayers.forEachIndexed { index, it ->
            val clientVersion = it.gameClientVersion
            val supportedGameServerVersions =
                clientVersionToServerVersions[clientVersion] ?: emptySet()
            possibleGameServerVersion =
                if (index == 0) {
                    supportedGameServerVersions
                } else {
                    possibleGameServerVersion.intersect(
                        supportedGameServerVersions
                    )
                }


            if (possibleGameServerVersion.isEmpty()) {
                return null
            }
        }


        return possibleGameServerVersion
            .maxByOrNull { it.gameServerVersionNumber }!!
            .gameServerVersionName
    }


    override fun getValidGameClientVersions(): List<String> {
        return clientVersionToServerVersions.keys.toList()
    }
}


class VersionCompatibility private constructor(type: BackendType) :
    ConfigObject<VersionCompatibility>(type) {
    constructor(
        serverVersion: String,
        clientVersions: Map<String, String>
    ) : this(BackendType.GAME) {
        this.serverVersion = serverVersion
        this.clientVersions = ConfigMapOfPrimitive(this)
        this.clientVersions.putAll(clientVersions)
    }


    override val description =
        "clientVersions to serverVersion support configuration."


    var serverVersion by
        types.string("game server version string, must not be empty")
    var clientVersions by
        types.mapOfString(
            "game client versions supported by this server version"
        )


    companion object : ConfigBackendModeFactory<VersionCompatibility> {
        override fun getFor(type: BackendType): VersionCompatibility {
            return VersionCompatibility(type)
        }
    }
}