build.gradle

plugins {
    id 'org.jetbrains.kotlin.jvm' version '2.0.10'
    id 'org.jetbrains.kotlin.plugin.serialization' version '2.0.10'

    id 'net.mamoe.mirai-console' version '2.16.0'
}

apply plugin: "maven-publish"
apply plugin: "java"


group = 'xmmt.dituon'
version = '6.2'

repositories {
    maven { url 'https://maven.aliyun.com/repository/public' }
    mavenCentral()
}

dependencies {
    compileOnly 'org.projectlombok:lombok:1.18.34'
    annotationProcessor 'org.projectlombok:lombok:1.18.34'

    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.1'
    implementation "com.madgag:animated-gif-lib:1.4"
    implementation "net.coobird:thumbnailator:0.4.19"
    implementation 'com.jhlabs:filters:2.0.235-1'

    implementation "org.java-websocket:Java-WebSocket:1.5.3"

    implementation "org.luaj:luaj-jse:3.0.1"

    testImplementation "junit:junit:4.11"
    testImplementation 'org.codehaus.groovy:groovy-json:3.0.18'

    testCompileOnly 'org.projectlombok:lombok:1.18.34'
    testAnnotationProcessor 'org.projectlombok:lombok:1.18.34'
}

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
}
mirai { jvmTarget = JavaVersion.VERSION_11 }

task sourcesJar(type: Jar, dependsOn: classes) {
    archiveClassifier.set("sources")
    from sourceSets.main.allSource
}

artifacts {
    archives sourcesJar
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            // useless for jitpack: groupId = GROUP
            artifactId = "petpet-share"
            // useless for jitpack: version = VERSION

            from components.java
        }
    }
}

jar {
    duplicatesStrategy(DuplicatesStrategy.EXCLUDE)
    manifest {
        attributes 'Main-Class': 'moe.dituon.petpet.Main'
    }
    from {
        (configurations.runtimeClasspath).collect {
            it.isDirectory() ? it : zipTree(it)
        }
    }
}

task wsJar(type: Jar) {
    group = 'build'
    description = 'build jar, excluding the websocket lib & webui'
    archiveClassifier.set("no-ws")

    exclude '**/petpet/websocket/**'
    exclude '**/org/java_websocket/**'
    exclude '**/index.html'

    manifest {
        attributes 'Main-Class': 'moe.dituon.petpet.Main'
    }

    with jar
}

def dataPath = 'data/xmmt.dituon.petpet'
def fontsPathName = 'fonts'
task generateIndexJson {
    def dataSubDirs = new File("$rootDir/$dataPath")
            .listFiles({ file -> file.isDirectory() && file.name != fontsPathName } as FileFilter)

    def dataTemplateNames = dataSubDirs.collect({ dir -> dir.getName() })

    def fontsNames = new File("$rootDir/$dataPath/$fontsPathName")
            .listFiles({ file -> file.isFile() } as FileFilter).collect({ file -> file.getName() })

    def jsonData = [
            version: Float.parseFloat(project.version),
            dataList: dataTemplateNames,
            fontList: fontsNames
    ]

    new File("$rootDir/index.json").withWriter { writer ->
        writer << new groovy.json.JsonBuilder(jsonData).toPrettyString()
    }

    def lengthIndex = dataSubDirs.collectEntries { dir ->
        [
                (dir.getName()): dir.listFiles({ file ->
                    file.isFile() && file.getName().endsWith(".png")
                } as FileFilter)?.length ?: 0
        ]
    }

    def aliasIndex = [:]
    def typeIndex = [:]

    dataSubDirs.each { dir ->
        if (dir.name != fontsPathName) {
            def dataJsonFile = new File("$rootDir/$dataPath/${dir.name}/data.json")
            if (dataJsonFile.exists()) {
                def dataJson = new groovy.json.JsonSlurper().parse(dataJsonFile)
                aliasIndex[dir.name] = dataJson.alias ?: []
                typeIndex[dir.name] = dataJson.type ?: "Unknown"
            } else {
                aliasIndex[dir.name] = []
                typeIndex[dir.name] = "Unknown"
            }
        }
    }

    def indexMapJsonData = new groovy.json.JsonBuilder([
            length: lengthIndex,
            alias: aliasIndex.collectEntries { key, value -> [(key): value] },
            type: typeIndex.collectEntries { key, value -> [(key): value] }
    ]).toString()

    new File("$rootDir/index.map.json").withWriter { writer ->
        writer << indexMapJsonData
    }
}

mirai {
    excludeDependency("org.java-websocket", "Java-WebSocket")
}

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}