build.gradle

// This is the build file we use to compile and run Battlecode players.
// We're using Gradle: https://gradle.org/

// Gradle's plugins allow it to automatically generate build scripts
// for different types of code. Here we apply the Java plugin, which provides
// all the tools needed to build player code!
apply plugin: 'java'

// The Kotlin plugin allows us to compile Kotlin, source files
apply plugin: 'kotlin'

// The Scala plugin expands upon the Java plugin, allowing us to compile
// Scala source files.
apply plugin: 'scala'

// These plugins allow for this build script to be compatible with IDEs.
apply plugin: 'idea'
apply plugin: 'eclipse'

// Extra tools from battlecode.
apply plugin: 'battlecode'

// Tell gradle that we want Java 8.
sourceCompatibility = 1.8
targetCompatibility = 1.8

// We override Gradle's defaults for project directory layout.
sourceSets {
    main {
        scala.srcDirs = ["src"]
        kotlin.srcDirs = ["src"]
        output.classesDir = "$buildDir/classes"
    }

    test {
        scala.srcDirs = ["test"]
        kotlin.srcDirs = ["test"]
        output.classesDir = "$buildDir/tests"
    }
}

repositories {
    // Let Gradle know about our own repository for hosting Battlecode.
    maven {
        url "http://battlecode-maven.s3-website-us-east-1.amazonaws.com/"
    }

    // Use the JCenter repo to resolve Scala dependencies.
    jcenter()
}

// Mark the client as a special dependency, so that we can handle it separately.
configurations {
    client
}

// Download a different version of the client depending on the local OS.
def os = System.getProperty("os.name").toLowerCase()
def clientName = os.startsWith('windows') ? 'battlecode-client-win' :
                 os.startsWith('mac') ? 'battlecode-client-mac' :
                 'battlecode-client-linux'

// The dependencies of this project.
dependencies {
    // The Battlecode engine.
    compile group: 'org.battlecode', name: 'battlecode', version: versions.battlecode

    // The Battlecode client.
    client group: 'org.battlecode', name: clientName, version: versions.battlecode

    compile "org.jetbrains.kotlin:kotlin-stdlib:$versions.kotlin"

    // Scala!
    compile group: 'org.scala-lang', name: 'scala-library', version: versions.scala
    compile group: 'org.scala-lang', name: 'scala-compiler', version: versions.scala
    compile group: 'org.scala-lang', name: 'scala-reflect', version: versions.scala
}

// Eclipse specific setup to enable docs and sources, and configure layout.
eclipse {
    classpath {
        downloadJavadoc = true
        downloadSources = true

        defaultOutputDir = new File(project.buildDir, 'classes-eclipse')
    }
}

// IntelliJ settings.
idea {
    module {
        downloadSources = true
        downloadJavadoc = true
    }
}

// Default configuration for running matches.
if (!project.hasProperty("teamA")) {
    ext.teamA = "examplefuncsplayer"
}
if (!project.hasProperty("teamB")) {
    ext.teamB = "examplefuncsplayer"
}
if (!project.hasProperty("maps")) {
    ext.maps = "shrine"
}

// Here we define a task. Tasks like this one, 'unpackClient', can be
// executed in the terminal with `./gradlew unpackClient` in Unix or
// `gradlew unpackClient` in Windows.
task unpackClient(type: Copy, dependsOn: configurations.client) {
    description 'Downloads the client.'
    group 'battlecode'

    dependsOn configurations.client

    from {
        configurations.client.collect {
            zipTree(it)
        }
    }
    into 'client/'
}

build.group = 'battlecode'
build.dependsOn('unpackClient')

// Another task. This one accepts three optional parameters, or "properties",
// corresponding to the bots used by the two teams, and the map(s) used in this
// game. These properties can be set in the command line with:
// On windows:
//   `gradlew -PteamA=<team A bot> -PteamB=<team B bot> -Pmaps=<comma
//   separated list of maps>`
// On OS X and Linux:
//   `./gradlew -PteamA=<team A bot> -PteamB=<team B bot> -Pmaps=<comma
//   separated list of maps>`
task run(type: JavaExec, dependsOn: 'build') {
    description 'Runs a match without starting the client.'
    group 'battlecode'

    main = 'battlecode.server.Main'
    classpath = sourceSets.main.runtimeClasspath
    args = ['-c=-']
    jvmArgs = [
        '-Dbc.server.mode=headless',
        '-Dbc.server.map-path=maps',
        '-Dbc.server.debug=true',
        '-Dbc.engine.debug-methods=true',
        '-Dbc.game.team-a='+project.property('teamA'),
        '-Dbc.game.team-b='+project.property('teamB'),
        '-Dbc.game.team-a.url='+sourceSets.main.output.classesDir,
        '-Dbc.game.team-b.url='+sourceSets.main.output.classesDir,
        '-Dbc.game.maps='+project.property('maps'),
        '-Dbc.server.save-file=' + 'matches/' + project.property('teamA') + '-vs-' + project.property('teamB') + '-on-' + project.property('maps') + '.bc17'
    ]
}

// Same as above, but with all the logging disabled...
task runQuiet(type: JavaExec, dependsOn: 'build') {
    description 'Runs a match without starting the client and without debug logs'
    group 'battlecode'

    main = 'battlecode.server.Main'
    classpath = sourceSets.main.runtimeClasspath
    args = ['-c=-']
    jvmArgs = [
        '-Dbc.server.mode=headless',
        '-Dbc.server.map-path=maps',
        '-Dbc.server.debug=false',
        '-Dbc.engine.debug-methods=false',
        '-Dbc.engine.silence-a=true',
        '-Dbc.engine.silence-b=true',
        '-Dbc.game.team-a='+project.property('teamA'),
        '-Dbc.game.team-b='+project.property('teamB'),
        '-Dbc.game.team-a.url='+sourceSets.main.output.classesDir,
        '-Dbc.game.team-b.url='+sourceSets.main.output.classesDir,
        '-Dbc.game.maps='+project.property('maps'),
        '-Dbc.server.save-file=' + 'matches/' + project.property('teamA') + '-vs-' + project.property('teamB') + '-on-' + project.property('maps') + '.bc17'
    ]
}

// This task prints out all available players, in the format that the `run`
// task expects them to be given as.
task listPlayers {
    description 'Lists all available players.'
    group 'battlecode'

    doLast {
        sourceSets.main.allSource.each {
            if (it.getName().equals('RobotPlayer.java')
                || it.getName().equals('RobotPlayer.kt')
                || it.getName().equals('RobotPlayer.scala')) {
                URI base = new File(project.projectDir, 'src').toURI()
                URI full = it.toURI()
                String path = base.relativize(full).toString()
                println 'PLAYER: '+path.substring(0, path.lastIndexOf('/')).replaceAll('/', '.')
            }
        }
    }
}

// This task prints out all available maps, in the format that the `run` task
// expects them to be given as.
task listMaps {
    description 'Lists all available maps.'
    group 'battlecode'

    doLast {
        sourceSets.main.compileClasspath.each {
            if (it.toString().contains('battlecode-2017')) {
                FileCollection fc = zipTree(it)
                fc += fileTree(new File(project.projectDir, 'maps'))
                fc.each {
                    String fn = it.getName()
                    if (fn.endsWith('.map17')) {
                        println 'MAP: '+fn.substring(0, fn.indexOf('.map17'))
                    }
                }
            }
        }
    }
}

// This task prepares player code for upload, assembling it into a Java archive.
// This archive can be uploaded at `www.battlecode.org`.
task jarForUpload(type: Jar) {
    description 'Assembles source code into an archive, ready to be uploaded to the Battlecode site.'
    group 'battlecode'

    from sourceSets.main.scala.srcDirs
    destinationDir = project.projectDir
    archiveName = 'battlecode-player-upload.jar'
}

// Battlecode updates a lot.
// We should make sure to check for new dependencies frequently.
configurations.all {
    // Check for updates every build.
    resolutionStrategy.cacheDynamicVersionsFor 60, 'seconds'
}


// We need to download the battlecode plugin before we can run the build script; this does that.
buildscript {
    ext.versions = [
        battlecode: '2017.+',
        kotlin: '1.0.6',
        scala: '2.11.7'
    ]

    repositories {
        maven {
            url "http://battlecode-maven-test-aaarblgarbl.s3-website-us-east-1.amazonaws.com/"
        }
        jcenter()
    }
    dependencies {
        // Load the battlecode plugin onto the classpath.
        classpath group: 'org.battlecode', name: 'battlecode-gradle-plugin', version: versions.battlecode
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$versions.kotlin"
    }
    configurations.all {
        // Check for updates every build.
        resolutionStrategy.cacheDynamicVersionsFor 60, 'seconds'
    }
}