欢迎回来！我很高兴提出第三个CodeBots挑战。这已经花了很长时间了。这项挑战将分为3个部分：简短版本，详细版本和其他详细信息。

短版

每个参赛者将编写一个24命令程序。这些bot会在世界各地移动并将其代码复制到其他bot中，同时试图阻止其他bot这样做。可能的命令之一是no-op Flag。如果一个机器人拥有Flag比其他任何一个机器人更多的东西Flag，那么您将获得积分。您可以通过获得最多的积分来获胜。

以上所有这些对于过去的两个挑战都是正确的。这次，机器人将能够同时运行多行代码。

长版

API

每个漫游器将精确地有24行，每行采用以下格式：

$label command parameters //comments

标签和注释是可选的，并且每个命令具有不同数量的参数。一切都不区分大小写。

参量

输入的参数可以是以下格式：

1. 介于0到23之间的值。
2. 一个变量：A，B，C，D
3. 使用加法的值：A+3或2+C
4. 用#符号指定的一行代码（#4代表第5行，而#C+2代表由计算得出的行C+2）。
5. 您可以使用$label而不是指定一行代码。
6. 对手的变量或代码行，由指定*。您的对手是您面对的方形机器人。（*B代表对手的B价值，而*#9代表对手的第十行）。如果那个方格中没有人，则不执行该命令。

指令

移动V

移动机器人North+(V*90 degrees clockwise)。运动不会改变方向。

转V

V*90 degrees顺时针旋转机器人。

复制大众

将任何内容复制V到中W。如果V是行号，则W必须是行号。如果V是变量或值，则W必须是变量。

旗

什么也没做。

星空卫视

启动附加到变量的新线程V。立即，在以后的每个回合中，线程将在line上执行命令V。

如果V已经连接到线程，则此命令为无操作。如果V是对手的变量，那么对手将启动附加到该变量的线程。

停止V

V在此回合结束时停止附加到变量的线程。

锁V

防止V以任何方式使用该行或变量，除非被称为的线程使用Lock。随后Lock由同一线程进行的调用将解锁V。不能在对手的变量或行上调用锁。

如果康德大众

这将测试Cond。如果条件为true，则它将线程指针移至行号V，否则移至行号W。该行将立即执行。

条件句可以X=Y，X<Y，!X，或?X：

1. X=Y 测试两条线是否属于同一类型且来自同一机器人的行，或者测试两条值是否等于相同数量。
2. X<Y测试的值X是否小于Y。
3. !X测试变量或行X是否被锁定（如果锁定，则返回true）
4. ?X 测试给定变量是否附加了线程

额外细节

多线程交互

相同类型的动作将同时执行。操作按以下顺序执行：

1. 锁。如果多个线程试图锁定一个变量，它们将全部失败。如果一个线程正在解锁变量而另一个线程正在尝试锁定它，则该变量将保持解锁状态。

2. 开始。如果多个线程试图在一个变量上启动一个线程，它将被视为一次启动。

3. 复制。如果两个线程都复制到同一个变量，则该变量将最终成为一个随机值。如果它们都复制到同一行，则两者都不起作用。如果一个线程复制到另一个线程正在复制的同一变量，则后者将复制一个随机值。如果两个线程都从同一个变量复制，则它们都将正常工作。

4. 如果。所有条件将同时进行测试，然后将在之后更新线程变量。执行If可以导致添加具有更高优先级的操作。具有较高优先级的操作将在继续通过之前执行If，而具有较低优先级的操作将在之后执行If。

5. 移动。同一机器人上的多次移动将使该机器人进行所有移动的总和。如果多个漫游器最终出现在同一位置，它们将返回到其起始位置。

6. 转。同一机器人多次旋转求和。

7. 停止。同一变量上的多个停止命令将被视为一次停止。

其他详情

您的初始线程开始附加到D变量

重复执行If（具有If指向自身的语句）将导致您的机器人不执行任何操作

如果线程在锁定后停止，则这些锁将被解锁

使用锁定的变量或行的操作将无效。

如果漫游器的行数少于24行，则其余行将被填充 Flag

在还连接到启动线程的变量上执行写操作实际上将使线程在新值开始时执行该线程，因为该线程将启动下一轮。

机器人按以下方式放置在环形世界中：

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

我添加了一些 示例 机器人，这些机器人被注释为语言参考。

控制器位于此处。我已经为此工作了很长时间，但它可能仍然存在错误。当规格与控制器矛盾时，说明是正确的。

计分板

1. 771  LockedScannerBot
2. 297  CopyAndSelfFlag
3. 289  DoubleTapBot
4. 197  ThreadCutterBot
5. 191  TripleThread
6. 180  ThickShelled
7. 155  Attacker
8. 99   RandomMover
9. 90   BananaBot
10. 56  LockedStationaryDoubleTap

锁定扫描仪机器人

尽可能快地扫描敌人，并用标志代替线。

    Lock D
    Copy $a A
    Start A
    Copy $b B
    Start B

$d  Lock $d0
    Lock $d1    
$d0 Copy $flag *#C+1
$d1 If 1=1 $d0 $d0

$a  Lock A
    Lock $a0
    Lock $a1
    Lock $a2
$a0 Copy $flag *#C
$a1 Copy C+2 C
$a2 If !*#C $a1 $a0

$b  Lock B
    Lock $b0
    Lock $b1
    Lock $b2
$b0 Move C
$b1 Turn 1
$b2 If 1=1 $b0 $b0

$flag Flag

DoubleTapBot

该机器人具有3个线程：一个用于移动（A），另外两个用于标记（B和D）。B标志1/2圈，D标志1/3圈。所以转一下身，他会加倍标记对手:)。

我认为如果C超过23，它将返回0。

如果可以转弯做准备（8转），这是非常安全的，因为他将始终保持至少2个线程（A和B）正常运行。

我目前无法尝试，因此当我回到首页时会进行测试:)

Lock D          //Thread D locks itself
Copy 6 A        //Thread A will start line 6
Start A     
Copy 13 B       //Thread B will start line 13
Start B        
Copy 20 D       //Moving Thread D to an other part of the program
Lock A          //Thread A locks itself and the line it will be using
Lock #10
Lock #11
Lock #12
Move C          //Move in a pseudo random direction
Turn 1      //always turn to the right
If 1=1 #10 #10  //return to Move C
Lock B          //Thread B locks itself and the line it will be using
Lock #13
Lock #14
Copy #18 *#C    //Copy a flag to the Cth line of the opponent
If 1=1 #16 #16  //jump back to the copy
Flag   
Flag   
Copy C+1 C      //Increment C
Copy #19 *#C+1  //Copy a flag to the Cth+1 line of the opponent
If 1=1 #20 #20  //jump back to the increment
Flag 

锁定式固定双击

受到@Katenkyo的DoubleTapBot的启发，此标志放弃了几个标志和任何移动的希望，以完全锁定其自己的线程，因此无法对其进行重新编程。但是，仍然可以将敌人标志写入非循环代码区域。

Lock $flag              // lock the only flag line, super important!
Lock D                  // lock thread D
Copy 10 A
Start A                 // start thread A at $Astart
Copy 17 B
Start B                 // start thread B at $Bstart
Lock $D1                // lock thread D lines
Lock $D2                // thread D should be safe on turn 8
$D1 Turn C              // Spin in place, once every 2 turns
$D2 If 0=0 $D1 $D1      // thread D loop
$Astart Lock A          // thread A starts here, locks itself
Lock $A1                // lock thread A lines
Lock $A2
Lock $A3                // thread A should be safe on turn 7
$A1 Copy $flag *#C      // ATTACK! once every 3 turns
$A2 Copy C+1 C          // increment C, used for attacks and turning
$A3 If 0=0 $A1 $A1      // thread A loop
$Bstart Lock B          // thread B starts here, locks itself
Lock $B1                // lock thread B lines
Lock $B2                // thread B should be safe on turn 8
$B1 Copy $flag *#C+12   // ATTACK! once every 2 turns
$B2 If 0=0 $B1 $B1      // thread B loop
$flag Flag

随机移动

沿伪随机方向移动

Copy 5 C
Copy 8 B
Start C
Move A // If you can't catch me, you can't modify me
If 1=1 #3 #3 //Continue to execute the above line
Start B
Copy 4 A
If 1=1 #6 #6 //Continue to execute the above line
Flag
Copy 5 A
If 1=1 #9 #9 //Continue to execute the above line

厚壳

尽可能锁住他的东西

Copy 5 B //Designating that the B thread will start on line 5
Start B //Starting the B thread
Lock C //Preventing C from being used
Copy A+1 A //The two threads are offset, meaning that the two threads shouldn't access this at the same time
Lock #A
Copy 2 B

攻击者机器人

将标志复制到各个位置

Copy A+1 A // Increment A
Move A //Move in the Ath direction
Turn A //Rotate A times
Copy #8 *#A //Copy my flag over
Copy 23 D //Loop back to the beginning.  (I use 23 here as threads auto-increment)

三重螺纹

这个简单的漫游器使用相同的代码运行三个线程。每个线程攻击1/3转，移动1/6，转1/6，并进行簿记1/3。

Move 0
Start A
Start B
$loop Copy #A+9 *#C
Move C
Copy #A+9 *#C
Turn C
Copy C+1 C
If 0=0 $loop $loop

香蕉机器人

尝试在敌人做任何事情之前先将香蕉扔进敌人的轮子。容易被压扁。

$d     If !*D $d1 $d0
$d0    Copy 24 *D
$d1    If !D $d2 $start
$d2    If !*B $d5 $d3
$d3    Copy 24 *B
$d4    Copy $d D

$start Lock D             //Banana's like to split.
       Copy $a A
       Start A
       Copy $b B
       Start B
       Lock $flag

$d5    Copy $start *C     //It's okay if enemy messes up our start.
       Copy $d d

$a     Lock A
$a1    Move C
       Turn 1
       Copy $a1 A

$b     Lock B
$b0    Copy C+1 C
       If !*#C $b0 $b1    //Banana's are good at slipping.
$b1    Copy $flag *#C
$b2    Copy $b0 B

$flag  Flag

切线机器人

   Lock D
   Lock $f
   Copy 16 C
$S If ?*D $1 $2
   Move 1
   Copy $S D
$f Flag
$1 Stop *D
$2 If ?*A $3 $4
$3 Stop *A
$4 If ?*B $5 $6
$5 Stop *B
$6 Copy $f *#C
   Copy C+1 C
   If *#C=#C $E $6
   Copy 2 D
$E Start *D

在填充代码之前，请停止所有敌方线程。

复制和自标记

该机器人运行三个线程。D线程移动直到遇到敌人，然后尝试向其复制标志，然后随机移动。A线程将其自己的标志复制到漫游器代码的非必要行上。B线程只是一个计数器。每个线程使用的变量，标志和代码行在前15个回合中都被完全锁定，并且漫游器使用自己的标志覆盖了几乎所有启动代码。我认为，如果没有专门的攻击机器人，只能在写入标记的情况下将其变成15岁以后，就无法将其转变为另一支球队的旗帜。

    Lock D              // Lock D thread
    Copy $AS A
    Start A             // Start A thread at $AS
    Start B             // B is just a counter
    Copy $DL D          // Jump to D thread startup code
$DC Start B             // Don't let B thread get stopped
$D0 If !*#B $D1 $D2
$D1 Copy $DF *#B
$D2 If !*#B+6 $D3 $DM
$D3 Copy $DF *#B
$DM Move B              // Move some direction after attacking
$DA Move 0              // Move north ...
    If ?*D $DC $DA      // until we hit a live target
$DF Flag                // Flag to copy
$DL Lock #B+3           // Lock the D thread's lines
    If B<12 $DL $DA     // jump to `Move 0` when D thread is safe
$AS Lock A
$AL Lock #B+20
    If B<4 $AL $AD
    Copy 23 B           // reset B so A doesn't overwrite its own code
$AF Flag
    Flag
$AD Copy $AF #B+1       // Copy a safe flag over every unused line of code
    If B<18 $AD $AF