Add korge-fleks extension to gradle plugin

gradle.properties

@@ -49,10 +49,8 @@ project.license.url=https://raw.githubusercontent.com/korlibs/korge-next/master/
 #kotlin.mpp.enableCInteropCommonization.nowarn=true
 #kotlin.mpp.enableCInteropCommonization=true
 kotlin.mpp.stability.nowarn=true
-kotlin.wasm.stability.nowarn=true
 org.gradle.warning.mode=none
 
-kotlin.native.ignoreIncorrectDependencies=true
 kotlin.native.ignoreDisabledTargets=true
 #kotlin.mpp.androidSourceSetLayoutVersion=2
 kotlin.mpp.androidSourceSetLayoutVersion1.nowarn=true

korge-gradle-plugin/src/main/kotlin/korlibs/korge/gradle/korgefleks/AssetConfig.kt

@@ -0,0 +1,298 @@
+package korlibs.korge.gradle.korgefleks
+
+import com.android.build.gradle.internal.cxx.json.jsonStringOf
+import kotlinx.kover.util.json.readJsonArray
+import java.io.File
+
+
+/**
+ * Configuration for managing assets in a KorgeFleks project.
+ *
+ * This class is a convenience wrapper around AssetImageLoader.
+ *
+ * @param asepriteExe The path to the Aseprite executable.
+ * @param projectDir The root directory of the project.
+ * @param assetPath The relative path to the directory containing asset files.
+ * @param resourcePath The relative path to the directory for game resources.
+ */
+open class AssetConfig(
+    private val asepriteExe: String,
+    projectDir: File,
+    assetPath: String,
+    resourcePath: String
+) {
+    var textureAtlasName: String = "texture"
+    var tilesetAtlasName: String = "tileset"
+    var simplifyJson: Boolean = true
+
+    var tileWidth: Int = 16
+    var tileHeight: Int = 16
+    var atlasWidth: Int = 2048
+    var atlasHeight: Int = 2048
+    var atlasPadding: Int = 1
+
+    companion object {
+        internal const val VERSION = "version"
+        internal const val TEXTURES = "textures"
+        internal const val TILESETS = "tilesets"
+        internal const val IMAGES = "images"
+        internal const val NINE_PATCHES = "ninePatches"
+        internal const val PIXEL_FONTS = "pixelFonts"
+        internal const val PARALLAX_LAYERS = "parallaxLayers"
+        internal const val TILES = "tiles"
+    }
+
+    // Directory where Aseprite files are located
+    protected val assetDir = projectDir.resolve(assetPath)
+    // Directory where exported tiles and tilesets will be stored
+    protected val exportTilesDir = projectDir.resolve("build/assets/imageAtlasInput")
+    // Directory where game resources are located
+    protected val gameResourcesDir = projectDir.resolve("src/commonMain/resources/${resourcePath}")
+
+    protected val assetInfo = linkedMapOf<String, Any>()
+
+    init {
+        // Make sure the export directories exist and that they are empty
+        if (exportTilesDir.exists()) exportTilesDir.deleteRecursively()
+        exportTilesDir.mkdirs()
+
+        // Set version info
+        val major = 1
+        val minor = 0
+        val build = 1
+        assetInfo[VERSION] = arrayOf(major, minor, build)
+
+        // Initialize maps and lists in asset info
+        assetInfo[TEXTURES] = arrayListOf<String>()
+        assetInfo[TILESETS] = arrayListOf<String>()
+        assetInfo[IMAGES] = linkedMapOf<String, Any>()
+        assetInfo[NINE_PATCHES] = linkedMapOf<String, Any>()
+        assetInfo[PIXEL_FONTS] = linkedMapOf<String, Any>()
+        assetInfo[PARALLAX_LAYERS] = linkedMapOf<String, Any>()
+        assetInfo[TILES] = linkedMapOf<String, Any>()
+    }
+
+    protected val assetImageAseExporter = AssetImageAseExporter(asepriteExe, assetDir, exportTilesDir, assetInfo)
+    protected val assetFileInstaller = AssetFileInstaller(assetDir, exportTilesDir, gameResourcesDir, assetInfo)
+    protected val assetImageAtlasBuilder = AssetImageAtlasBuilder(exportTilesDir, gameResourcesDir, assetInfo)
+    protected val assetLevelMapExporter = AssetLevelMapExporter(assetDir, gameResourcesDir, assetInfo)
+
+    /**
+     * Export specific layers and tags from Aseprite file as independent png images.
+     * Adds exported images to internal asset info list.
+     */
+    fun addImageAse(filename: String, layers: List<String>, tags: List<String>, output: String) {
+        assetImageAseExporter.addImageAse(filename, layers, tags, output)
+    }
+
+    /** Export full image from Aseprite file
+     */
+    fun addImageAse(filename: String, output: String) {
+        assetImageAseExporter.addImageAse(filename, emptyList(), emptyList(), output )
+    }
+
+    /** Export specific layer from Aseprite file
+     */
+    fun addImageAse(filename: String, layer: String, output: String) {
+        assetImageAseExporter.addImageAse(filename, listOf(layer), emptyList(), output)
+    }
+
+    /** Export specific layer and tag from Aseprite file
+     */
+    fun addImageAse(filename: String, layer: String, tag: String, output: String) {
+        assetImageAseExporter.addImageAse(filename, listOf(layer), listOf(tag), output)
+    }
+
+    /** Export specific layer and tags from Aseprite file
+     */
+    fun addImageAse(filename: String, layer: String, tags: List<String>, output: String) {
+        assetImageAseExporter.addImageAse(filename, listOf(layer), tags, output)
+    }
+
+    /** Export specific layers from Aseprite file
+     */
+    fun addImageAse(filename: String, layers: List<String>, output: String) {
+        assetImageAseExporter.addImageAse(filename, layers, emptyList(), output)
+    }
+
+    /** Export specific layers and tag from Aseprite file
+     */
+    fun addImageAse(filename: String, layers: List<String>, tag: String, output: String) {
+        assetImageAseExporter.addImageAse(filename, layers, listOf(tag), output)
+    }
+
+    /**
+     * Export nine-patch image from Aseprite file.
+     * Adds exported nine-patch image to internal asset info list.
+     */
+    fun addNinePatchImageAse(filename: String, output: String) {
+        assetImageAseExporter.addNinePatchImageAse(filename, emptyList(), emptyList(), output)
+    }
+
+    /**
+     * Export pixel font file and associated pixel font image.
+     * It copies font file to game resources and exports font image to assets folder for atlas packing.
+     */
+    fun addPixelFont(filename: String) {
+        assetFileInstaller.addPixelFont(filename)
+    }
+
+    /**
+     * Export parallax layer images from Aseprite file.
+     * Adds exported parallax images to internal asset info list.
+     */
+    fun addParallaxImageAse(filename: String, parallaxInfo: ParallaxInfo) {
+        assetImageAseExporter.addParallaxImageAse(filename, parallaxInfo)
+    }
+
+    /**
+     * Add a generic file to the asset configuration.
+     * Copies the file to the game resources' directory.
+     */
+    fun addFile(filename: String) {
+        assetFileInstaller.addFile(filename)
+    }
+
+    /**
+     * Build texture and tileset atlases from exported images.
+     * Uses atlas names and sizes from the AssetConfig properties.
+     *
+     * This will always be called as last step after all assets have been added.
+     */
+    internal open fun buildAssetStore() {
+        // First build the image and tileset atlases
+        assetImageAtlasBuilder.buildAtlases(
+            textureAtlasName,
+            atlasWidth,
+            atlasHeight,
+            atlasPadding
+        )
+        // Finally, write out the asset info as JSON file
+        writeAssetInfoJson()
+    }
+
+    protected fun writeAssetInfoJson() {
+        val assetInfoJsonFile = gameResourcesDir.resolve("${textureAtlasName}.atlas.json")
+        assetInfoJsonFile.parentFile?.let { parent ->
+            if (!parent.exists() && !parent.mkdirs()) error("Failed to create directory: ${parent.path}")
+            val jsonString = jsonStringOf(assetInfo)
+            // Simplify JSON string by removing unnecessary spaces and line breaks
+            val simplifiedJsonString = if (simplifyJson) jsonString.replace(Regex("\\s+"), "")
+            else jsonString
+            assetInfoJsonFile.writeText(simplifiedJsonString)
+        }
+    }
+}
+
+class WorldClusterAssetConfig(
+    asepriteExe: String,
+    projectDir: File,
+    assetPath: String,
+    resourcePath: String
+) : AssetConfig(asepriteExe, projectDir, assetPath, resourcePath) {
+
+    private val tileSetFiles: MutableList<File> = mutableListOf()
+    private val exportTilesetDir = projectDir.resolve("build/assets/tilesetAtlasInput")
+
+    // Directory with cluster asset info files (e.g. world.json, intro.json, etc.)
+    private val clusterAssetInfoDir = projectDir.resolve("gradle/worldClusterAssetInfo")
+
+    private val assetTilesetExporter = AssetTilesetExporter(assetDir, exportTilesetDir, tileSetFiles)
+    private val assetTilesetAtlasBuilder = AssetTilesetAtlasBuilder(exportTilesetDir, gameResourcesDir, assetInfo, tileSetFiles, clusterAssetInfoDir)
+
+    init {
+        // Make sure the export directories exist and that they are empty
+        if (exportTilesDir.exists()) exportTilesDir.deleteRecursively()
+        if (exportTilesetDir.exists()) exportTilesetDir.deleteRecursively()
+        exportTilesDir.mkdirs()
+        exportTilesetDir.mkdirs()
+    }
+
+    /**
+     * Export single tiles from a png tileset file and stores them in a tileset atlas.
+     * Adds exported tiles and tileset images to internal asset info list.
+     */
+    fun addTilesetImagePng(filename: String) {
+        assetTilesetExporter.addTilesetImagePng(filename)
+    }
+
+    /**
+     * Export single level from LDtk file as an TileMap object.
+     * Adds exported level map to internal asset info list.
+     *
+     * @param filename The LDtk file containing the level data.
+     * @param levelName The name of the level to export.
+     */
+    fun addTileMapLDtkFile(filename: String, levelName: String) {
+        // TODO Get data for all clusters and extract used tilesets
+        val tileSetsPerClusterMap = mapOf<String, List<String>>()
+
+        assetLevelMapExporter.exportTileMapLDtk(filename, levelName, tileSetsPerClusterMap)
+    }
+
+    /**
+     * Build texture and tileset atlases from exported images.
+     * Uses atlas names and sizes from the AssetConfig properties.
+     *
+     * This will always be called as last step after all assets have been added.
+     *
+     * @param assetResourcePath The relative path to the directory for game resources. The name of the last folder is the cluster name.
+     */
+    fun buildAssetStore(assetResourcePath: String) {
+        // First build the image and tileset atlases
+        assetImageAtlasBuilder.buildAtlases(
+            textureAtlasName,
+            atlasWidth,
+            atlasHeight,
+            atlasPadding
+        )
+        assetTilesetAtlasBuilder.buildTilesetAtlas(
+            assetResourcePath,
+            tilesetAtlasName,
+            tileWidth,
+            tileHeight,
+            atlasWidth,
+            atlasHeight,
+            atlasPadding
+        )
+        // Finally, write out the asset info as JSON file
+        writeAssetInfoJson()
+    }
+}
+
+class WorldLDtkLevelMapAssetConfig(
+    projectDir: File,
+    world: Int,
+    private val levelMapFilePath: String,
+    resourcePath: String
+) {
+    // Directory with cluster asset info files (e.g. world.json, intro.json, etc.)
+    private val clusterAssetInfoDir = projectDir.resolve("gradle/worldClusterAssetInfo/world_${world}")
+    // Directory where game resources are located
+    private val gameResourcesDir = projectDir.resolve("src/commonMain/resources/${resourcePath}")
+    private val assetLevelMapExporter = AssetLevelMapExporter(projectDir, gameResourcesDir, linkedMapOf())
+
+    /**
+     * Export level map from LDtk file as chunked level map.
+     * Adds exported level map to internal asset info list.
+     */
+    fun buildAssetStore() {
+        // Get the info which tileset are available in each processed asset cluster
+        if (clusterAssetInfoDir.listFiles() != null && clusterAssetInfoDir.listFiles().isNotEmpty()) {
+            val clusterAssetInfoFiles = clusterAssetInfoDir.listFiles()!!.filter { it.extension == "json" }
+
+            val tileSetsPerClusterMap: Map<String, List<String>> = clusterAssetInfoFiles.associate { file ->
+                val clusterName = file.nameWithoutExtension
+                val tileSetsList: List<String> = file.readJsonArray().let { jsonArray ->
+                    jsonArray.map { it as String }
+                }
+                clusterName to tileSetsList
+            }
+
+            println("Tilesets per cluster: $tileSetsPerClusterMap")
+
+            // TODO change to support world chunks
+            assetLevelMapExporter.exportLevelMapLDtk(levelMapFilePath, tileSetsPerClusterMap)
+        } else error("ERROR: No cluster asset info files found. Please run first all world cluster asset tasks before running level map asset task.")
+    }
+}