[Question]
  [
All bots at the battle arena suddenly got brainfucked and no one can explain why. But who cares as long as they are still able to fight - although Brainfuck is the only language they understand anymore.
---
It's been a while since the last submission so I'll finally annouce the winner of BrainFuckedBotsForBattling: **Congratulations to LymiaAluysia for winning with NyurokiMagicalFantasy!**
---
## Scoreboard
```
|       Owner        |          Bot            Score |
|--------------------|-------------------------------|
| LymiaAluysia       | NyurokiMagicalFantasy -  600  |
| Sylwester          | LethalLokeV2.1        -  585  |
| weston             | MickeyV4              -  584  |
| Sp3000             | YandereBot            -  538  |
| Comintern          | CounterPunch          -  512  |
| Sylwester          | BurlyBalderV3         -  507  |
| LymiaAluysia       | NestDarwin            -  493  |
| IstvanChung        | Bigger                -  493  |
| Manu               | DecoyMaster           -  489  |
| archaephyrryx      | Wut                   -  478  |
| DLosc              | LightfootPlodder      -  475  |
| archaephyrryx      | 99BottlesOfBats       -  461  |
| Sylwester          | TerribleThorV2        -  458  |
| MikaLammi          | WallE2.0              -  443  |
| Mikescher          | MultiVAC              -  441  |
| archaephyrryx      | Twitcher              -  439  |
| Timtech            | MetalDetector         -  438  |
| AndoDaan           | BeatYouMate           -  433  |
| csarchon           | TheWallmaster         -  427  |
| Sparr              | SeeSawRush            -  412  |
| archaephyrryx      | Stitcher              -  406  |
| PhiNotPi           | RandomOscillator      -  403  |
| ccarton            | AnybodyThere          -  398  |
| Comintern          | 2BotsOneCup           -  392  |
| kaine              | SternBot              -  387  |
| PhiNotPi           | EvoBot2               -  385  |
| PhiNotPi           | EvoBot1               -  381  |
| Brilliand          | TimedAttack           -  373  |
| Sylwester          | ReluctantRanV2        -  373  |
| AndoDaan           | PrimesAndWonders      -  359  |
| Nax                | TruthBot              -  357  |
| DLosc              | Plodder               -  356  |
| weston             | FastTrapClearBot      -  345  |
| MikaLammi          | PolarBearMkII         -  340  |
| Sp3000             | ParanoidBot           -  336  |
| Moop               | Alternator            -  319  |
| TestBot            | FastClearBot          -  302  |
| icedvariables      | PyBot                 -  293  |
| TestBot            | DecoyBot              -  293  |
| kaine              | BestOffense           -  291  |
| Geobits            | Backtracker           -  289  |
| bornSwift          | ScribeBot             -  280  |
| IngoBuerk          | Geronimo              -  268  |
| flawr              | CropCircleBot         -  239  |
| plannapus          | CleanUpOnAisleSix     -  233  |
| frederick          | ConBot                -  230  |
| frederick          | 128Bot                -  222  |
| AndoDaan           | EndTitled             -  219  |
| PhiNotPi           | CloakingDeviceBot     -  215  |
| AndoDaan           | GetOffMate            -  206  |
| DLosc              | ScaredyBot            -  205  |
| isaacg             | CleverAndDetermined   -  202  |
| PhiNotPi           | CantTouchThis         -  202  |
| Moop               | StubbornBot           -  174  |
| Cruncher           | StallBot              -  168  |
| IngoBuerk          | Gambler               -  157  |
| BetaDecay          | RussianRoulette       -  129  |
| flawr              | DoNothingBot          -  123  |
| SebastianLamerichs | Dumbot                -  115  |
| mmphilips          | PacifistBot           -  112  |
| SeanD              | DontUnderstand        -  92   |
| proudHaskeller     | PatientBot            -  83   |
| frederick          | Dumberbot             -  70   |
| flawr              | MetaJSRandomBot       -  68   |
| Darkgamma          | TheRetard             -  61   |
| BetaDecay          | Roomba                -  61   |
| BetaDecay          | PrussianRoulette      -  31   |
| frederick          | Dumbestbot            -  0    |
```
*Final Scores from 09.10.2014*
**EDIT6**: Discarded logs due to extreme size and runtime. You can generate them yourself by uncommenting the lines in `RunThisTournament.py`.
**EDIT5**: Implemented Abbreviation handling into the controller, no huge runtimes anymore. **This has the side effect that numbers and parentheses are not treated as comments anymore.** You can still use them if you want to provide an annotated version, but it would be very helpful if there would be **also an uncommented version of your code**, so I don't need to remove the comments manually. Thanks!
**EDIT4**: Changed the title, because the tournament got removed from the hot network questions. Thanks to @Geobits for pointing this out!
**EDIT3**: Removed comments in bf programs, due to an unexpected result, should be fixed now. If anyone has a problem with removing his comments, please report.
**EDIT2**: Since it caused an arcane runtime on my quite slow computer, I reduced the timeout limit from 100000 cycles to 10000 cycles. Not that anyone has turned the resultof a running game beyond this point anyway.
**EDIT1**: Fixed a bug in the convert script causing the interpreter to not ignore numbers in commented programs.
---
## Description
This is a [Brainfuck](http://esolangs.org/wiki/Brainfuck) tournament inspired by [BF Joust](http://esolangs.org/wiki/BF_Joust). Two bots (Brainfuck programs) are fighting each other in an arena which is represented by a memory tape. Each cell can hold values from -127 up to 128 and wrap at their limits (so 128 + 1 = -127).
Valid instructions are similiar to regular Brainfuck, which means:
```
+ : Increment cell at your pointer's location by 1
- : Decrement cell at your pointer's location by 1
> : Move your memory pointer by 1 cell towards the enemy flag
< : Move your memory pointer by 1 cell away from the enemy flag
[ : Jump behind the matching ']'-bracket if the cell at your pointer's location equals 0
] : Jump behind the matching '['-bracket if the cell at your pointer's location is not 0
. : Do nothing
```
The arena has a size of 10 to 30 cells which is pseudorandomly chosen each battle. At both ends is a 'flag' located which has an initial value of 128, while all other cells are zeroed. Your bot's goal is to zero the enemy's flag for 2 consecutive cycles before he zeroes your own flag.
Each bot starts at his own flag, which is cell [0] from his own perspective. The opponent is located on the other side of the tape.
```
[ 128 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 128 ]
   ^                                             ^
my bot                                       other bot
```
Both bots execute their action simultaneously, this is considered one cycle. The game ends after 10000 cycles or as soon as one of the winning conditions is reached. If one of the programs reaches its end, it simply stops doing anthing until the end of the game, but can still win.
---
## Winning conditions
Your bot wins under one of the following conditions:
* Your enemy's flag is zeroed before yours
* Your enemy moves his pointer out of the tape (executes `>` on your flag or `<` on his own)
* Your flag's value is more far away from 0 than the value of your opponent's flag after 10000 cycles
---
## Rules
Your post should contain a name for your bot and its code.
* You can use the following abbreviation syntax to make your code more readable:
	+ e.g. `(+)*4` is the same as `++++`, this is valid for any instruction **except unmatched brackets in parentheses** since the loop logic collides with the abbreviation logic. Please use `[-[-[-` instead of `([-)*3`
* Every other character than `+-><[].` is a comment and therefore ignored, except `()*` for abbreviations
Bots which do not follow the rules will excluded from the tournament.
* Only basic Brainfuck is allowed, no other variants which supports procedures or arithmetic operations
* Your bot's source code should not contain unmatched brackets
You may inform yourself about [basic strategies](http://esolangs.org/wiki/BF_Joust_strategies) but do **not** use another one's code for your own bot.
---
## Scoring
A bot's score is determined by the number of wins against all other bots.
An encounter between 2 bots consists of 10 matches with different memory tape lengths, which results in a maximum score of 10 points per encounter.
A draw results in no points for this match.
---
## Control program
You can find the [control program](https://github.com/redevined/brainfuck/tree/master/BrainFuckedBotsForBattling) on github, along with the full logs from the battles.
The leaderboard will be posted here once it is generated.
Feel free to clone the repository and try your bot against the others on your own. Use `python Arena.py yourbot.bf otherbot.bf` to run a match. You can modify the conditions with the command-line flags `-m` and `-t`. If your terminal does not support ANSI escape sequences, use the `--no-color` flag to disable colored output.
---
## Example bots
FastClearBot.bf
```
(>)*9       Since the tape length is at least 10, the first 9 cells can be easily ignored
([          Find a non-zero cell
+++         Increment at first, since it could be a decoy
[-]         Set the cell to zero
]>          Move on to the next cell
)*21        Repeat this 21 times
```
DecoyBot.bf
```
>(+)*10     Set up a large defense in front of your flag
>(-)*10     Set up another one with different polarity
(>+>-)*3    Create some small decoys
(>[-]       Move on and set the next cell to zero
.           Wait one round, in case it is the enemy's flag
)*21        Repeat this 21 times
```
The DecoyBot will win every match with a tape length greater than ten, since the FastClearBot can avoid the small decoys, but not the larger ones. The only situation in which the FastClearBot can win against DecoyBot, is when it is fast enough to reach the enemy's flag before his opponent has built up large decoys.
  
[Answer]
# Cloaking Device Bot
This bot basically tries to hide its base, making it so that other bots will move right past it and off the tape.
```
(-)*127(-+--+-++)*12500
```
[Answer]
# Burly Balder v3
Burly Balder is a medium slow rush. It makes two large decoys before going into
rush mode. In rush mode it has a loop that only uses 4
steps each zero cell and when a non zero cell it has a case analysis for
[-18,18] before blindly reducing with 107 before clearing with `[-.]`. He
clears an unchanged flag in 242 steps, 114 more than a uncertain `-*128`
and 14 less than a naive `[-]` clear. When a cell is cleared he continues
leaving a trail of -2 decoys. He has a special case only for index
9 to save some steps for size 10 games and it leaves the cell with a 1 decoy.
```
>((-)*18>)*2                                  Make two minus seventeen decoys
(->)*6                                        Move to cell nine
[                                             special case for ten cell game 
   +[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[       if not minus one to minus eighteen 
   (-)*18                                     decrease by eighteen
   -[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[       if not plus one to plus eighteen
       (-)*107                                decrease by hundred and seven
       [-.]                                   slow clear
   ]]]]]]]]]]]]]]]]]]                         end plus conditionals
   ]]]]]]]]]]]]]]]]]]                         end minus conditionals
]                                             end special case
+
([>                                           while true go right
  [                                           start clear cell 
   +[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[       if not minus one to minus eighteen 
   (-)*18                                     decrease by eighteen
   -[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[       if not plus one to plus eighteen
       (-)*107                                decrease by hundred and seven
       [-.]                                   slow clear
   ]]]]]]]]]]]]]]]]]]                         end plus conditionals
   ]]]]]]]]]]]]]]]]]]                         end minus conditionals
  ]                                           end clear cell
  --                                          set to minus two 
 ]                                            while true end
 -                                           decrease and loop
)*5                                          In case of clash or initial column minus seven is zero
```
Trivia: Balder is a nordic god and son of Odin. He is known mostly for the [story of his death](http://ancienthistory.about.com/cs/norsegodspictures/a/baldersdeath.htm):
He was scared for his safety so the other gods tried to predict and shield against every threat.
He was eventually killed by Loki since while they protected him against swords and arrows they forgot to
protect him against Mistletoe.
[Answer]
# [Nyuroki Magical Fantasy](https://www.youtube.com/watch?v=i-C46RO4-a0)
I think it's about time to get serious~ I finished up my compiler for a little HLL to make writing BF Joust programs easier. This was my first serious attempt to make something with it. The bot's concept is pretty simple. It sets up a few decoys of varying polarities, then goes crazy with a large wiggle clear with a reverse offset clear in the middle.
Oh, by the way, the expected score is roughly 577 points against the last round's hill. That's a 93% win rate. <3
[Compiled](https://github.com/Lymia/JoustExt/blob/master/examples/nyuroki.bf) |
[Source Code](https://github.com/Lymia/JoustExt/blob/master/examples/nyuroki.jx)
```
Nyuroki Magical Fantasy by Lymia Aluysia
Released under the terms of MIT license
>>>>>>>>++<--<+<--<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+<-------------------------------------------------------------<---------------
----------------------------------------------<++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++<(-)*19(>)*8(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-
[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[
+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-
[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[
-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3
+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[
-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>
[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[
-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*
82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(
-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[
+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+
[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[
+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-
[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[
+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-
[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*
41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[
(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[
-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-
[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[
-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.]
.]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[
-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+
[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[
+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+
[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16
+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+
[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[
-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+
[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[
-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-
[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+
[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-
[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[
-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-
[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82
[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)
*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[
+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+
[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[
+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(
+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[
+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]-->[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[
-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+
[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]--)*2]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]--)*3]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]--)*4]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*5]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*6]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*7]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*8]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*9]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]--)*10]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]--)*11]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)
*12]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*13]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*14]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*15]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*16]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]--)*17]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]--)*18]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]--)*19]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*
20]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*21
```
---
**Edit**: I squeezed a few more wins out of Nyuroki.
**Edit 2**: Hey, look, I did it again!
**Edit 3**: After wrestling for a while with a stupid parsing bug in Arena.py, I finally got another improvement in~ This is what I mean by "time to get serious", you know. <3
[Answer]
# EvoBot 1
This is a simple bot created via genetic algorithm. I started with a template, and my program slowly adjusted the numbers to create a better warrior-bot. The code below has been edited to increase readability.
```
>+>---(>)*6(>[+++[-]])*30
```
I used the other entries in the competition to measure the fitness of the different candidates.
Since this was my first attempt at an evobot, I started with a simple template:
```
>(+)*n>(-)*n(>)*n(>[(+)*n[-]])*30  #template
```
I predict that this bot will receive a score in the 50s to 60s range.
~~I am currently working on a reverse decoy template.~~
# EvoBot 2
This is a bot created by the same genetic algorithm, but with the following template:
```
>>>>(-)*n<(+)*n<(-)*n<(+)*n(>)*8(>[+++[-]])*30  #template
```
This bot uses the reverse decoy strategy to set 4 decoys of varying height. The resulting bot is:
```
>>>>(-)*4<(+)*6<(-)*7<(+)*8(>)*8(>[+++[-]])*30
```
I expect this new bot to fare better than the previous bots, possibly earning a score in the 70s (probably much higher than that since there are many new entries).
[Answer]
# Alternator
It assumes most people will zero a cell by either adding or subtracting to it, so on average every cell will take 128 turns to zero.
```
(>+>-)*4>+(>[-][.])*21
```
Annotated version
```
(>+>-)*4       Move eight squares alternating polarity    
>+             Move one more
(
    >          Move to the next square
    [-]        Zero it
    [.]        Wait while it is zero
)*21           Repeat
```
[Answer]
So, someone else here using an genetic algorithm to try and make programs here. Well... a long time ago, I wrote an BF Joust evolver for an ongoing hill in an IRC channel. I decided to give it a spin for this contest as well~
And... unlike the other person with an evolver, my evolver can actually change more of the program more than repeat counts. :)
# NestDarwin (Generation 309)
This is the best result my evolver has come up with so far. I'm not sure how much the nested structure helps in this case, but, structures like this was what the evolver is meant to be able to do. Expected performance on the 27.08.2014 hill is 474 points. (Calculated by running the battle on all 21 tape lengths, and multiplying by 10/21. Note that this isn't normalized for the fact that this hill has one extra program on it)
```
(-)*5(>[(-)*4----[.+]]--((-)*5(>[(-)*4----[.+]]--((-)*5(>[(-)*4----[.+]]--((-)*5(>[(-)*4----[.+]]--)*10000)*10000)*10000)*10000)*10000)*10000)*10000
```
---
**EDIT**: Changed list of programs I wanna enter into this hill. Ran evolver overnight. :)
---
**EDIT 2**: I went and manually analyzed the evolver's output. Despite looking very different, NestDarwin is basically an optimized version of TinyDarwin... Manually minimized (with identical functionality) and analyzed:
```
(-)*5                     Break stuff that assumes flag size.
(>[(-)*8[.+]](-)*7)*3     Make a few larger decoys next to our flag. 
                          The clear loop is basically dead code here.
                          Few things are going to approach so fast, so.
(>[(-)*8[.+]](-)*2)*10000 And go on an rampage with an offset clear!
                          I presume the slow clear is to beat tripwires.
```
So, an almost identical program would be as follows... which is basically a super-optimized version of TinyDarwin. 
```
(-)*5(>.(-)*7)*3(>[(-)*8[.+]](-)*2)*10000
```
TinyDarwin was as follows. Not very different, hun? I'm just going to withdraw it from the hill. I thought it was distinct, but... well, I was wrong.
```
((-)*5>[(-)*4.[+.]].)*10000
```
It's become apparent that the current hill isn't strong enough to allow it to evolve much more complex things. :(
[Answer]
## Polar bear Mk II
There are two kinds of *polar bears*: those who get trapped and those who trap other people.
Tries to guess polarity of the opponent and then uses that information to lock opponent into infinite loop. Works well against simple clearing strategies and somewhat randomly against other. Traps can be quite easily avoided so I might add some backup strategies later.
```
>++>- create polar bear traps
[[]]<
[][
[[]]<
(+)*290 (>)*9  (+)*120 (.+)*16 (<)*9
(+)*112 (>)*10 (+)*120 (.+)*16 (<)*10
(+)*112 (>)*11 (+)*120 (.+)*16 (<)*11
(+)*112 (>)*12 (+)*120 (.+)*16 (<)*12
(+)*111 (>)*13 (+)*120 (.+)*16 (<)*13
(+)*111 (>)*14 (+)*120 (.+)*16 (<)*14
(+)*111 (>)*15 (+)*120 (.+)*16 (<)*15
(+)*110 (>)*16 (+)*120 (.+)*16 (<)*16
(+)*110 (>)*17 (+)*120 (.+)*16 (<)*17
(+)*110 (>)*18 (+)*120 (.+)*16 (<)*18
(+)*109 (>)*19 (+)*120 (.+)*16 (<)*19
(+)*109 (>)*20 (+)*120 (.+)*16 (<)*20
(+)*109 (>)*21 (+)*120 (.+)*16 (<)*21
(+)*108 (>)*22 (+)*120 (.+)*16 (<)*22
(+)*108 (>)*23 (+)*120 (.+)*16 (<)*23
(+)*108 (>)*24 (+)*120 (.+)*16 (<)*24
(+)*107 (>)*25 (+)*120 (.+)*16 (<)*25
(+)*107 (>)*26 (+)*120 (.+)*16 (<)*26
(+)*107 (>)*27 (+)*120 (.+)*16 (<)*27
(+)*106 (>)*28 (+)*120 (.+)*16 (<)*28
(+)*106 (>)*29 (+)*120 (.+)*16 (<)*29
(+)*106 (>)*29 [-]
]<
(-)*290 (>)*9  (+)*120 (.+)*16 (<)*9
(-)*112 (>)*10 (+)*120 (.+)*16 (<)*10
(-)*112 (>)*11 (+)*120 (.+)*16 (<)*11
(-)*112 (>)*12 (+)*120 (.+)*16 (<)*12
(-)*111 (>)*13 (+)*120 (.+)*16 (<)*13
(-)*111 (>)*14 (+)*120 (.+)*16 (<)*14
(-)*111 (>)*15 (+)*120 (.+)*16 (<)*15
(-)*110 (>)*16 (+)*120 (.+)*16 (<)*16
(-)*110 (>)*17 (+)*120 (.+)*16 (<)*17
(-)*110 (>)*18 (+)*120 (.+)*16 (<)*18
(-)*109 (>)*19 (+)*120 (.+)*16 (<)*19
(-)*109 (>)*20 (+)*120 (.+)*16 (<)*20
(-)*109 (>)*21 (+)*120 (.+)*16 (<)*21
(-)*108 (>)*22 (+)*120 (.+)*16 (<)*22
(-)*108 (>)*23 (+)*120 (.+)*16 (<)*23
(-)*108 (>)*24 (+)*120 (.+)*16 (<)*24
(-)*107 (>)*25 (+)*120 (.+)*16 (<)*25
(-)*107 (>)*26 (+)*120 (.+)*16 (<)*26
(-)*107 (>)*27 (+)*120 (.+)*16 (<)*27
(-)*106 (>)*28 (+)*120 (.+)*16 (<)*28
(-)*106 (>)*29 (+)*120 (.+)*16 (<)*29
(-)*106 (>)*29 [-]
```
[Answer]
# Pacifist Bot
My bot believes violence is never the answer and will try to avoid combat at all costs.
```
(.)*8       Since it takes at least 9 turns for a bot to come to mine, remain idle for 8
>           Skedaddle over one spot
([(>)*8     If a bot has approached, RUN
[(<)*8      If you accidentally ran into a bot, run the other way this time
]].         If it's safe here, chill out
)*6249      keep running until the end of battle, or until tired
```
[Answer]
# AnybodyThere?
Periodically looks behind to determine when the enemy has started clearing it's decoys, then rushes ahead.
Seems to do well, but I'm not sure if that's because of the strategy or just because I'm adding 10 to every cell before clearing.
Edit: Fixed a logic problem. First time writing a brainfuck program. It lives up to it's name.
```
>>>+<(+)*5<(-)*5>>             Initial defense
[                              While he hasn't passed us yet
  (>[([(+)*10[-]]>)*29])*4     Jump ahead four, checking for enemy
  +                            Front marker
  <<<<                         Check behind
  [                            If he hasn't passed us yet
    >>>
    (+)*5<(-)*5                Set decoys in reverse
    <<[-]                  
  ]
  >>>>                         Check ahead
]                              
([-[(+)*10[-]]]>)*29           Clear to the end
```
[Answer]
## WALL-E 2.0
Rushes to location 9 and adds 128 to it, winning quickly in size 10 arena if opponent hasn't changed initial flag value. On larger arenas, this works as large decoy. After that it fills the space between location 9 and own flag with large decoys. When decoys are placed, it scans for non-empty locations and tries to clear them quickly.
**Version 2.0** builds larger decoys and has some tolerance against changing initial flag value. It can also switch to backup strategy if things start to look hairy.
```
(>)*9
(+)*128 <
< [ (<)*7 ((-+-)*256)*15 ] > [ (<)*8 ((+-+)*256)*15 ]
(-)*47 < (+)*63 < (-)*72 < (+)*69 <
(-)*84 < (+)*66 < (-)*76 < (+)*66 <
++++ (>)*9 +.+.+.----.-.-. (>[-[++[(+)*124.+.+.+.+.+.+.+.+.>]]])*21
```
Effectiveness of this bot is based on two facts:
1. Most bots do not change the initial value of their flag.
2. Building large decoys is faster than clearing them.
[Answer]
# Lethal Loke V2.1 (with Mistletoe)
This is of course a deadly bot and he kills not only beautiful Burly Balder a with mistletoe, but wins almost every time against the other bots as well. It is a combined medium and fast rush. My test gives me a score of 567
[Compiled BFJ file for battle](https://gist.githubusercontent.com/westerp/e86fc8413a572dc907fb/raw/035d17d371412c6ef5766823239ea42664580a4a/LethalLokeV2.1), Racket BFJ generator source:
```
#lang racket
;; bare minimum bfj support
(define (bf . args)
  (apply string-append 
         (map (lambda (x) 
                (if (number? x)
                    (number->string x)
                    x))
              args)))
(define (dup x num)  
  (let loop ((n num) (lst '()))
    (cond ((< n 0) (error "Negative n"))
          ((zero? n) (apply bf lst))
          (else (loop (sub1 n) (cons x lst))))))
;; Useful procedures
(define (wiggle amount default-zero n)
  (let rec ((n n))
    (if (zero? n)
        ""
        (bf "["
            (dup "-[" amount)
            (bf "(+)*" amount)
            (dup "+[" amount)
            default-zero
            ">"
            (rec (sub1 n))
            (dup "]" (* amount 2))
            "]"))))
(define (goto from to)
  (let* ((dst (- to from))
         (op (if (> dst 0) ">" "<"))
         (abs (if (> dst 0) dst (- dst))))
    (if (= from to) 
        ""
        (bf "(" op ")*" abs))))
(define max-position 30)
(define initial-decoy  "(-)*17")
(define small-decoy "(+)*10")
(define large-decoy "(-)*32")
(define flag-position 7)
(define decoy-phase-end-position 14)
(define wiggle-amount 8)
(define plodd-clear "..(+)*120(+.)*27>")
(define plodd-inner-clear (bf "(+)*" 
                              (- 78 wiggle-amount) 
                              "..(+)*42(+.)*27"))
;; Main body of Loke V2
(define (generate-loke2)
  (bf ">" 
      initial-decoy
      ">->+>->+>->"
      (let gen-rec ((n flag-position) (p #t))
        (if (> n decoy-phase-end-position)
            (bf (medium-slow n))
            (bf "[" 
                (medium-slow n)
                "]" 
                (if p small-decoy large-decoy)
                ">"
                (gen-rec (+ n 1) (not p)))))))
;; Retreat goes back to home
;; leaving a trail of flags
;; from flag position
(define (medium-slow last-index)
  (bf (goto last-index 2)
      (let medium-rec ((n 2) (p #f))
        (if (= n flag-position)
                (fast-rush n last-index)
            (bf (if p "-" "+")
                "[" (fast-rush n (max 9 last-index)) "]" 
                (if p small-decoy large-decoy)
                ">"
                (medium-rec (+ n 1) (not p)))))))
(define (fast-rush cur-position last-known)
  (bf (goto cur-position last-known)      
      "([" plodd-clear 
      "("
      (wiggle wiggle-amount
              plodd-inner-clear 
              (- max-position last-known 1))
      ">)*" (- max-position last-known)
      "]>)*" (- max-position last-known)))
(display (generate-loke2))
```
**Trivia**: Loke (Loki) is a god in Nordic mythology that likes to play with everyone and trick them. He is a shape shifter (into animals and people) and usually goes his own ways. In the stories he often travel with and assist the other gods and does small tricks and stir things up. Besides killing Balder he fathered Hel (godess of Hell/Helvete), the beast Fenrir, and the Midgard Serpent that starts Ragnarok (norse armageddon).
**How it works**
In the beginning he makes a large (-17) decoy then make `+-` pattern all the way to index 7. He scan forwards from to 13 leaving a trail of (+10,-32)+ decoys but when he detects a set he will abort and start a medium\*1 rush mode. If no cells are set he will also start the slow\*3 rush mode.
\*1 In medium rush mode he has detected opponent activity in one of index 7-13 and he starts from index 2. Some opponents leave a zero and other leave a different value and he now have means to detect opponent activity while before making decoys in index 2-6 (-32,+10)+. If cell is not expected value (-1, 1) or he finished making all decoys he goes in fast\*2 rush mode.
\*2 The fast rush mode he expects he has been detected so decoys won't work. We hope the ones we already have set is stopping the opponent and focus on running through opponents decoys. He starts rushing at the farthest point we know based on the previous scanning [9,14] or index 9 if we were made earlier than that. He has special case for first decoy where we just add 120 and plodd 27 since he doesn't want to reduce tha value below zero incase it's a trap, but for every decoy after we wiggle clear at [-8,8] before increasing by 120 and plodding 27 steps ebfore contiuing forward to next cell. 
Slow rush mode was removed since it didn't affect the score with the current hill and it makes my bot a little smaller (but not much).
[Answer]
# Geronimo
Is even more offensive than kaine's BestOffense bot as it does not build up any defense. The strategy here is: Others will try to be clever, but being clever takes cycles. So let's just skip to the part we know the enemy is in and clear everything we find.
```
(>)*9(>[-])*21
```
Seems to win most matches against the OP's example bots and kaine's bot.
[Answer]
## SternBot
An actual half serious bot now that things are started. Addressing the simular nature of some of these bots.
```
(>->+>)*3(>[+]>[-])*21
```
[Answer]
# DoNothingBot
> 
> The best defense (...) is ignorance.
> 
> 
> 
```
.
```
It does nothing.
EDIT: Wow, I was astonished to see that it did a better job than more than the least 20% of all bots=) (Does this mean it uses a superior strategy or ....?)
[Answer]
# CounterPunch - Edited
Balanced combination of building a strong defense and then attacking.
```
(+)*6>(-)*12(>)*7(<(-)*12<(+)*12)*3(>)*7(([-([(-)*6[+.]])*5])*4>)*21
```
**Annotated:**
```
(+)*6                             Switch polarity of the flag
>(-)*12                           Build a quick decoy in front of the flag
(>)*7(<(-)*12<(+)*12)*3           Hop out and start building decoys backward
(>)*7                             Tally ho!
(([-([(-)*6[+.]])*5])*4>)*21      Clear toward the opposite end
```
Defends similar to @Geobit's [Backtracker](https://codegolf.stackexchange.com/a/36658/7464), but defends against fast attackers by putting a quick decoy out in front of the flag first.
Attack is nested clearing with opposite polarity to quickly clear out decoys with smallish values. Worst case scenario should be a decoy of 64 (either polarity).
**Edit 1:** Improve attacking efficiency against decoys (had a logic error in the polarity switching).
**Edit 2:** Testing indicates that the pause performs slightly better in the inner-most loop.
[Answer]
# Backtracker
A reverse decoy strategy. Start laying decoys down from the front back, so nobody skips over the rest as I'm building them. 
If the board is less than size 20 or so, this doesn't work against fast-attack bots, since we'll just pass each other before I start decoying.
```
(>)*9((-)*4<+<-<(+)*4<)*2(>)*8(>[-])*21
(>)*9                   Jump ahead 9
((-)*4<+<-<(+)*4<)*2    Lay down alternating polarity/size decoys for 8 spots behind
(>)*8                   Jump back forward
(>[-])*21               Clear until flag
```
Note: I don't BF, but this like it does what I want to me. If not, please let me now.
[Answer]
# Can't Touch This
This is a defense-oriented program that attempts to determine how the opponent is clearing cells, and builds a decoy of the appropriate size.
```
>---    create 1st decoy
>+      decoy for timing
>+      decoy for waiting
[]<     tripwire activated!
[<-->]  increase size of 1st decoy while opponent clears 2nd decoy
(>)*8   attack!
[+(<)*9(+)*20(>)*9]    slowly clear, while going back to stop enemy progress
>[+(<)*10(+)*22(>)*10]
>[+(<)*11(+)*24(>)*11]
>[+(<)*12(+)*26(>)*12]
>[+(<)*13(+)*28(>)*13]
>[+(<)*14(+)*30(>)*14]
>[+(<)*15(+)*32(>)*15]
>[+(<)*16(+)*34(>)*16]
>[+(<)*17(+)*36(>)*17]
>[+(<)*18(+)*38(>)*18]
>[+(<)*19(+)*40(>)*19]
>[+(<)*20(+)*42(>)*20]
>[+(<)*21(+)*44(>)*21]
>[+(<)*22(+)*46(>)*22]
>[+(<)*23(+)*48(>)*23]
>[+(<)*24(+)*50(>)*24]
>[+(<)*25(+)*52(>)*25]
>[+(<)*26(+)*54(>)*26]
>[+(<)*27(+)*56(>)*27]
>[+(<)*28(+)*58(>)*28]
```
I am currently working on a version that can win against both polarities.
[Answer]
# ImpatientTripwire (a.k.a. YandereBot)
Tries to be a tripwire so that it can lay decoys of (mostly) the corresponding polarity, but gives up if you take too long and assumes you're the opposite parity instead. Has a reverse tripwire for small boards.
```
(+)*5                                     Toggles the base
>-                                        Sets up reverse tripwire
>>++>-->                                  Sets up basic decoys    
(+)*20                                    Makes a massive antioffset tripwire
(([)*150                                  Waits for a while
    <<<<                                  Goes to check on the other tripwire
    +[
      <                                   Bot found you and is furious
      ((+)*128 (>)*9 (+.)*55 (<)*9)*5     Tries to tie you up
      ((+)*128 (>)*10 (+.)*54 (<)*10)*5   And torture you
      ((+)*128 (>)*11 (+.)*53 (<)*11)*5   As it destroys the world
      ((+)*128 (>)*12 (+.)*52 (<)*12)*5
      ((+)*128 (>)*13 (+.)*51 (<)*13)*6
      ((+)*128 (>)*14 (+.)*50 (<)*14)*6
      ((+)*128 (>)*15 (+.)*49 (<)*15)*6
      ((+)*128 (>)*16 (+.)*48 (<)*16)*6
      ((+)*128 (>)*17 (+.)*47 (<)*17)*6
      ((+)*128 (>)*18 (+.)*46 (<)*18)*6
      ((+)*128 (>)*19 (+.)*45 (<)*19)*6
      ((+)*128 (>)*20 (+.)*44 (<)*20)*6
      ((+)*128 (>)*21 (+.)*43 (<)*21)*6
      ((+)*128 (>)*22 (+.)*42 (<)*22)*7
      ((+)*128 (>)*23 (+.)*41 (<)*23)*7
      ((+)*128 (>)*24 (+.)*40 (<)*24)*7
      ((+)*128 (>)*25 (+.)*39 (<)*25)*7
      ((+)*128 (>)*26 (+.)*38 (<)*26)*7
      ((+)*128 (>)*27 (+.)*37 (<)*27)*7
      ((+)*128 (>)*28 (+.)*36 (<)*28)*8
      ((+)*128 (>)*29 (+.)*35 (<)*29)*8      
    ]-
    >>>>)*2                                 Waits again
      <(+)*20                               Bot got stood up, is sad
      <(+)*20                               Sets up some decoys
      <(+)*20                               Grabs a knife
      <(-)*20                               Licks the blade
      <(-)*5                                Locks the house
      >>>>>>>>                              Goes to hunt you down
     (
       >                                    Start searching
       [
         +[+[+[                             Search from minus three
         ---
         -[-[-[                             To plus three
         (-)*17                             If that's no good, do an offset
         [+]                                Clear by adding
         [-.--]                             Just in case
         ]]]]]]                             I would duplicate the program to skip these like at
       ]                                    the bottom but the file would get too large
       [--.---]                             Also just in case
       -                                    Leave a small trail
     )*22
(
  ]                                         Skip the bracket closing
  <(-)*20                                   Bot found you and is happy
  <(-)*20                                   Has just the perfect presents for you
  <(-)*20                                   You like decoys right?
  <(+)*20                                   Here's a plus one in case you are sneaky
  <(-)*5
  >>>>>>>>                                  Time to hunt you down
  (>[+[+[+[----[-[-[(-)*17[+][-.--]]]]]]]][--.---]-)*22
)*300
```
**Current version:** [1.3](http://pastebin.com/4GPDx0b0) - edited to do better on smaller boards, at the expense of losing games due to enemies sneaking past during tripwire checking
**Past versions:** [1.2.1](http://pastebin.com/SRJ5KnF7)
(I need a better clear algorithm :/ )
[Answer]
# Lightfoot Plodder - EDITED
Based on the [Plodder](https://codegolf.stackexchange.com/a/36685/16766), this speedy behemoth is able to "fast forward" through consecutive 0's quickly until it reaches something nonzero (at which point it starts plodding as expected).
Now improved with a more robust skimming algorithm, which also allows fast-forwarding through small decoys, and bigger decoys of its own.
**Edit #2**: Now is able to go back to skimming if it finds more pockets of zeros.
```
>(-)*4
>(-)*7
>(-)*4
>(+)*7
>(-)*17
>(+)*3
> -
>(-)*10
>(+)*16[-]<-
([
[>>
 [+
  [--
   [+++
    [<+>(+)*14[-]]
   ]
  ]
 ]<-
]>>
[(+)*126(+.)*4>]
<]+)*10
```
[Answer]
# Reluctant Rán v2
The strategy is easy. Try to get the opponent to think her flag is a decoy and precede past the board and loose (a kind of tripwire / vibrator). After 10 full rounds she gives up and tries to determine if opponent is at her flag and if not she will make -17 decoys until she hits a set cell. The clearing method she uses is special case for [-12,12] and starts plodding similar to Loke.
```
>>-<<                                  set a flag
(.)*11                                 wait for sixteenth step
((-)*256)*10                           reduce by ten rounds
                                       We give up check flags
> [(>)*7                               detected fast rush mode
    (-[>[
        -[-[-[-[-[-[-[-[-[-[-[-[       from plus one to twelve
        (+)*12                         reduce by twelwe
        +[+[+[+[+[+[+[+[+[+[+[+[       from minus one to twelve
          (+)*66..(+)*41(+.)*17>       increase and plod
        ]]]]]]]]]]]]]]]]]]]]]]]]]-])*3 
  ](-)*31
>+[(>)*6                               detected fast rush mode
    (-[>[
        -[-[-[-[-[-[-[-[-[-[-[-[       from plus one to twelve
        (+)*12                         reduce by twelwe
        +[+[+[+[+[+[+[+[+[+[+[+[       from minus one to twelve
          (+)*66..(+)*41(+.)*17>       increase and plod
        ]]]]]]]]]]]]]]]]]]]]]]]]]-])*3 
  ](-)*21
[>[                                    propably a trapper so we move slow
    ..+..-(+)*119(+.)*17               plodd the first cell so we dont go to zero on low positive
    ([>[
        -[-[-[-[-[-[-[-[-[-[-[-[       from plus one to twelve
        (+)*12                         reduce by twelwe
        +[+[+[+[+[+[+[+[+[+[+[+[       from minus one to twelve
          (+)*66..(+)*41(+.)*17>       increase and plod
        ]]]]]]]]]]]]]]]]]]]]]]]]]-]-)*3 
  ](-)*17
]
```
Trivia: Rán is a Nordic Mythology sea goddess that takes sailors before they die at sea.
[Answer]
# [Mickey V4](https://github.com/westonized/brain-fuck-java)
For V4 I used the same method as V3, against the updated bots but with more concurrent populations (30 not 10).
Developed against all 60 bots, including `BurlyBalderV3` and `LethalLoke` (but excluding 2botsonecup which is uncompilable by my strict implementation).
I discovered wildly different bots and success rates if I started with different random seeds. So I decided to separate these different starting points into populations and let them occasionally cross-pollinate.
In 1400 generations, 30 concurrently evolving populations created this program:
```
++>------>->---<<<------------->------>->
---->------------->>--->------<----------
------<------<-<<--<------------->-------
-<-->------>------->----------->---------
----->-------->------->----------------[>
[--[-[+]]]>[--[+]]-]-------[>[--[-[+]]]>[
--[+]]-]<--<------>------->--------------
--[>[--[-[+]]]>[--[+]]-]<--<-------------
--------->------>->-<-----
```
I calculate the win rate of this bot to be **90.0%** against the current crop. (1135/125/0 tape lengths won/lost/drawn).
## V3 info
Calculated win rate of 89.2% (1124/62/74 tape lengths won/lost/drawn).
## V2 info
The generation program now has analysis to tell which part of the end of the program is unused and trims it before generating the next generations from it. This means that random mutations happen in used parts of the program only and so evolution is faster.
72% against the current crop at the time. (892/204/143 tape lengths won/lost/drawn).
## V1 info
31500 generations, only 12 bots faced. 65% (165/80/7 tape lengths won/lost/drawn). I use all 21 tape lengths.
Potential bots are ranked by:
* most wins then;
* most draws then;
* quickest time drawn then;
* quickest time won
## Trivia
* Mickey is named after my cat and;
* To paraphrase T.S. Elliot: `The Naming of Cats is a difficult matter,
It isn't just one of your brainfuck bots`
* My java bf vm and genetic algorithm is on [github](https://github.com/westonized/brain-fuck-java).
* The vm is capable of running a complete tournament in under 4 seconds on a single core of an i7 (caution - results are not always identical to the tournaments engine).
[Answer]
# Gambler
This is closely related to my Geronimo bot. But where Geronimo is playing a sure thing, the Gambler tries to be quicker by doing what it does best -- gambling: It goes to the 20th cell and starts zero-ing from there.
That means that it might easily lose just because the arena isn't that big. But if it is, it might be the few cycles that count.
```
(>)*19(>[-])*11
```
Fun Fact: I was really considering entering a bunch of bots which all look like `(>)*X(>[-])*Y` where `X in 9..29` and `Y = 30 - X`. But I think entering twenty bots would be a little too much :) Or even forty if I had two versions, one which zero-s with `[+]` and one that does it with `[-]`.
[Answer]
## Dumbot
A remarkably stupid bot that just messes with the environment and hopes that the bots it battles all go off the tape.
```
(+)*50(>-)*7(([.])*50(+)*50>)*7([-])*256
```
(I'm not sure if this even works - it doesn't error out though!)
Annotated (with what I *think* it does):
```
(+)*50      Increase home cell by 50
(>-)*7      For next 7 cells, decrement once
(           Open loop
([.])*50    If cell is non-zero, do nothing. If cell is zero... Still do nothing? I'unno.
(+)*50      Now let's increment it fifty times for some reason.
>)*7        And let's do the above two instructions ten times more, in the next 7 cells
([-])*256    If the cell we're on is non-zero, decrement it continuously and hope it's the enemy.
```
(I will be staggered if this wins a single battle)
[Answer]
# CropCircleBot
```
[>>[+][-]-<[-][+]+][>[+][-]<[-][+]++]
```
This Bot uses advanced algorithms that were transmitted by aliens throu crop circles they placed on earth. It will change mankind and provide huge technological advancements and even solve many environmental problems.
[Answer]
# BeatYouMate
And because everybody should post a bot that will beat the first bot they post, here's a 5+ decoy laying bot:
```
(>------>+++++++)*4>([(+)*6[-]]>)*21
```
[Answer]
# CleverAndDetermined
```
>+>-(>+++[-])*21
```
Sets a few small traps, then races over to the other side, and tries to clear everything, above or below zero. Fails on `----`.
[Answer]
# MetaJSRandomBot
```
+[[>-[->+]>>[-]>-<<[>][+]<]+<]->
```
The idea behind this bot is making something total random that is still a valid js code without too much uselessness. I wrote following code ([JSFiddle link](http://jsfiddle.net/flawr/wn5x831o/)) for generating it. Lets see how well it does=)
```
var nchars = 30;
var nbrack = 10;
var alphab = "+ - < >".split(' ');
var s = [];
for(var i=0;i<nchars;i++){
    s.push(alphab[(Math.random()*alphab.length)|0]);
}
var ind1,ind2;
for(var i=0;i<nbrack;i++){
    ind1 = (s.length*Math.random())|0;
    s.splice(ind1,0,'[');
    ind2 = ((s.length-ind1-1)*Math.random())|0 + ind1;
    s.splice(ind2,0,']');
}
s = s.join('')
for(var i=0;i<Math.max(nchars,nbrack);i++){//remove useless stuff
    s=s.replace('[]','');
    s=s.replace('+-','+');
    s=s.replace('-+','-');
    s=s.replace('<>','');
    s=s.replace('><','');
}
alert(s);
```
[Answer]
# Prussian Roulette
Russian Roulette made a bet with his friend Prussian, and now it's his turn to play.
```
>(+)*5(-.[>.[>(-)*10]]>>)*1000
```
[Answer]
# Bigger
**The arms race begins!!**
Both builds and destroys walls of height ~~16~~ 18, bigger than most competitors. Also has a little logic to beat the cloaker, flag-defenders, anti-alternators, and bots that assume an untouched flag
```
+>->+>+>-(>(-)*18>(+)*18)*2(>([(+)*18[-][-[+]]])*2)*21
```
## Annotated version
```
Off by one
==========
Adjust own flag a little for fun
-
Decoy stage
===========
Build decoys
>->+>+>-        Add four quick walls to deter rushers
                Also throw off bots depending on the alternation
(>(-)*18
 >(+)*18)*2     Build four large decoys
Clear stage
===========
(               Repeat the following forever:
  >             Move forward
  ([            Skip if the space is zeroed already
      (+)*18    Bust negative decoys smaller than 18
      [-]       Clear
      [-[+]]    Check that the wall is actually cleared; if it isn't,
                clear in the opposite direction to defeat bots that try
                to sense our clear direction and defend the flag
  ])*2          Repeat the "non-zero" check to guard against the cloaker
)*21
```
[Answer]
# PatientBot
A partly serious bot.
this bot will attempt winning by the 100000 cycles limit.
it will go to the enemy flag while putting a few traps in the way, decrease it a bit, go back and defend the flag.
```
>++>->->+>+>->->+(>+[-[-[(<)*9--[<--](+)*10000]]])*20
```
it will assume everything bigger than 1 or smaller than -1 is the flag, and when it will encounter one, it will go back.
it defends by simply incrementing constantly. this assumes most programs will either use [] to check if the flag became 0, and so (+)\*100000 will be much faster
**Edit:** can't get it to work on the BF Joust interpreter. i'm giving up. maybe you should tell me how to improve my code.
**Edit:** now the bot makes the spot just before the flag 2, and after it decremented the flag a bit, it searches for a 2. this is meant to cancel the scenario where the bot would find a 0 cell other than the one before the flag.
]