[Question]
  [
# Code Bots
I hate private and protected variables. I just want to access anything and everything!
If you are like me, then this challenge is for you!
Write a bot that ~~works together in harmony with other bots~~ makes other bots do what you want. You are a programmer, and you know how things are supposed to work. Your job is to convert as many other bots to your ways as possible.
# The Code
You will have 24 lines of code to write your bot. Each turn, every bot will execute 1 line sequentially.
Each bot stores 5 variables `A` through `E`. `A` and `B` are for personal use, `C` stores the next line to execute, `D` stores the current direction, and `E` is a random number. The variables start at 0, except for `D`, which will start at a random value. All variables have only store 0-23. Numbers larger or smaller will be modulated by 24.
In this post, I will use opponent to be the adjacent bot you are facing
Each line must contain one of the following 5 commands:
1. `Flag` does nothing. Except it's how you win
2. `Move` moves your bot in the `D`th direction. If a bot already occupies the space, no move will happen
3. `Copy Var1 Var2` copies the contents of Var1 into Var2
4. `If Condition Line1 Line2` If Condition is true, executes Line1, else Line2
5. `Block Var1` blocks the next write on a variable
A variable can be used as follows:
`#Var` will use the variable as a line number. If `A` is 17, `Copy #8 #A` will copy the contents of line 8 onto line 17.
`*Var` will use the variable of your opponent. `Copy 5 *C` will set the opponent's `C` variable to `5`
`Var+Var` will add the two variables. `Copy D+1 D` will rotate the bot to the right
When `D` is used as a direction, `[North, East, South, West][D%4]` will be used
These modifiers can be chained: `Copy *#*C #9` will copy the next line your opponent will execute into your own code on line 9. `**D` refers to your opponent's opponent's `D` variable.
A Condition will be evaluated as follows:
1. If `Var`:
	1. If Var is `A` through `C`, it will return true if Var is nonzero, else false.
	2. If Var is `D`, it will return true if there is a bot in the `D`th direction, else false
	3. If Var is `E`, it will return true if E is odd, else false
	4. If Var is a line, it will return true if it is a Flag line
2. If `Var1=Var2`:
	1. Returns true if both are `A-E`, and equal the same number
	2. Returns true if both are lines, and the line type is equal
3. If `Var1==Var2`:
	1. Returns true if both are `A-E`, and equal the same number
	2. Returns true if both are lines, and are identical (Flags from different bots will not be equal)
50 bots of each type will be placed in a toroidal world in the following pattern:
```
B...B...B...B...
..B...B...B...B.
B...B...B...B...
..B...B...B...B.
```
After each game of 5,000 turns, the flags on each bot will be counted. You get a point if a bot has more of your flag than any other type of flag. If the case of a tie between `N` bots, no points are given.
There will be 10 games, and scores will be accumulated at the end.
# Side Notes
End of line comments are allowed, and are denoted with `//`
Attempting to do something that doesn't make sense, such as adding to a line will do nothing
Attempting to do something on a non-existent bot will do nothing
## Infinite recursion on an `If` will end with no line being executed
`If` does not change the value of `C`
A `Block` doesn't expire until somebody attempts to write to it
Multiple variables and lines can be blocked at once
`Block`ing a variable multiple times will block multiple times as long as the second block statement is on a different line of code than your first
Spaces are only allowed between arguments (and after the command)
If a bot is shorter than 24 lines, Flag will be the rest of the lines.
# Sample Program
```
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
```
The program will be run by my Python controller [here](https://github.com/thenameipicked/CodeBots).
**The Java controller is [here](https://github.com/thenameipicked/CodeBotsJava)** It is *fast* and looks much better than the python one.
Scoreboard:
1. 6837 [$Copy](https://codegolf.stackexchange.com/a/37312/)
2. 3355 [Lockheed](https://codegolf.stackexchange.com/a/37253/)
3. 1695 [MindControl](https://codegolf.stackexchange.com/a/37711)
4. 967 [Byzantine](https://codegolf.stackexchange.com/a/37106)
5. 959 [AttackOrElse](https://codegolf.stackexchange.com/a/37208)
6. 743 [Cadmyllion](https://codegolf.stackexchange.com/a/37116)
7. 367 [Influenza](https://codegolf.stackexchange.com/a/37049/)
8. 251 [TheCommonCold](https://codegolf.stackexchange.com/a/37023)
9. 226 [Magus](https://codegolf.stackexchange.com/a/37011)
10. 137 [HideBlockAttack](https://codegolf.stackexchange.com/a/37016/)
11. 129 [RowBot](https://codegolf.stackexchange.com/a/37050/)
12. 123 [FastMoveCloneDodge](https://codegolf.stackexchange.com/a/36990)
13. 112 [FastForwardClone](https://codegolf.stackexchange.com/a/36989/)
14. 96 [QuickFreeze](https://codegolf.stackexchange.com/a/36993/)
15. 71 [RepairAndProtect](https://codegolf.stackexchange.com/a/36996)
16. 96 [SuperFreeze](https://codegolf.stackexchange.com/a/36998)
17. 93 [RovingVirus](https://codegolf.stackexchange.com/a/37022/)
18. 80 [ForwardClone](https://codegolf.stackexchange.com/a/36988)
19. 77 [FreezeTag](https://codegolf.stackexchange.com/a/36997/)
20. 68 [Palimpseste](https://codegolf.stackexchange.com/a/37084/)
21. 62 [BlockFreezeAttack](https://codegolf.stackexchange.com/a/37002)
22. 51 [RushAttackDodge](https://codegolf.stackexchange.com/a/36984/)
23. 46 [Blocker](https://codegolf.stackexchange.com/a/36980/)
24. 40 [TurretMaker](https://codegolf.stackexchange.com/a/37074/)
25. 37 [Copycat](https://codegolf.stackexchange.com/a/36981)
26. 37 [Kamikaze](https://codegolf.stackexchange.com/a/37215)
27. 35 [FlagInjector](https://codegolf.stackexchange.com/a/37067/)
28. 33 [RandomCopier](https://codegolf.stackexchange.com/a/36982)
29. 31 [Insidious](https://codegolf.stackexchange.com/a/37055/)
30. 29 [HappyAsAClam](https://codegolf.stackexchange.com/a/37303)
31. 25 NanoVirus
32. 21 [Nullifier](https://codegolf.stackexchange.com/a/37083/)
33. 19 [Nanoviris](https://codegolf.stackexchange.com/a/37026)
34. 17 [BoringCopybot](https://codegolf.stackexchange.com/a/36999)
35. 16 [Movebot](https://codegolf.stackexchange.com/a/36994/)
36. 14 [Flagbot](https://codegolf.stackexchange.com/a/36992)
37. 13 [Neutralizer](https://codegolf.stackexchange.com/a/37066/)
38. 12 [Cancer](https://codegolf.stackexchange.com/a/37054)
39. 9 [DNAbot](https://codegolf.stackexchange.com/a/36987)
40. 9 [Parasite](https://codegolf.stackexchange.com/a/37017)
41. 8 [MetaInsidious](https://codegolf.stackexchange.com/a/37060)
42. 8 [Rebranding](https://codegolf.stackexchange.com/a/37072/)
43. 8 [AdaptiveBot](https://codegolf.stackexchange.com/a/37098/)
44. 8 [ReproducingBot](https://codegolf.stackexchange.com/a/37015)
45. 8 [KungFuBot](https://codegolf.stackexchange.com/a/37046)
46. 5 [QuickFreezerbot](https://codegolf.stackexchange.com/a/37004)
47. 4 [Attacker](https://codegolf.stackexchange.com/a/36979/)
  
[Answer]
# Flagbot
```
Flag
```
Why bother doing anything when other bots are going to be nice enough to give me their code?
[Answer]
# Freeze Tag
```
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
```
Trap opponent in a loop, fill him with flags, move on to next opponent.
[Answer]
# Parasite
Why kill other bots? This bot looks through opponent's code and replaces only the flags.
```
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
```
[Answer]
# $Copy
This bot uses much of the same techniques as COTO's Lockheed, so I will shamelessly borrow and enhance.
This exploits a `C` vulnerability to break blocks and even reverses the neutralizer. It is also written in absolutes because of this. I think this might break if the `C` shift is reinstated, but as long as the shift is constant, it can be rewritten to combat it.
For whatever reason, the lack of loop at the end made this bot super good.
```
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
```
[Answer]
# Lockheed
My third (and likely final) submission to this particular bot war: the Lockheed Reactor, or "Lockheed" for short.
```
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
```
Special thanks goes to @Wasmoo, who shared his discovery of the "'Blocking a variable multiple times will block multiple times as long as the second block statement is on a different line of code than your first.' simply isn't true" exploit. I make extensive use of it.
Also, thanks goes to Nathan Merill for administrating the competition and for publishing the simulator. The simulator is utterly invaluable in tuning bots. I wouldn't have believed it if I hadn't simulated it with my own eyes, but the addition or removal of the most conceptually minor bot feature can mean the difference between great success and abject failure. I'm torn as to whether that's a good thing or not.
[Answer]
# Attack Or Else
Seeing as defensive robots like Byzantine were doing so well, I decided to make a defensive robot as well.
This has two sets of patterns, depending on whether or not the enemy is present.
* If the enemy is not present, it blocks its lines for 3 turns and then moves.
* If the enemy is present, ~~it alternates between copying its flag and copying code that will cause the enemy to copy that flag (a weak replicator)~~ it copies its flag
* At the end of the loop, it changes to a random direction and continues
* Most aspects of its code is duplicated
More testing showed a few important concepts:
* "Turn random" performed dramatically better than "Turn right" (+2700 over alternative)
* Block increment of `A+7` shown to be more effective than any other increment (+200 over next best)
* "Direct attack" shown to be better than "Weak replicator" (+900 over alternative)
* Defense of "3-1-2-1" better than other combinations (+200 over next best)
* Duplicated attack, block, and loop code improves its score (+300 over non-duplicated)
* Duplicated block increment does not improve its score (+400 over duplicated)
Observing the simulation graphically via the Java UI helped a lot. Thank you!
Below is the new and improved code. I don't think I can do anything more.
```
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
```
[Answer]
# Row Bot
```
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!
```
Will move until it finds a robot.  
Will set that robot in the same direction as itself.  
Will then copy its code into the robot.  
This should make a row of "Row Bot" Robots. :)
[Answer]
# Super Freeze
```
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
```
This bot keeps trying to freeze the bot in front of it until it works, then writes a bunch of flags to random lines, and after 8 turns of that it rotates and moves on to another opponent.
[Answer]
# Byzantine
A highly defensive bot that institutes multiple blocks on its flags and most sensitive instructions, including meta-blocks (i.e. blocks on critical block instructions).
It also moves constantly in unpredictable ways, and plants flags in numerous locations on opponents on a best-effort basis.
```
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
```
Not sure how it will perform, since I can't simulate. But we'll give it a shot. ;)
---
### Disclaimer
I wrote this before being kindly informed by PhiNotPi that conditional logic is cost-free. However, I've decided to leave it in since one can never have too many bots.
[Answer]
# Cadmyllion
"I just entered a bot in the battle royale," I say. "It moves every few turns to prevent attacks by slower bots."
"What do you mean by slower bots?" PhiNotPi asks.
"Bots that are stuck evaluating long chains of conditional logic," I reply.
"'If' statements that redirect to other statements---including other 'if' statements---are all executed on the same turn," says PhiNotPi.
"Sweet massacred rules of assembly code!" I cry. "Who came up with that idea?"
...and thus is the story of how Cadmyllion came about.
Cadmyllion: the bot that happily exploits the surreal ability to evaluate infinitely many conditional expressions in a single instruction... by making pretty much every thing it does conditional.
### Code
```
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
```
[Answer]
# Meta Insidious
This bot freezes and then converts opponents into less efficient versions of [Sparr's Insidious](https://codegolf.stackexchange.com/questions/36978/whats-wrong-with-public-variables/37055#37055), which in their turn, will turn opponents into bots that spam flags for me. This is likely the most complex bot I've written and I thus expect it to do terrible, there was no space for blocking and only one flag fitted in the code. Turning a bot into an insidious clone also takes too long.
The biggest challenge was writing the code for the insidious clones in such a way that it works regardless of its position in the bot. The freeze gets removed when I paste the second to last code exactly where the freeze is located, this starts up the opponent just in time.
```
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
```
[Answer]
# Repair and Protect
This bot repairs its own code, while protecting the newly repaired lines.
```
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
```
Explanation:
The initial value of `A` is `0`, and the lines are numbered 0-23. If the `If` statement is executed and is false, it does attempt the execute the same line again. The controller does not allow a bot to execute the same line twice, so the turn is ended and `C` is incremented to `1`.
The next line, `Copy #A #A+8` is actually performed regardless of the value of the `If` statement. The difference is that it is executed twice if true and once if false. If the line `#A+8` is blocked (which happens eventually), then performing it twice with actually copy, while performing it once will only unblock it. Then, the newly copied line is blocked to preserve it.
[Answer]
# Neutralizer
This bot makes its victim rewrite its entire program, making it worth 0 points. Once the virus is in place, it moves on. This is a scorched earth approach to victory.
```
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]
```
The comparison `*#*C==#7` doesn't seems to adjust for the opponent's shift correctly, but the bot does eventually move on.
[Answer]
# Insidious
```
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
```
Inspired by @Cruncher, this bot infects other bots with a small block of code, filling the other bot with this bot's flags. Those bots are then sitting ducks for further attack, but they will be mostly full of my flags when they get re-infected by someone else.
Edit: thanks to @PhiNotPi for golf assistance, @overactor for efficiency advice
[Answer]
# Happy As A Clam
This is an exercise in blocking. It performed remarkably well until [`$Copy`](https://codegolf.stackexchange.com/a/37312/) came around.
The clam has 22 block commands. Because `A` is shifted every loop, they will reference different lines each time through the loop. This allows each command to stack blocks on every other line, maxing out at 22 blocks per line. Thus, to break the fully armored clam, one would need to write to a line 22 times.
For example, `#10` will be protected each time through the loop by the following lines:
* Loop 0, A=0 `#10` protected by line 7 (`7+0+3`=10)
* Loop 1, A=7 `#10` protected by line 0 (`0+7+3`=10)
* Loop 2, A=14 `#10` protected by line 17 (`17+14+3`=34=10)
* Loop 3, A=21 `#10` protected by line 10 (`10+21+3`=34=10)
So after Line 10 of Loop 3, `#10` has been blocked 4 times, requiring 4 writes to `#10` to break the blocks, with a 5th one to actually overwrite the line.
Note that blocks are keyed by their `C` value and will **not** stack if the protected line was already blocked by the same `C` value. So after 22 blocks are established for each line, the blocks will no longer stack.
```
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
```
[Answer]
## MindControl
I guess it's never too late?
```
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 comes from my idea that it would take some considerable time to copy my whole program to the opponent, during which my bot is vulnerable to attacks from other directions. So why not make the opponent copy my program while I scan for enemies?
Once it finds an enemy, MindControl immediately freezes the enemy to prevent escape. Then it uploads the downloader to the opponent and let the victim download MindControl's program itself. The downloader exploit the fact that few bots uses `B` and will loop until it downloads all 24 lines. When the downloader rewrites `#19` from `Copy 16 C` to `Copy 23 C`, it signifies the victim have downloaded all lines and will go on to reboot itself.
The first versions of my bot does not include Blocks. And it was so vulnerable that almost any change is crippling. So I decided to add Blocks based on Wasmoo's $Copy (which is based on COTO's Lockheed). The downside I found is that it is difficult for the original to correct mistakes in the copies. But this is far from crippling and the score increased significantly so I kept the Blocks.
## UPDATES
I improved the downloader to keep trying to download until a successful rewrite to circumvent blocks. It does mean it takes one more turn to upload the downloader but my score doubled after this change!! Can't argue with numbers.
---
Another update. As you may have noticed, MindControl decides whether to attack target by comparing a random line between itself and its target. If they match, MindControl just assumes the target is already infected and leave it alone. (Side note: I used to use a static line for comparison but that gives lots of false positives and negatives) Turns out that gives a lot of false negatives. So I decided to exploit `==` and make some trivial changes like `C+23` to `23+C`. The program is functionally identical but different in the eyes of `==`. Now that MindControl has no line that is identical to any line in any other bot, it will 100% hit any untouched bot. Again, score increased significantly.
---
Improved the Downloader again. It now runs on a shorter loop. (which seems to have a large correlation with my score)
---
Improved Downloader yet again. Uses original bot's code so it uploads faster. Also added 2 random blocks which seems to improve score
[Answer]
# Attacker
```
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
```
[Answer]
# Movebot
```
Move
Copy 23 C
Flag
```
Like Flagbot, but move around while accepting gifts of code to go with all of our flags.
[Answer]
# Reproducing bot
This bot tries to freeze his opponent and then copy his entire code into that bot before restarting the other bot. This should also work (mostly) if the opponent uses blocking, though that does make it all even slower than it already is.
```
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
```
[Answer]
# Magus
Magus is a simple attempt at a self-propagating virus. It attempts to copy itself into the programs of other bots. (Edited to remove negative numbers, fix condition, trim lines.)
```
Block #A
Copy #A *#A
Copy A+1 A
If A #0 #4
Copy 0 *C
Flag
Move
Copy 0 C
```
[Answer]
# 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
```
This bot repairs its own code while moving and attacking.
[Answer]
# Blocker
```
Copy A+1 A
Block #A
Copy C+22 C
```
[Answer]
# Copycat
```
If D #4 #3
Move
Copy 23 C
Copy *#*C #1
Copy #23 *#E
```
[Answer]
# Quick freezerbot
Tries to copy flags in the line that will get executed next of his opponent, moves if there is no enemy to attack.
```
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
```
[Answer]
# Block, Freeze, Attack
```
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
```
Blocks all 24 lines, then loops 24 times either moving or attacking, then repeats. An attack involves attempting to freeze the opponent, then copying four flags to random locations, then turning.
[Answer]
# Hide, Block, Attack
This bot is based off of Block Freeze Attack. I changed the placement of some `If` statements to make it more compact allowing me to plant more flags. I also have it run away at the start of a game to buy some time to block.
```
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
```
[Answer]
# Roving Virus
```
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
```
This bot wanders until it finds an enemy, then freezes them, replaces all of their code with its own, unfreezes them, then wanders again.
[Answer]
# The common cold
It infects you virtually immediately and you'll spread it around. based on [PhiNotPi's Parasite](https://codegolf.stackexchange.com/questions/36978/whats-wrong-with-public-variables/37017#37017), the common cold checks almost immediately if it can copy its flag over yours. Blocks a random value if it can't. Moves around a bit if there's no opponent.
```
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
```
[Answer]
# Influenza
This is closely based off of the Common Cold (which was based off my Parasite) with slightly increased speed.
```
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
```
[Answer]
# Rebranding
```
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
```
This bot tries to randomly locate flags in enemy bots and replace them with friendly flags, turning away after detecting success. Inspired by Cancer bot.
]