build.gradle

//////// General configuration ////////

apply plugin: 'java'
apply plugin: 'scala'

// Compatibility version: Java 21
java {
    sourceCompatibility = JavaVersion.VERSION_21
    targetCompatibility = JavaVersion.VERSION_21
}

// Vaildate Java version
if(JavaVersion.current() < JavaVersion.VERSION_21) {
    throw new GradleException("The engine must be run using >= Java 21 JDK. Detected JDK " + JavaVersion.current())
}

// Directory layout.
sourceSets {
  main {
    java.srcDirs = ["src"]
    java.includes = ["**/*.java"]
    java.destinationDirectory.set(file("$buildDir/classes"))

    scala.srcDirs = ["src"]
    scala.includes = ["**/*.scala"]
    scala.destinationDirectory.set(file("$buildDir/classes"))
  }
  test {
    java.srcDirs = ["test"]
    java.includes = ["**/*.java"]
    java.destinationDirectory.set(file("$buildDir/tests"))

    scala.srcDirs = ["test"]
    scala.includes = ["**/*.scala"]
    scala.destinationDirectory.set(file("$buildDir/tests"))
  }
}


//////// IDE configuration ////////

apply plugin: 'idea'
apply plugin: 'eclipse'

idea {
  module {
    jdkName = 21
    downloadJavadoc = true
    downloadSources = true
  }
}

eclipse {
  classpath {
    downloadJavadoc = true
    downloadSources = true
    defaultOutputDir = new File(project.buildDir, 'classes-eclipse')
  }
}


//////// Versions and Files ////////

ext.versions = [
  battlecodeEngine: new File(projectDir, "engine_version.txt").text.trim(),
  battlecodeClient: new File(projectDir, "client_version.txt").text.trim()
]

ext.python = System.properties['os.name'].toLowerCase().contains('windows') ? 'python' : 'python3'
ext.pythonScript = new File(projectDir, "run.py")
ext.botDirectory = new File(projectDir, "src")

configurations.all {
  resolutionStrategy.cacheDynamicVersionsFor 60, 'seconds'
}

static String[] getVersionsFromWeb(boolean onSaturn) {
  String[] urls = ["https://api.battlecode.org/api/episode/e/bc26/?format=json"]
  String engineVersion = null
  String clientVersion = null
  for (String url : urls) {
    try {
      String episodeInfo = new URL(url).text.trim()
      def json = new groovy.json.JsonSlurper().parseText(episodeInfo)
      if (onSaturn) {
        engineVersion = json.release_version_saturn
      } else {
        engineVersion = json.release_version_public
      }
      clientVersion = json.release_version_client
    } catch (Exception ex) {
      System.out.println("Could not obtain version from " + url)
      System.out.println(ex.toString())
    }
  }
  return [engineVersion, clientVersion]
}

task version {
  description 'Outputs the currently installed version of Battlecode.'
  group 'battlecode'
  doLast {
    logger.quiet("Currently configured engine version: " + versions.battlecodeEngine)
    logger.quiet("Currently configured client version: " + versions.battlecodeClient)
  }
}

task checkNewVersion {
  description 'Checks for a newer version of Battlecode.'
  group 'battlecode'
  doLast {
    def vers = getVersionsFromWeb((project.findProperty("onSaturn") ?: "false").toBoolean())
    def engineVersion = vers[0] ?: versions.battlecodeEngine
    def clientVersion = vers[1] ?: versions.battlecodeClient
    if (versions.battlecodeEngine != engineVersion || versions.battlecodeClient != clientVersion) {
      logger.quiet("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
      logger.quiet("  !!!   NEW BATTLECODE VERSION AVAILABLE   !!!  ")
      logger.quiet("Current engine version: " + versions.battlecodeEngine)
      logger.quiet("New Battlecode engine version:     " + engineVersion)
      logger.quiet("Current client version: " + versions.battlecodeClient)
      logger.quiet("New Battlecode client version:     " + clientVersion)
      logger.quiet("Run './gradlew update' to set new configurations")
      logger.quiet("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
    }
  }
}

task update {
  description 'Updates configurations to use the latest available version of Battlecode.'
  group 'battlecode'
  doLast {
    def vers = getVersionsFromWeb((project.findProperty("onSaturn") ?: "false").toBoolean())
    if (vers[0] == null || vers[1] == null) {
      throw new Exception(
        "Could not find new version number. Are you connected to the internet?"
      )
    }
    if (versions.battlecodeEngine != vers[0]) {
      versions.battlecodeEngine = vers[0]
      new File(projectDir, "engine_version.txt").text = vers[0]
      logger.quiet("Updated engine configuration to use version: " + vers[0])
      logger.warn("Newest dependencies have not yet been downloaded.")
    }
    if (versions.battlecodeClient != vers[1]) {
      versions.battlecodeClient = vers[1]
      new File(projectDir, "client_version.txt").text = vers[1]
      logger.quiet("Updated client configuration to use version: " + vers[1])
      logger.warn("Newest dependencies have not yet been downloaded.")
    }
  }
}

task installPyLocal(type: Exec) {
  description 'Updates configurations to use an already downloaded version of the Python engine.'
  group 'battlecode'
  commandLine python, pythonScript.absolutePath, 'install_current_version',
    '--on-saturn', (project.findProperty("onSaturn") ?: "false").toString(),
    '--force-reinstall', (project.findProperty("forceReinstallPy") ?: "false").toString()
}

//////// Dependencies ////////

repositories {
  // Generic dependencies
  mavenCentral()
}

if ((project.findProperty("onSaturn") ?: "false").toBoolean()) {
  // Saturn: direct access to protected releases.
  repositories {
    maven {
      url "gcs://mitbattlecode-releases/maven"
      content {
        includeGroup 'org.battlecode'
      }
    }
  }
} else {
  // Public Battlecode distribution.
  repositories {
    maven {
      url "https://releases.battlecode.org/maven"
      content {
        includeGroup 'org.battlecode'
      }

      // Optional authentication for local private access
      if (project.hasProperty('gcloudToken')) {
        authentication {
          header(HttpHeaderAuthentication)
        }
        credentials(HttpHeaderCredentials) {
          name = "Authorization"
          value = "Bearer ${project.gcloudToken}"
        }
      }
    }
  }
}


configurations {
  client
}

def os = System.getProperty("os.name").toLowerCase()
def clientName = os.startsWith('windows')
                    ? 'battlecode26-client-win-'
                    : os.startsWith('mac')
                        ? 'battlecode26-client-mac-'
                        : 'battlecode26-client-linux-'
def clientType = project.findProperty("compatibilityClient").toBoolean()
                    ? "electron"
                    : "tauri"

dependencies {
  testImplementation group: 'junit', name: 'junit', version: '4.13.2'

  // The Battlecode engine.
  implementation group: 'org.battlecode', name: 'battlecode26-java', version: versions.battlecodeEngine

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

  // Scala
  implementation group: 'org.scala-lang', name: 'scala-library', version: '2.13.11'
  testImplementation group: 'org.scalatest', name: 'scalatest_2.13', version: '3.2.9'
}


//////// Client ////////

def arch64 = System.getProperty("os.arch").matches("^(x86_64|amd64|ia32e|em64t|x64)\$")
def arch32 = System.getProperty("os.arch").matches("^(x86_32|x86|i[3-6]86|ia32|x32)\$")

if (arch32) {
  logger.error('Sorry, the local Battlecode client does not support 32-bit architectures. Ensure you installed the 64-bit JDK')
}

// Add the unpackClient task, but only do it when we are not on the server
if (!(project.findProperty("onSaturn") ?: "false").toBoolean()) {
  task unpackClient(type: Copy) {
    description 'Downloads the client.'
    group 'battlecode'

    dependsOn configurations.client
    finalizedBy checkNewVersion

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

  build.configure {
    group 'battlecode'
    dependsOn unpackClient
  }
}

task verify(type: JavaExec) {
  description 'Runs basic verifications that a package is valid.'
  group 'battlecode'
  dependsOn build

  mainClass = 'battlecode.instrumenter.Verifier'
  classpath = sourceSets.main.runtimeClasspath
  args = [
    project.findProperty("team") ?: "examplefuncsplayer",
    project.findProperty("url") ?: sourceSets.main.output.classesDirs.getAsPath(),
  ]
}


//////// Running ////////

task downloadPyPackage(type: Exec) {
  description 'Downloads Python dependencies for running matches.'
  group 'battlecode'
  commandLine python, pythonScript.absolutePath, 'update',
        '--on-saturn', (project.findProperty("onSaturn") ?: "false").toString(),
        '--debug', (project.findProperty("debug") ?: "false").toString(),
        '--force-reinstall', (project.findProperty("forceReinstallPy") ?: "false").toString()
}

def truncateString(String input, int maxLength) {
  if (input.length() > maxLength) {
    return input.substring(0, maxLength)
  }
  return input
}

def defaultClassLocation = sourceSets.main.output.classesDirs.getAsPath()
def defaultReplayName = truncateString(project.property('teamA') + '-vs-' + project.property('teamB') + '-on-' + project.property('maps'), 80)
def defaultReplayFile = 'matches/' + defaultReplayName + '.bc26'

task runJavaLocal(type: JavaExec) {
  mainClass = 'battlecode.server.Main'
  classpath = sourceSets.main.runtimeClasspath
  args = ['-c=-']
  jvmArgs = [
    '--add-opens=java.base/jdk.internal.misc=ALL-UNNAMED',
    '--add-opens=java.base/jdk.internal.math=ALL-UNNAMED',
    '--add-opens=java.base/jdk.internal.util=ALL-UNNAMED',
    '--add-opens=java.base/jdk.internal.access=ALL-UNNAMED',
    '--add-opens=java.base/sun.security.action=ALL-UNNAMED',
    '-Dbc.server.wait-for-client=' + (project.findProperty('waitForClient') ?: 'false'),
    '-Dbc.server.mode=headless',
    '-Dbc.server.map-path=maps',
    '-Dbc.server.robot-player-to-system-out=' + (project.findProperty('outputVerbose') ?: 'true'),
    '-Dbc.server.debug=false',
    '-Dbc.engine.debug-methods=' + (project.findProperty('debug') ?: 'false'),
    '-Dbc.engine.enable-profiler=' + (project.findProperty('enableProfiler') ?: 'false'),
    '-Dbc.engine.show-indicators=' + (project.findProperty('showIndicators') ?: 'true'),
    '-Dbc.game.team-a=' + project.property('teamA'),
    '-Dbc.game.team-b=' + project.property('teamB'),
    '-Dbc.game.team-a.language=' + (project.findProperty('languageA') ?: 'java'),
    '-Dbc.game.team-b.language=' + (project.findProperty('languageB') ?: 'java'),
    '-Dbc.game.team-a.url=' + (project.findProperty('classLocationA') ?: defaultClassLocation),
    '-Dbc.game.team-b.url=' + (project.findProperty('classLocationB') ?: defaultClassLocation),
    '-Dbc.game.team-a.package=' + (project.findProperty('packageNameA') ?: project.property('teamA')),
    '-Dbc.game.team-b.package=' + (project.findProperty('packageNameB') ?: project.property('teamB')),
    '-Dbc.game.maps=' + project.property('maps'),
    '-Dbc.server.validate-maps=' + project.property('validateMaps'),
    '-Dbc.server.alternate-order=' + project.property('alternateOrder'),
    '-Dbc.server.save-file=' + (project.findProperty('replay') ?: defaultReplayFile),
  ]
}

task runJava(dependsOn: runJavaLocal) {}

task runPyLocal(type: Exec, dependsOn: installPyLocal) {
  commandLine python, '-m', 'battlecode26',
    '--teamA', project.findProperty('languageA') == 'python' ? project.property('teamA') : '/',
    '--teamB', project.findProperty('languageB') == 'python' ? project.property('teamB') : '/',
    '--dirA', botDirectory.absolutePath,
    '--dirB', botDirectory.absolutePath,
    '--new-process'
}

task runPy(type: Exec) {
  mustRunAfter downloadPyPackage
  commandLine python, '-m', 'battlecode26',
    '--teamA', project.findProperty('languageA') == 'python' ? project.property('teamA') : '/',
    '--teamB', project.findProperty('languageB') == 'python' ? project.property('teamB') : '/',
    '--dirA', botDirectory.absolutePath,
    '--dirB', botDirectory.absolutePath,
    '--new-process'
}

task runLocal {
  description 'Runs a match locally (no updates) without starting the client.'
  group 'battlecode'
  dependsOn runJavaLocal
}

task run {
  description 'Runs a match without starting the client.'
  group 'battlecode'
  dependsOn runJava
}

if (project.findProperty("languageA") == "python" || project.findProperty("languageB") == "python") {
  run.dependsOn downloadPyPackage
  run.dependsOn runPy
  runJava.mustRunAfter runPy
  runLocal.dependsOn installPyLocal
  runLocal.dependsOn runPyLocal
  runJavaLocal.mustRunAfter runPyLocal
}


//////// Informational ////////

task listPlayers {
  description 'Lists all available players.'
  group 'battlecode'

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

task listMaps {
  description 'Lists all available maps.'
  group 'battlecode'

  doLast {
    sourceSets.main.compileClasspath.each {
      logger.debug(it.name)
      if (it.toString().contains('battlecode26-')) {
        FileCollection fc = zipTree(it)
        fc += fileTree(new File(project.projectDir, 'maps'))
        fc.each {
          String fn = it.getName()
          if (fn.endsWith('.map26')) {
            logger.quiet(fn.substring(0, fn.indexOf('.map26')))
          }
        }
      }
    }
  }
}


//////// Submitting ////////

task zipForSubmit(type: Zip) {
  description 'Produce a zip file for submission.'
  group 'battlecode'

  archiveFileName = 'submission.zip'
  destinationDirectory = project.projectDir
  from sourceSets.main.allSource
}