总览
这是一场机器人大战，看谁能生存最长。但是，这些漫游器会通过受到攻击来增强其功能，因此在拍摄前您需要仔细考虑。
每回合，您都可以选择要攻击或防御的机器人。攻击会缩短其生命并增加力量。最后一个机器人站获胜。
机器人
每个机器人以1000生命和10力量开始。
受到攻击时：
- 从你的生命中减去攻击者的力量
- 你的力量提高1。
因此，如果在第一回合中受到两个机器人的攻击，则您将拥有980点生命和12点力量。
如果您选择捍卫：
- 你的力量会降低1
- 此回合对您的所有攻击将减少一半
- 如果您受到攻击，则每个攻击者将获得2点力量，而不是1点
因此，如果您在第一回合防御并受到两个机器人的攻击，您将拥有990点生命和13点力量。如果您防御并且没有受到攻击，那么您将拥有1000点生命，但是只有9点力量。
如果转弯结束时您的力量小于1，则将其设置为1。如果您的生命低于1，您将死亡。
输入输出
机器人每回合叫一次。每转一圈有一个时间限制。
初始
第一次调用您的漫游器时，将不会给出任何参数。回应ok。这样做只是为了确保您的机器人能够响应。如果没有，它将不会被添加到播放器列表中。
每转
每回合，您的机器人都将获得有关游戏中所有机器人的信息作为命令行参数。这些参数的一个示例是：
1 0,1000,10,1 1,995,11,D
第一个参数是您的漫游器的唯一ID。然后，出现一个用空格分隔的漫游器列表。每个漫游器的格式为：
id,life,power,lastAction
lastAction可以是一个整数，表示他们攻击了哪个机器人，D是否防御了，以及X这是否是第一回合。其他都是整数。
因此，在上面的示例中，您1在最后一轮被机器人保护。Bot 0攻击了您，并且仍然处于启动状态。
每转的输出非常简单。只需将您要攻击的机器人输出为整数（例如0或3）或D进行防御即可。不要攻击已死亡或不存在的机器人，因为这将视为无效命令。任何无效的命令都将导致您失去1次电源。
比赛结构
每个游戏都包含以1000生命值和10力量开始的所有机器人。所有漫游器均同时采取措施。游戏的最大回合数为1000。
如果在回合结束时仍有一个机器人存活（生命> 0），则该机器人将获得1分并开始另一场比赛。如果达到转弯限制，并且有多个机器人处于活动状态，那么没人会得到积分。如果所有剩余的漫游器都死于同一回合，则没有人获得分数。
锦标赛包括15场比赛。最后谁得分最高者获胜！每种获胜游戏中剩余的生命总和打破关系。
州
漫游器只能在名为state（“ Hero”可以写入state/hero.whatever）的直接子文件夹中读取或写入以自身命名的单个文件。该文件的大小不得超过1024 2个字节。注意遵守时间限制。您的程序必须在一秒内终止才能计数，而不仅仅是给出响应。
这些文件将在每次锦标赛前擦除，但会在每个游戏中持续存在。id游戏之间的所有漫游器标识符（）也将保持不变。
控制者
以下是比赛控制器（Stronger.java）。默认情况下，它仅输出最终结果（排序的玩家列表，优胜者排在首位），这可能需要一段时间。它没有冻结，只是保持沉默。如果您想要更详细的转弯输出，请-log在运行时添加参数。
要添加机器人，您有两种选择：
将命令添加为参数（
java Stronger -log "python bot.py"）将命令添加到
defaultPlayers[]源代码（"python bot.py"）中
机器人Hero，Bully和Coward可以在此答案中找到，并将用于评分目的。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Stronger {
static final String[] defaultPlayers = {
"java Hero",
"java Bully",
"java Coward"
};
final int timeout = 1000;
final int startLife = 1000;
final int startPower = 10;
final int numRounds = 15;
boolean log = false;
List<Player> players;
public static void main(String[] args){
new Stronger().run(args);
}
void run(String[] args){
init(args);
for(int i=0;i<numRounds;i++){
Collections.shuffle(players);
runGame();
}
Collections.sort(players);
for(Player player : players)
System.out.println(player.toString());
}
void runGame(){
log("Player Count: " + players.size());
for(Player player : players)
player.reset();
int turn = 0;
while(turn++ < startLife){
if(aliveCount() < 2)
break;
log("Turn " + turn);
List<Player> clones = new ArrayList<Player>();
for(Player player : players)
clones.add(player.copy());
for(Player player : players){
if(player.life < 1 || player.timedOut)
continue;
String[] args = new String[players.size()+1];
args[0] = "" + player.id;
for(int i=1;i<args.length;i++)
args[i] = players.get(i-1).toArgument();
String reply = getReply(player, args);
Player clone = player.findCopyOrMe(clones);
if(reply.equals("T")){
clone.timedOut = true;
clone.life = 0;
}
clone.lastAction = reply.trim();
}
for(Player player : players){
if(player.life < 1 || player.timedOut)
continue;
Player clone = player.findCopyOrMe(clones);
if(clone.lastAction.equals("D")){
clone.power--;
}else{
try{
int target = Integer.parseInt(clone.lastAction);
for(Player t : players)
if(t.id == target && t.life < 1)
throw new Exception();
for(Player tclone : clones){
if(tclone.id == target){
int atk = player.power;
if(tclone.lastAction.equals("D")){
atk -= player.power / 2;
tclone.power++;
}
tclone.life -= atk;
tclone.power++;
}
}
} catch (Exception e){
log(player.cmd + " returned an invalid command: (" + clone.lastAction + ")");
clone.power--;
}
}
}
players = clones;
for(Player player : players){
if(player.power < 1)
player.power = 1;
log(player.life + "\t\t" + player.power + "\t\t(" + player.id + ")\t" + player.cmd);
}
log("\n");
}
if(aliveCount() == 1)
for(Player player : players)
if(player.life > 0){
player.scoreRounds++;
player.scoreLife += player.life;
}
}
void log(String msg){if(log)System.out.println(msg);}
String getReply(Player player, String[] args){
try{
List<String> cmd = new ArrayList<String>();
String[] tokens = player.cmd.split(" ");
for(String token : tokens)
cmd.add(token);
for(String arg : args)
cmd.add(arg);
ProcessBuilder builder = new ProcessBuilder(cmd);
builder.redirectErrorStream();
long start = System.currentTimeMillis();
Process process = builder.start();
Scanner scanner = new Scanner(process.getInputStream());
process.waitFor();
String reply = scanner.nextLine();
scanner.close();
process.destroy();
if(System.currentTimeMillis() - start > timeout)
return "T";
return reply;
}catch(Exception e){
e.printStackTrace();
return "Exception: " + e.getMessage();
}
}
void init(String[] args){
players = new ArrayList<Player>();
for(String arg : args){
if(arg.toLowerCase().startsWith("-log")){
log = true;
}else{
Player player = createPlayer(arg);
if(player != null)
players.add(player);
}
}
for(String cmd : defaultPlayers){
Player player = createPlayer(cmd);
if(player != null)
players.add(player);
}
}
Player createPlayer(String cmd){
Player player = new Player(cmd);
String reply = getReply(player, new String[]{});
log(player.cmd + " " + reply);
if(reply != null && reply.equals("ok"))
return player;
return null;
}
int aliveCount(){
int alive = 0;;
for(Player player : players)
if(player.life > 0)
alive++;
return alive;
}
static int nextId = 0;
class Player implements Comparable<Player>{
int id, life, power, scoreRounds, scoreLife;
boolean timedOut;
String cmd, lastAction;
Player(String cmd){
this.cmd = cmd;
id = nextId++;
scoreRounds = 0;
scoreLife = 0;
reset();
}
public Player copy(){
Player copy = new Player(cmd);
copy.id = id;
copy.life = life;
copy.power = power;
copy.scoreRounds = scoreRounds;
copy.scoreLife = scoreLife;
copy.lastAction = lastAction;
return copy;
}
void reset(){
life = startLife;
power = startPower;
lastAction = "X";
timedOut = false;
}
Player findCopyOrMe(List<Player> copies){
for(Player copy : copies)
if(copy.id == id)
return copy;
return this;
}
public int compareTo(Player other){
if(scoreRounds == other.scoreRounds)
return other.scoreLife - scoreLife;
return other.scoreRounds - scoreRounds;
}
public String toArgument(){
return id + "," + life + "," + power + "," + lastAction;
}
public String toString(){
String out = "" + scoreRounds + "\t" + scoreLife;
while(out.length() < 20)
out += " ";
return out + "(" + id + ")\t" + cmd;
}
}
}
规则
您最多可以输入两个机器人。如果您想从游戏中删除一个来输入第三个，请删除其帖子。
您不能通过荟萃分析来定位或以其他方式选出机器人。仅使用您的漫游器所提供的信息。这包括您自己的机器人，因此您不能输入两个相互勾结的机器人。
请勿尝试以任何方式干扰控制器或其他机器人的运行。
您的机器人可能无法实例化或以其他方式运行控制器或其他机器人。
结果
（截至2015年5月22日00：00：00Z提交的漫游器数量）
这轮比赛进行得更好，只有两场比赛在1000转时停顿。拉尔夫·马歇尔（Ralph Marshall）的桑塔亚娜（Santyana）赢得了第一名，是唯一获得三场胜利的机器人。那还不够，所以他在Tactician上也获得了第三名。Stormcrow的Phantom Menace排名第二，在这里排名第一。总而言之，新成员的表现非常不错，排名前六位的职位少于五个职位。恭喜，欢迎光临本站！
赢得零分的机器人没有列出，以节省空间。上面时间戳之前发布的所有漫游器均已运行，因此，如果您看不到自己的漫游器，则它不会赢得任何收益。
Wins Life(tiebreaker) Name
3 561 perl Santayana.pl
2 850 java PhantomMenace
2 692 perl Tactician.pl
2 524 java Wiisniper
1 227 java Tank
1 184 java Velociraptor
1 7 java Coward
1 3 java IKnowYou
Sorta粗略并行控制器（由他人提供）：
import java.lang.ProcessBuilder.Redirect;
import java.nio.file.FileSystems;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.atomic.AtomicInteger;
public class Stronger {
static final String[] defaultPlayers = {
"java Hero",
"java Bully",
"java Coward",
"java Psycho",
"./monte.out",
"java Analyst",
"java Guardian",
"java Revenger",
"python precog.py",
//"python snappingTurtle.py",
"python beserker.py",
"./suprise.out",
//"python boxer.py",
"python defense.py",
"java Tank",
"java IKnowYou",
//"java BroBot",
"java Equaliser",
"java Velociraptor",
//"java AboveAverage",
"java PhantomMenace",
"java Wiisniper",
//"python semiRandom.py",
"/usr/bin/perl tactition.pl",
"/usr/bin/perl santayana.pl",
//"java GlitchUser"
"/usr/local/bin/Rscript opportunity.R",
"/usr/local/bin/scala Bandwagoner",
};
final int timeout = 5000;
final int startLife = 1000;
final int startPower = 10;
final int numRounds = 20;
boolean log = true;
List<Player> players;
public static void main(String[] args){
new Stronger().run(args);
}
void run(String[] args){
init(args);
for(int i=1;i<=numRounds;i++){
if(log) System.out.println("Begining round "+ i);
Collections.shuffle(players);
runGame();
}
Collections.sort(players);
for(Player player : players)
System.out.println(player.toString());
}
void runGame(){
log("Player Count: " + players.size());
for(Player player : players)
player.reset();
int turn = 0;
while(turn++ < startLife){
if(aliveCount() < 2)
break;
log("Turn " + turn);
List<Player> clones = new ArrayList<Player>();
for(Player player : players)
clones.add(player.copy());
AtomicInteger count=new AtomicInteger(players.size());
for(Player player : players){
new Thread(() -> {
if(player.life >= 1 && !player.timedOut){
String[] args = new String[players.size()+1];
args[0] = "" + player.id;
for(int i=1;i<args.length;i++)
args[i] = players.get(i-1).toArgument();
String reply = getReply(player, args);
Player clone = player.findCopyOrMe(clones);
if(reply.equals("T")){
clone.timedOut = true;
clone.life = 0;
}
clone.lastAction = reply.trim();
}
synchronized(count){
count.decrementAndGet();
count.notify();
}
}).start();
}
synchronized(count){
while(count.get() > 0){
//System.out.println(count);
try{
count.wait();
}catch(InterruptedException e){
}
}
}
for(Player player : players){
if(player.life < 1 || player.timedOut)
continue;
Player clone = player.findCopyOrMe(clones);
if(clone.lastAction.equals("D")){
clone.power--;
}else{
try{
int target = Integer.parseInt(clone.lastAction);
for(Player t : players)
if(t.id == target && t.life < 1)
throw new Exception();
for(Player tclone : clones){
if(tclone.id == target){
int atk = player.power;
if(tclone.lastAction.equals("D")){
atk -= player.power / 2;
tclone.power++;
}
tclone.life -= atk;
tclone.power++;
}
}
} catch (Exception e){
log(player.cmd + " returned an invalid command: (" + clone.lastAction + ")");
clone.power--;
}
}
}
players = clones;
for(Player player : players){
if(player.power < 1)
player.power = 1;
log(player.life + "\t\t" + player.power + "\t\t" + player.lastAction + "\t\t(" + player.id + ")\t" + player.cmd);
}
log("\n");
}
if(aliveCount() == 1)
for(Player player : players)
if(player.life > 0){
player.scoreRounds++;
player.scoreLife += player.life;
}
}
void log(String msg){if(log)System.out.println(msg);}
String getReply(Player player, String[] args){
try{
List<String> cmd = new ArrayList<String>();
String[] tokens = player.cmd.split(" ");
for(String token : tokens)
cmd.add(token);
for(String arg : args)
cmd.add(arg);
ProcessBuilder builder = new ProcessBuilder(cmd);
builder.directory(FileSystems.getDefault().getPath(".", "bin").toFile());
//builder.redirectError(Redirect.PIPE);
long start = System.currentTimeMillis();
Process process = builder.start();
Scanner scanner = new Scanner(process.getInputStream());
process.waitFor();
String reply = scanner.nextLine();
scanner.close();
process.destroy();
if(System.currentTimeMillis() - start > timeout)
return "T";
return reply;
}catch(Exception e){
//e.printStackTrace();
return "Exception: " + e.getMessage();
}
}
void init(String[] args){
players = new ArrayList<Player>();
for(String arg : args){
if(arg.toLowerCase().startsWith("-log")){
log = true;
}else{
Player player = createPlayer(arg);
if(player != null)
players.add(player);
}
}
for(String cmd : defaultPlayers){
Player player = createPlayer(cmd);
if(player != null)
players.add(player);
}
}
Player createPlayer(String cmd){
Player player = new Player(cmd);
String reply = getReply(player, new String[]{});
log(player.cmd + " " + reply);
if(reply != null && reply.equals("ok"))
return player;
return null;
}
int aliveCount(){
int alive = 0;;
for(Player player : players)
if(player.life > 0)
alive++;
return alive;
}
static int nextId = 0;
class Player implements Comparable<Player>{
int id, life, power, scoreRounds, scoreLife;
boolean timedOut;
String cmd, lastAction;
Player(String cmd){
this.cmd = cmd;
id = nextId++;
scoreRounds = 0;
scoreLife = 0;
reset();
}
public Player copy(){
Player copy = new Player(cmd);
copy.id = id;
copy.life = life;
copy.power = power;
copy.scoreRounds = scoreRounds;
copy.scoreLife = scoreLife;
copy.lastAction = lastAction;
return copy;
}
void reset(){
life = startLife;
power = startPower;
lastAction = "X";
timedOut = false;
}
Player findCopyOrMe(List<Player> copies){
for(Player copy : copies)
if(copy.id == id)
return copy;
return this;
}
public int compareTo(Player other){
if(scoreRounds == other.scoreRounds)
return other.scoreLife - scoreLife;
return other.scoreRounds - scoreRounds;
}
public String toArgument(){
return id + "," + life + "," + power + "," + lastAction;
}
public String toString(){
String out = "" + scoreRounds + "\t" + scoreLife;
while(out.length() < 20)
out += " ";
return out + "(" + id + ")\t" + cmd;
}
}
}
2
@Tim机器人列表以空格分隔。每个漫游器的统计信息以逗号分隔。
—
Geobits，2015年
@Mark当前的机器人大约一半防御方向，一半攻击。防御性机器人都没有一个赢家。我同意它鼓励某种防御，但是侵略的好处在于，纯粹的防御根本无法赢得任何分。只有您是唯一的幸存者，您才能赢得积分。
—
Geobits
如果有人想知道现在有更多提交者，僵尸程序如何堆积起来，那么这就是我的“非正式”测试运行的结果：3-809-英雄；2-593-Velociraptor; 1-471-SurpriseBot; 1-433-ward夫; 1-371-Santayana; 1-364-威斯尼珀; 1-262-分析师；1-230-Bully；1-132-均衡器；1-71-IKnowYou; 0-0-precog，Berserker，BroBot，SemiRandom，MonteBot，Tactician，SnappingTurtle，Psycho，Revenger，机会，PhantomMenace，坦克，Boxer，Guardian，AverageAverage，DefensiveBot。来自Opportunity，AboveAvg，BroBot，Boxer和SemiRandom的许多无效命令。
—
OJFord
我有一个并行版本的控制器，它比原始控制器运行游戏的速度更快，如果有人有兴趣的话，我可以发布它...
—
其他
@Manu只要没有同时执行每个机器人，就没有关系。我认为并行版本仍然让所有漫游器先转一圈然后再转到下一个。就像我说的，如果要发布，我将在使用前进行验证。
—
Geobits，2015年