代码机器人

我讨厌私有和保护变量。我只想访问任何东西！

如果您像我一样，那么这个挑战就是给您的！

编写一个~~与其他机器人协调工作的机器人，~~使其他机器人按您的意愿工作。您是一名程序员，并且您知道应该如何工作。您的工作是将尽可能多的其他漫游器转换为您的方式。

代码

您将有24行代码来编写您的机器人。每回合，每个漫游器将顺序执行1行。

每个漫游器A通过都存储5个变量E。 A并且B供个人使用，C存储要执行的下一行，D存储当前方向，并且E是一个随机数。变量从0开始，除了除外D，后者将从一个随机值开始。所有变量仅存储0-23。更大或更小的数字将被24调制。

在这篇文章中，我将使用对手作为您面临的相邻机器人

每行必须包含以下5个命令之一：

Flag什么也没做。除了这是你赢的方式
Move将您的漫游器移向Dth方向。如果机器人已经占据了空间，则不会发生任何移动
Copy Var1 Var2 将Var1的内容复制到Var2
If Condition Line1 Line2 如果Condition为true，则执行Line1，否则执行Line2
Block Var1 阻止对变量的下一次写入

变量可以如下使用：

#Var将使用该变量作为行号。如果A为17，Copy #8 #A则将第8行的内容复制到第17行。 *Var将使用对手的变量。 Copy 5 *C将对手的C变量设置为5 Var+Var将两个变量相加。 Copy D+1 D会将机器人向右旋转

当D用作指示时，[North, East, South, West][D%4]将被使用

这些修饰符可以链接在一起：Copy *#*C #9将对手将执行的下一行复制到第9行的自己的代码中。 **D是指对手的对手D变量。

条件的评估如下：

如果Var：
1. 如果Var A通过C，则如果Var非零，它将返回true，否则返回false。
2. 如果Var是D，则如果在此D方向上有机器人，则它将返回true ，否则返回false
3. 如果Var为E，如果E为奇数，则返回true，否则返回false
4. 如果Var是一行，则如果它是Flag行，它将返回true
如果Var1=Var2：
1. 如果两个都是A-E，并且等于相同的数字，则返回true
2. 如果两者都是线，并且线型相等，则返回true
如果Var1==Var2：
1. 如果两个都是A-E，并且等于相同的数字，则返回true
2. 如果两个都是行且相同，则返回true（来自不同机器人的标志将不相等）

每种类型的50个机器人将以以下方式放置在环形世界中：

B...B...B...B...
..B...B...B...B.
B...B...B...B...
..B...B...B...B.

每次进行5,000转后，将计算每个机器人上的标志。如果一个机器人具有比其他任何类型的标志更多的标志，您将获得一个分数。如果N机器人之间出现平局，则不会给出任何分数。

将有10场比赛，最后将累积分数。

旁注

行尾注释是允许的，并用表示 //

尝试执行无意义的操作（例如添加到行中）将无济于事

尝试在不存在的机器人上做某事将无济于事

在`If`will 上进行无限递归而没有执行任何行

If 不会改变 C

Block直到有人尝试写入它，A 才会过期

可以一次阻止多个变量和行

Block只要第二个block语句与第一个语句位于不同的代码行，则多次将变量阻塞多次

仅在参数之间（以及命令之后）允许有空格

如果漫游器少于24行，则Flag将是其余的行。

样例程序

Copy 2 C        //Skip to the If line
Flag            //Where I'm storing my flag
Move            //Move in the D'th direction
If D #5 #2      //If there's a bot, copy code, otherwise, move!
Copy #1 *#E     //Copy my flag onto a random spot in my bot's code
Copy 2 C        //Skip back to the If line

该程序将由我的Python控制器在此处运行。

Java控制器就在这里， 它速度很快，并且看起来比python更好。

计分板：

king-of-the-hill

— 内森·美林（Nathan Merrill）
source

1

Java可供我测试后，我将全力以赴。

— Wasmoo 2014年

2

我假设您从未玩过核心战争。en.wikipedia.org/wiki/Core_War

— matt_black

我没有玩过，但是在编写挑战时我读了很多。

— 弥敦道·美林

我有一个适用于Python控制器的补丁，试图在github上将其推回给您...但是我没有权限/不太了解git。补丁程序将所有“ 16”替换为“ num_lines”，以允许对最后8条指令进行写/跳转访问；还会从clarify_flags（）的平局条件中删除“ max_flag_count = 0”，该条件有时会向第三台机器人授予双向平局。

— 2014年

1

下一场战斗将进行的任何预计到达时间？一点都不着急。我只是好奇。谢谢。

— COTO 2014年

13

旗杆机器人

Flag

当其他机器人变得足够好以给我他们的代码时，为什么还要做任何事情呢？

— 斯帕
source

8

冻结标签

Move
If D #3 #2
Copy 23 C
Copy 3 C
Copy #23 *#*C
Copy #21 *#*C+1
Copy #22 *#*C+2
Copy #21 *#*C+3
Copy #22 *#*C+4
Copy #21 *#*C+5
Copy #22 *#*C+6
Copy #21 *#*C+7
Copy #22 *#*C+8
Copy #21 *#*C+9
Copy #22 *#*C+10
Copy #21 *#*C+11
Copy #22 *#*C+12
Copy #21 *#*C+13
Copy #22 *#*C+14
Copy D+1 D
Copy 0 C
Flag
Flag
Copy C+23 C

圈住对手，用旗帜填满他，继续前进到下一个对手。

— 斯帕
source

Copy C+23 C这必须是最恶意的代码xD行。

— Cruncher 2014年

我很感兴趣。这可能是可改进的。与其在其中填充标志，不如在其中添加一个循环以使其自身充满标志？还是那不算作您的标志？

— Cruncher 2014年

这是一个整洁可行的想法，但更为复杂。您应该编写一个使用它的机器人：)

— Sparr，2014年

2

您知道最后一个问题的答案吗？Or would that not count as your flags?。因为如果它们不算作您自己的标志，那绝对不是一个好的解决方案

— Cruncher 2014年

@Cruncher，您可以给他们一个标志，并使其复制，这将算作您的标志之一。

— Sparr 2014年

8

寄生虫

为什么要杀死其他机器人？该机器人通过查看对手的代码，仅替换标志。

Copy 1 A
Copy E D
Block #A
If *#A #C+3 #C
Copy A+A+A+A+A A
Copy C+19 C
Copy #C+4 *#A
Flag
Copy 1 A
Copy E D
Block #A
If *#A #C+3 #C
Copy A+A+A+A+A A
Copy C+19 C
Copy #C+4 *#A
Flag
Copy 1 A
Copy E D
Block #A
If *#A #C+3 #C
Copy A+A+A+A+A A
Copy C+19 C
Copy #C+4 *#A
Flag

— 皮诺皮
source

8

$复制

该机器人使用的技术与COTO的洛克希德（Lockheed）相同，因此我会毫不客气地借鉴和增强。

这利用了 C漏洞来打破障碍，甚至使中和器逆转。因此，它也以绝对形式编写。我认为，如果C恢复转移，可能会破坏这种情况，但是只要转移是恒定的，就可以对其进行重写以应对它。

无论出于何种原因，最后都缺少循环，使该机器人非常出色。

Block #C+A 
If D #7 #13        //If [enemy] Copy 0 ELSE block
If D #8 #0         //If [enemy] Freeze 0 ELSE block
If D #9 #6         //If [enemy] FreezeCheck ELSE Inc
Move
Copy 0 C
Copy A+5 A          //Inc
Copy 23 *C          //Copy 0
Copy #10 *#*C+23    //FreezeAttack
If *#*C==#10 #11 #5 //FreezeCheck: If [frozen] GOTO Copy Attack ELSE GOTO [1]
Copy C+23 C         //FREEZE
Copy 13 C           //GOTO Copy Attack
Copy 15 C           //Loop Copy Attack
Block #C+A
Copy D+3 *D             //Copy Attack: Spin Enemy
Copy 0 *B               //Set enemy counter (a la COTO)
Copy #*B+0 *#*C+*B+1    //Copy my lines
Copy #*B+1 *#*C+*B+2    //Copy my lines
Copy #*B+2 *#*C+*B+3    //Copy my lines
Copy *B+3 *B            //Inc counter
If *B==0 #19 #12        //Loop check
Copy D+1 D              //Turn myself

— 瓦斯穆
source

1

我将鞠躬接受您的改进设计，并在Bots v。3竞赛中再次与您面对。;）

— COTO 2014年

老实说，我相信这是每个人的共同努力。如果没有几个机器人可以以此为模型，这将不存在。有趣的是，此机器人的添加完全重新组织了计分板，因为依赖于阻塞的机器人被打破了，而其他依赖于标记替换的机器人则上升了。

— Wasmoo 2014年

有人可以在某处总结Block的实际行为以及该机器人和Lockheed如何利用它吗？

— Sparr 2014年

如HappyAsAClam所述，每行可以产生块。最重要的是，它并不能叠加名为具有相同的块C值。因此，从If语句调用时可以堆叠一个块，这就是此处使用的漏洞利用方法。$ Copy通过Copy在同一行上一遍又一遍地执行直到成功，从而打破了块（如蛤lam），这使其比Lockheed具有优势。

— Wasmoo 2014年

7

洛克希德

我第三次（也可能是最后一次）提交给这场特别的机器人大战：洛克希德反应堆，简称“洛克希德”。

Block #C+A
If D #C+7 #C+1
Block #C+A
Move
Copy A+5 A
If A==0 #C+12 #C+21
Copy C+17 C
Copy D+3 *D
Copy C+9 C
Copy C+21 C
Copy C+23 C
Copy #C+23 *#*C+2
Copy #C+22 *#*C+1
Copy 0 *A
Copy #*A+C+9 *#*C+*A+1
Copy *A+1 *A
If *A==0 #C+15 #C+17
Copy D+1 D
Copy C+5 C

特别感谢@Wasmoo，他分享了他的发现：“只要第二个block语句与您的第一个代码行不在同一行，多次阻塞变量将多次阻塞。” 根本不是真的”漏洞。我大量使用它。

另外，还要感谢Nathan Merill主持比赛并发布模拟器。该模拟器在调整机器人方面绝对是无价之宝。如果不亲眼目睹它，我将不会相信，但是添加或删除概念上最次要的机器人功能可能意味着成功与失败之间的区别。我为这是否一件好事感到沮丧。

— 首席技术官
source

多次阻止变量确实失败。但是，只有在以下情况下，它才会阻止：您正在执行同一行（If指向该行不会失败），您正在阻止相同的值（单行可以使用递增变量来阻止1-24行），并且区块尚未发布（有人试图修改该变量）

— Nathan Merrill

我对OP中的语句提出质疑，因为阻塞指令是键到IP的，而不是阻塞语句。因此，单个块语句可以在所有指令上建立多达24个单独的块。我认为OP中的子句“只要第二个语句块与第一个语句块不在同一行上”应修改为“只要对（C，<block target>）语句块尚未生效”。也就是说，block语句所在的行与堆栈无关，除非直接执行该块C=块指令地址。

— COTO 2014年

1

这个机器人太神奇了！它将所有最佳概念组合在一起。它会保护自己直到找到敌人为止，然后对敌人进行两次冰冻并将其自身副本上载到目标上，然后再朝相反的方向释放它。在模拟中，我看到其中一个副本修复了已损坏的原件。哇！干得好，COTO！

— Wasmoo 2014年

6

进攻还是其他

看到像拜占庭这样的防御性机器人表现如此出色，我决定也制造一个防御性机器人。

根据敌人是否存在，这有两种模式。

如果不存在敌人，它将阻挡其路线3圈，然后移动。
如果敌人存在，~~它将在复制其标志和复制代码之间交替进行，这将导致敌人复制该标志（弱复制器）~~并复制其标志
在循环结束时，它将变为随机方向并继续
其代码的大多数方面都是重复的

更多测试显示了一些重要概念：

“随机转弯”的效果比“向右转”要好得多（比替代方案高2700）
块增量 A+7比其他任何增量都有效（+200在下一个最佳位置上）
与“弱复制器”相比，“直接攻击”要好（替代品+900）
与其他组合相比，对“ 3-1-2-1”的防御更好（次佳防御为+200）
重复的攻击，阻止和循环代码提高了得分（比未重复的攻击代码提高了300）
重复的块增量不会提高得分（重复的+400）

通过Java UI以图形方式观察仿真很有帮助。谢谢！下面是新的和改进的代码。我认为我无能为力了。

Block #C+A          //Dynamic block for If statements
If D #20 #0
If D #19 #8
If D #20 #23
If D #19 #0
If D #20 #8
If D #19 #23
Copy A+7 A          //Increment dynamic block
Block #C+A          //Dynamic block for If statements
If D #19 #8
If D #20 #0
If D #19 #8
If D #20 #23
If D #19 #8
If D #20 #0
If D #19 #23
Copy E D            //Turn Random
Copy 23 C           //Loop to beginning
Copy 23 C           //Loop to beginning
Copy #22 *#*C+1     //Copy my flag to the enemy's next
Copy #21 *#*C+1     //Copy my flag to the enemy's next
Flag
Flag
Move

— 瓦斯穆
source

这个机器人确实很棒。欢迎您使用GUI。

— 内森·美林

我对其进行了更新，使其包含第二个循环，从而大大提高了其性能。我还注意到Java C中的阻止基于阻止它的。由于该机器人具有一个基于的旋转块C，因此它将在其每个命令上产生多个块。这使得该机器人更具防御性。

— Wasmoo 2014年

我的理解是，每个原始指令只能建立一个块，因此上面的代码只能在任何一条指令上建立一个块（而在每个指令上建立一个完整的块需要24 * 17圈）。如果我的理解是错误的，那么语言“多次阻塞一个变量将阻塞多次，只要第二个阻塞语句与第一个阻塞语句位于不同的代码行上”。需要修改OP中的代码，因为（如果坦率地说）如果Wasmoo的代码能够在任何指令上建立多个块，则此语句为false。

— COTO 2014年

@COTO：Java模拟器If在列表中每行添加一个块，并键入C调用它的变量。因此，使用执行Block语句的1个Block和9个If，机器人可以为每行最多获取10个Block（至少进行24 * 10 * 10圈），可能是OP没有正确地传递模拟。

— Wasmoo 2014年

我再次更新了代码以反映在保留核心概念的同时进一步改进迭代的过程。我认为这比每次迭代都充斥整个论坛要好，例如从弱复制到直接攻击，以及从非复制到重复的切换。如果您希望我重新发送原件，则可以。

— Wasmoo 2014年

5

行机器人

Move
If D #7 #0
If D #7 #0
If D #7 #0
If D #7 #0
If D #7 #0
Copy 0 C
If D=*D #9 #8     //If they point in a different direction
Copy *D D           //fix that
If #A==*#A #10 #11  //Did we copy line A already?
Copy A+1 A          //If so, A++
Copy #A *#A         //else, copy it!

将移动直到找到机器人。
会将机器人设置为与自身相同的方向。
然后将其代码复制到机器人中。
这将使“ Row Bot”机器人排成一行。:)

— 超级汤姆
source

有两个（易于修复）问题。首先，If声明必须大写。其次，的每一侧都不应有空格=，例如D=*D。

— PhiNotPi 2014年

这是一个很棒的主意。

— Sparr

没有旗帜，你就不会赢。

— 圣保罗Ebermann

3

@PaŭloEbermann机器人程序最多包含24行标志，因此该机器人程序末尾具有12个隐式标志。

— Sparr

5

超级冻结

Move                    // start moving!
Block #E
If D #12 #0             // 8 turns of attack or move
If D #12 #0
If D #12 #0
If D #12 #0
If D #12 #0
If D #12 #0
If D #12 #0
If D #12 #0
Copy D+1 D              // change direction
Copy 0 C                // start over
If *#*C==#23 #13 #14    // if opponent is frozen, give them a flag, otherwise freeze them
Copy #C+13 *#E          // give a flag to opponent
Copy #23 *#*C           // copy freeze line to opponent
Flag                    // 8 flags, one per If above
Flag
Flag
Flag
Flag
Flag
Flag
Flag                    
Copy C+23 C             // this line freezes any bot that executes it

该机器人不断尝试冻结它前面的机器人，直到它起作用为止，然后在随机行上写入一堆标志，并在旋转8圈后旋转并前进到另一个对手。

— 斯帕
source

5

拜占庭

一个高度防御的机器人，在其标志和最敏感的指令上建立多个块，包括元块（即关键块指令上的块）。

它还以不可预测的方式不断移动，并在最大努力的基础上在对手的多个位置插上旗帜。

Block #A
Block #A+1
Block #A+2
Copy E D
Move
Block #A+3
Block #A+4
Move
Copy #22 *#*C+1
Copy E D
Move
Block #A+5
Block #A+6
Block #A+7
Move
Copy #22 *#23
Block #A+8
Block #A+9
Block #A+10
Copy #22 *#2
Copy A+14 A
Move
Flag
Copy #22 *#*C+12

由于我无法模拟，因此不确定其性能如何。但是，我们会尝试一下。;）

免责声明

我在被PhiNotPi告知条件逻辑是免费的之前写了这篇文章。但是，我决定放弃它，因为永远不会有太多的机器人。

— 首席技术官
source

这个机器人赢了！

— justhalf 2014年

4

镉

我说：“我刚刚在皇家大逃杀中加入了机器人。” “它每隔几转就会移动一次，以防止速度较慢的机器人发动攻击。”

“慢速机器人是什么意思？” PhiNotPi问。

我回答说：“僵尸机器人无法评估条件逻辑的长链。”

“重定向到其他语句的'If'语句-包括其他'if'语句-都在同一回合上执行，” PhiNotPi说。

“甜蜜的汇编代码大屠杀规则！” 我哭了。“谁想到了这个主意？”

...这就是Cadmyllion如何产生的故事。

Cadmyllion：这个机器人很高兴利用超现实的能力在一条指令中通过对它所做的几乎所有事情进行条件化来评估无限多个条件表达式。

码

If D #15 #19
Move
If D #16 #20
Copy D+3 D
Block #A
If D #15 #20
Copy A+1 A
If D #16 #1
Move
If D #15 #19
If D #16 #4
Copy E D
Block #A+12
Copy C+10 C
Flag
If *#0==#14 #17 #21
If *#0==#14 #18 #21
If *#*C+1==#14 #18 #22
Copy *C+11 *C
Block #A+6
Block #A+18
Copy #14 *#0
Copy #23 *#*C+1
Flag

— 首席技术官
source

4

元阴险

该机器人冻结，然后将对手转化为效率较低的Sparr's Insidious版本，而反过来又会将对手转变为为我标记垃圾内容的机器人。这可能是我写过的最复杂的机器人，因此我希望它表现得很糟糕，没有阻塞的空间，并且代码中仅装有一个标志。将机器人变成阴险的克隆也需要很长时间。

最大的挑战是编写隐蔽克隆的代码，使其无论在机器人中的位置如何都可以工作。当我将倒数第二个代码粘贴到冻结的确切位置时，冻结就会被删除，这会及时启动对手。

If D #2 #1
Copy 23 C
Copy #8 *#*C // freeze the opponent
Copy 9 A
Copy #A *#A+*C // copy the next line at the appropriate  line
Copy A+1 A
If A==0 #7 #23
Copy 23 C
Copy C+23 C
If D #C+2 #C+23 // the code for the Insidious clone starts here
Copy C+21 C
Copy C+2 C
If D #C+6 #C+22
If D #C+5 #C+22
If D #C+4 #C+20
If D #C+3 #C+19
If D #C+2 #C+18
Copy E D
Copy #C+7 *#*C
Flag
Copy C+3 A
Copy #C+22 #A
Copy A+1 A
Copy C+21 C // And ends here

— 演员
source

那是一个聪明的主意。但是，我没有看到任何Move命令。这是否意味着您的机器人和垃圾邮件机器人都不会移动？

— Wasmoo 2014年

Insidious克隆可能会根据bots原始代码中的内容而移动，由于空间有限，必须丢掉q位功能才能使用24行代码实现这一目标。比起其他任何事情，这更像是一种心理锻炼。

— 演员

3

维修与保护

该机器人在保护新修复的代码行的同时修复了自己的代码。

If #A==#A+16 #C+1 #C
Copy #A #A+8
Block #A+8
Copy A+1 A
Copy E D
Move
Copy #C+1 *#*C
Flag
If #A==#A+16 #C+1 #C
Copy #A #A+8
Block #A+8
Copy A+1 A
Copy E D
Move
Copy #C+1 *#*C
Flag
If #A==#A+16 #C+1 #C
Copy #A #A+8
Block #A+8
Copy A+1 A
Copy E D
Move
Copy #C+1 *#*C
Flag

说明：

的初始值A是0，并且这些线被编号0-23。如果该If语句已执行且为false，则它将再次尝试执行同一行。控制器不允许机器人执行同一行两次，因此转弯结束并C增加到1。

Copy #A #A+8无论If语句的值如何，实际上都将执行下一行。区别在于，如果为true，则执行两次；如果为false，则执行一次。如果该行#A+8被阻塞（最终会发生），则在实际复制的情况下执行两次，而仅执行一次则只会取消阻塞。然后，新复制的行将被阻止以保留它。

— 皮诺皮
source

我试图了解你们所有人的机器人，但我被困住了。的初始值是A多少？是不是0？如果是这样，那么您的第一行将第0行与第16行进行比较，但是据我从OP示例bot的了解，第一行是第1行，不是吗？另外，仍然在您的第一行中，#C是指这一行，这是否意味着如果If语句返回false，您就陷入了一个无限循环中？

— plannapus 2014年

@plannapus我添加了一些解释。

— PhiNotPi 2014年

3

中和剂

该机器人使其受害者重写了整个程序，价值0分。一旦病毒就位，它就会继续传播。这是胜利的焦土方法。

If D #C+2 #C+3          // A: If [enemy exists] B else C
Copy C+22 C             // GOTO A
If *#*C==#7 #C+4 #C+5   // B: If [enemy was neutralized] D else E
Move                    // C: Move
Copy E D                // D: Turn Randomly
Copy #7 *#*C            // E: Neutralize enemy
Copy C+1 C              // Skip the next line
Copy #C #C+1            // Neutralizing Code [Copy this line to next line]

这种比较*#*C==#7似乎并不能正确地适应对手的移动，但是机器人最终确实可以继续前进。

— 瓦斯穆
source

Copy C+1 C只需要跳过一行就可以了。

— 弥敦道·美林

2

“跳过下一行”表示您的机器人在继续操作之前将花费16圈执行标志指令。您可能要Copy 23 C转而回到第一行。

— Sparr 2014年

仅当“ GOTO A”被覆盖时才会发生“跳过下一行”。我还有其他方法可以使该漫游器更具攻击性和防御性，例如重复“ A”，复制代码和阻止“ GOTO A”。但是，如果这个机器人完全被击中，无论如何它几乎已经死了。

— Wasmoo 2014年

3

阴险

Move
If D #4 #0
If D #4 #0
Copy 0 C
Copy 4 C
If D #12 #11
If D #12 #11
If D #12 #11
If D #12 #11
If D #12 #11
Copy D+1 D
If D #4 #3
Copy #C+8 *#*C
Flag
Copy C A
Copy #C+22 #A
Copy A+23 A
Copy C+21 C

受@Cruncher的启发，该机器人用一小段代码感染其他机器人，并用该机器人的标志填充其他机器人。这些机器人随后坐到鸭嘴上以进行进一步的攻击，但是当它们被其他人再次感染时，它们通常会充满我的旗帜。

编辑：感谢@PhiNotPi提供高尔夫帮助，感谢@overactor提供效率建议

— 斯帕
source

恭喜您达到2k！

— bjb568

3

蛤C开心

这是阻止的练习。直到$Copy出现之前，它的表现都非常出色。

蛤有22个块命令。因为A每个循环都会移动，因此每次循环都会引用不同的行。这允许每个命令在每隔一行上堆叠块，每行最多22个块。因此，要破坏全副武装的蛤lam，需要写22遍。

例如，#10每次通过循环都会受到以下几行的保护：

回路0，A = 0 #10受第7行保护（7+0+3= 10）
回路1，A = 7 #10受第0行保护（0+7+3= 10）
回路2，A = 14 #10受第17行保护（17+14+3= 34 = 10）
回路3，A = 21 #10受第10行保护（10+21+3= 34 = 10）

因此，在循环3的第10行之后，#10已被阻塞4次，需要写入4次#10才能破坏该块，而第5个实际该行。

请注意，块由它们的C值键控，如果受保护的行已被相同的值阻止，则不会堆叠C。因此，在为每行建立22个块之后，这些块将不再堆叠。

Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Block #C+A+3
Copy A+7 A
Flag

— 瓦斯穆
source

3

精神控制

我想永远不会太晚？

Block #C+D
If D #2 #0        // Scan for enemy
If *#E==#E #0 #5  // Attack if necessary
Copy D+5 D        // Turn
Copy 22+1 C       // Repeat
Copy 4+1 C        // ATTACK:
Copy #22+1 *#*C   //   Freeze
Copy #17 *#17     //   Upload the DOWNLOADER
Copy #18 *#18     //
Copy #21 *#19     //
Copy D+2 *D       //   FACE ME!!
Copy 17 *C        //   Start download
If E #0 #13
If E #0 #13
Copy 22+1 C
Flag
Flag
Copy *#B+20 #B+20         // DOWNLOADER
If *#B+20==#B+20 *#20 #19 //
Copy 22+1 C               //
Copy 1+B B                //
Copy 16 C                 //
Flag
Copy 23+C C        // FREEZE

MindControl来自我的想法，即将我的整个程序复制到对手会花费一些时间，在此期间我的机器人很容易受到来自其他方向的攻击。那么，为什么在我扫描敌人时不让对手复制我的程序呢？

一旦找到敌人，MindControl便立即冻结该敌人以防止逃脱。然后，它将下载程序上传到对手，让受害者下载MindControl的程序本身。该下载器利用了这样一个事实，即很少有漫游器使用，B并且会循环运行直到下载全部24行为止。当下载重写#19从Copy 16 C到Copy 23 C，这意味着受害者已经下载的所有行，并会继续以重启。

我的漫游器的第一个版本不包含块。而且它是如此脆弱，几乎所有的变化都在崩溃。因此，我决定基于Wasmoo的$ Copy（基于COTO的Lockheed）添加块。我发现不利的一面是，原件很难纠正副本中的错误。但这远非残障，并且得分显着提高，所以我保留了Blocks。

更新

我改进了下载程序，使其能够继续尝试下载，直到成功重写为规避块为止。这确实意味着还需要再转一圈才能上载下载器，但是在此更改之后，我的得分翻了一番！！不能与数字争论。

另一个更新。您可能已经注意到，MindControl通过比较目标和目标之间的随机线来决定是否攻击目标。如果它们匹配，则MindControl只是假设目标已被感染，则不理会它。（旁注：我以前使用静态线进行比较，但是会产生很多误报和否定）。结果是，会产生很多误报。所以，我决定利用==，使像一些微不足道的变化C+23来23+C。该程序在功能上是相同的，但在Windows看来却有所不同==。现在，MindControl没有与任何其他bot中的任何行都相同的行，它将100％命中任何未触及的bot。同样，分数显着提高。

再次改进了下载程序。现在，它以较短的循环运行。（这似乎与我的分数有很大的相关性）

再次改进了Downloader。使用原始机器人代码，因此上传速度更快。还添加了2个随机块，似乎可以提高得分

— 黄昏
source

永远不会太迟！

— 弥敦道·美林

我正在考虑重命名为BrainWash ...

— TwiNight

或观看BunkerBuster后，通过HappyAsAClam观看下载程序的崩溃，了解地堡

— TwiNight 2014年

我曾想过尝试先上传一个下载器的想法，但我无法像您一样小。做得好！我也喜欢您将D用作粗纱三角洲；它可以保存命令并加快设计速度。我很惊讶没有“ Move”命令的机器人会如此出色地工作。模拟显示，机器人趋向于成群结队，但我不知道这将是一个成功的策略。我同意，打破蛤lam有其独特之处。

— Wasmoo 2014年

@Wasmoo显然，下载器设计要求僵尸程序保持静止，并且确实会使僵尸程序集结。我喜欢将其视为一棵树的根，该树伸出并吸收其他机器人以使其生长。但我想敏捷是$ Copy和Lockheed击败我的原因。

— TwiNight

2

攻击者

Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Copy #E *#*C
Flag

— 内森·美林（Nathan Merrill）
source

2

移动机器人

Move
Copy 23 C
Flag

就像Flagbot一样，但是在接受代码礼物的同时四处走动，以便与我们所有的旗帜一起使用。

— 斯帕
source

2

复制机器人

该机器人试图冻结他的对手，然后在重新启动另一个机器人之前将其全部代码复制到该机器人中。如果对手使用格挡，这也应该起作用（大部分情况下），尽管这确实会使格挡变得比现在慢。

If D #23 #22
Copy 23 C
Copy #18 *#*C
Copy #18 *#*C+1
Copy #18 *#*C
Copy #18 *#0
Copy #18 *#0
Copy 0 *C
Copy 0 *C
Copy 1 A
Copy #A *#*A
If D #12 #14
Copy A+1 A
Copy 9 C
Copy 23 C
Flag
Flag
Flag
Copy C+23 C
Copy D+1 D
Flag
If *#*C==#*C #19 #13
Move
If *#*C+1==#*C+1 #21 #13

— 演员
source

条件中没有空格

— Nathan Merrill 2014年

@NathanMerrill陷阱

— 演员

2

魔术师

Magus是对自传播病毒的简单尝试。它试图将自身复制到其他机器人程序中。（已编辑以删除负数，修复条件和修剪线条。）

Block #A
Copy #A *#A
Copy A+1 A
If A #0 #4
Copy 0 *C
Flag
Move
Copy 0 C

— 以撒
source

不允许使用负值。请使用23代表B

— Nathan Merrill

请使用23，不是25

— 弥敦道美林

除非我有误解，否则将导致它不会阻塞或复制第23或24行（请注意：它与第一个修订版略有不同，A增加了1，而不是B）

— Isaac

+ 0 = 24 + 1 = 25，-1 = 23，如果你希望它是-1，它应该是23

— 弥敦道美林

那是以前的样子，因为我以为您只能与0进行比较（以某种方式错过了'='部分，我认为是漏读），但是现在它已更改，所以A从1开始到25结束。想象第3行是for (int i = 1; i < 25; i++).. 。

— 艾萨克

1

DNAbot

Flag
Copy 8 D
Copy 16 B
If #D==#B #C+2 #C+3
Block #A
Copy #D #A
If D #7 #15
Copy #23 *#*C
Copy A+1 A
Copy B+1 B
Copy D+1 D
If #D==#B #C+2 #C+3
Block #A
Copy #D #A
If D #7 #15
Move
Copy A+1 A
Copy B+1 B
Copy D+1 D
If #D==#B #C+2 #C+3
Block #A
Copy #D #A
If D #7 #15
Flag

该机器人在移动和攻击时会修复自己的代码。

— 斯帕
source

1

封锁者

Copy A+1 A
Block #A
Copy C+22 C

— 内森·美林（Nathan Merrill）
source

1

山寨

If D #4 #3
Move
Copy 23 C
Copy *#*C #1
Copy #23 *#E

— 内森·美林（Nathan Merrill）
source

1

快速冷冻机器人

尝试在将要在其对手旁边执行的行中复制标志，如果没有要攻击的敌人，则移动该标志。

Block #13
Block #14
If D #13 #14
If D #13 #14
If D #13 #14
If D #13 #14   
If D #13 #14
If D #13 #14
If D #13 #14
If D #13 #14
If D #13 #14
If D #13 #14   
Copy 23 C
If E #15 #16
Move
Copy #23 *#*C
Copy D+1 D

— 演员
source

前两行无效。他们需要＃13和＃14

— Nathan Merrill 2014年

1

阻止，冻结，攻击

Block #A        // start block loop
Copy A+1 A      // loop A from 0 to 23
If A #3 #4      
Copy 23 C       // repeat block loop
Copy 5 C        // exit block loop to attack/move loop
Move
If D #11 #5     // attack or move
Copy A+1 A      // loop A from 0 to 23
If A #9 #10
Copy 5 C        // repeat attack/move loop
Copy 23 C       // exit attack/move loop to block loop
Copy 11 C       // start of attack routine
Copy #23 *#*C   // freeze opponent
Copy #19 *#E    // copy flag to opponent
Copy #20 *#E    // copy flag to opponent
Copy #21 *#E    // copy flag to opponent
Copy #22 *#E    // copy flag to opponent
Copy D+1 D      // change direction
Copy 5 C        // repeat attack/move loop
Flag
Flag
Flag
Flag
Copy C+23 C     // freeze instruction, for copying

阻塞所有24条线，然后循环移动或攻击24次，然后重复。攻击包括试图冻结对手，然后将四个标志复制到随机位置，然后转向。

— 斯帕
source

1

隐藏，阻止，攻击

该机器人基于Block Freeze Attack。我更改了一些If语句的位置以使其更紧凑，从而允许我植入更多的标志。我也有在游戏开始时就逃走的时间，以争取一些时间来阻止。

Copy D+1 D
Move           //buy some time by moving to a more secure location
Block #A+2
Copy A+1 A
If A #11 #17
Copy #23 *#E
Copy #22 *#E
Copy #21 *#E
Copy #20 *#E
Copy #19 *#E
Copy D+1 D
Copy 1 C
Move
If D #14 #15
Copy 3 C
Copy 11 C
Copy #18 *#*C
If D #16 #15
Copy C+23 C
Flag
Flag
Flag
Flag
Flag

— 皮诺皮
source

1

巡回病毒

If D #6 #16
Move
Copy 23 C
Flag
Flag
Flag
Copy 6 C
Copy A+23 A
Copy #A *#A                     //clone previous line to enemy
Copy 23 *C                      //freeze enemy
If A #6 #16                     //loop or turn then continue
Copy 0 *C                       //reboot enemy
Copy 23 C                       //start moving again
Flag
Flag
Flag
Copy D+1 D                      //turn
Flag
Flag
Flag
Flag
Flag
Flag
Copy 22 C                       //freeze instruction

该漫游器徘徊，直到找到一个敌人，然后冻结它们，用其自己的代码替换所有代码，解冻它们，然后再次徘徊。

— 斯帕
source

1

普通感冒

它几乎立即感染您，并且会四处传播。基于PhiNotPi的Parasite，普通感冒几乎立即检查是否可以将其标志复制到您的标志上。如果不能，则阻止随机值。如果没有对手，则略微移动。

Block #22
If D #8 #5
If D #8 #5
If D #8 #5
Copy 23 C
If E #6 #7
Copy D+1 D
Move
If *#E=#22 #15 #9
If *#E+1=#22 #16 #10
If *#E+2=#22 #17 #11
If *#E+3=#22 #18 #12
If *#E+4=#22 #19 #13
If *#E+5=#22 #20 #14
If *#E+6=#22 #21 #23
Copy #22 *#E
Copy #22 *#E+1
Copy #22 *#E+2
Copy #22 *#E+3
Copy #22 *#E+4
Copy #22 *#E+5
Copy #22 *#E+6
Flag
Block #E

— 演员
source

1

流感

这与普通感冒（基于我的寄生虫）密切相关，但速度略有提高。

Move
Block #23
If D #8 #0
If D #8 #0
If D #8 #0
If D #8 #7
Copy 0 C
Copy D+1 D
If *#E #9 #10
Copy #23 *#E
If *#E+1 #11 #12
Copy #23 *#E+1
If *#E+2 #13 #14
Copy #23 *#E+2
If *#E+3 #15 #16
Copy #23 *#E+3
If *#E+4 #17 #18
Copy #23 *#E+4
If *#E+5 #19 #20
Copy #23 *#E+5
If *#E+6 #21 #22
Copy #23 *#E+6
Block #E
Flag

— 皮诺皮
source

我期待看到这种改变。但是，第5行上的＃5会引发无限循环，而那些＃7也不太可能是您想要的。

— 演员

@overactor谢谢，这些是通过添加额外的行而产生的错误。

— PhiNotPi 2014年

我是否知道痛苦。

— overactor 2014年

1

品牌重塑

Move
If D #10 #0
If D #10 #0
If D #10 #0
If D #10 #0
If D #10 #0
If D #10 #0
If D #10 #0
If D #10 #0
Copy 0 C
If *#E=#14 #11 #9
If *#E==#14 #13 #12
Copy D+1 D
Copy #14 *#E
Flag

该漫游器会尝试在敌方漫游器中随机定位标志，并用友好的标志替换它们，并在检测到成功后将其拒绝。受癌症机器人的启发。

— 斯帕
source

公共变量有什么问题？

代码机器人

代码

旁注

在Ifwill 上进行无限递归而没有执行任何行

样例程序

旗杆机器人

冻结标签

寄生虫

$复制

洛克希德

进攻还是其他

行机器人

超级冻结

拜占庭

免责声明

镉

码

元阴险

维修与保护

中和剂

阴险

蛤C开心

精神控制

更新

攻击者

移动机器人

复制机器人

魔术师

DNAbot

封锁者

山寨

快速冷冻机器人

阻止，冻结，攻击

隐藏，阻止，攻击

巡回病毒

普通感冒

流感

品牌重塑

在`If`will 上进行无限递归而没有执行任何行