BF Joust champions

From Esolang
Jump to navigation Jump to search

This page details major BF Joust programs, where "major" is, for the most part, defined as having been #1 on the either of the two hills, and gives the source for the latest version. Since the egojoust hill is now down, a condition has been added that being #1 on the "traditional" scoring system also counts.

2009

nescience_creep • Code: >+>->+>->+>->+(>-++-(.)*132[+]++>-++-(.)*132[-]--)*15

A very slow rush that leaves a trail of small decoys, using a simple clear.

ehird_defend8mwahahaha

Patashu_lazy • Code: >(+)*5>(-)*5>(+)*5>(-)*5>(-)*5>(+)*5>(+)*5>(-)*5(>(-.)*128)*21[-]((-)*2048(+)*2048.)*2

impomatic_shadow • Code: (>(-)*9)*2(>-)*7(>(+)*10[-])*20

A basic offset clear rusher that leaves slightly larger decoys than its predecessors, but no trail.

impomatic_spyglass • Code: (>(-)*9>(+)*9)*4(>(+)*10[-]++--[(---.)*9999])*21

A basic offset clear rusher with a counter-shudder/vibration backup clear.

nescience_shade • Code: (>(-)*9)*2>(>-)*4(>[(>(+)*10[-])*20]{})%20

An anti-tripwire offset clear rusher with a mix of small and medium sized decoys.

myndzi_slowrush • Trace and animation • Code: >(+)*22>(-)*22(>++++++>------)*1>+>->->+(>[[-(+)*22[-]]+>[+(-)*22[+]]->]+)*21

The canonical slow rush candidate. Leaves several much larger decoys, and uses equally large offsets in its clear. Leaves a trail and alternates polarity on each cell due to the tendency of many people to alternate the polarities of their decoys. Contains several guards against vibration/shudder style programs.

ehird_the_unknowable_reversi_of_slowrush • Code: >(-)*20>(+)*20>->+>->+>->+(>[[+-----------------[+.]]->]-)*20

An obvious modification of slowrush, possibly of an earlier version. This is the first champion program to use a 3-cycle clear (to foil simple lock defenders).

ais523_vibration_fool_faster • Trace and animation • Code: >>>++++<----<++++<(-)*127.(-+)*50000

A vibrator that leaves small decoys, set up in a reverse decoy setup, in an effort to ensure that it has cleared its own flag before the opponent arrives. Its major method of winning is to cause the opponent to miss the presence of the flag altogether, due to the 1 in 2 chance that it happens to be 0 when the opponent arrives; the rest of the time, it also has a chance to win the same way any other vibration program does.

myndzi_3pass • Code: >+>->+>->+>->+>---<++<--<++<--<++<++(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16(>[(-)*21[-[+]]](+)*19)*21

A fairly standard offset clear rush that constructs its decoys in three passes in order to give itself time to build bigger ones. In addition it leaves a trail of very large decoys, so it would be considered a rather slow rush.

Patashu_quickbeatinthestreetdanceonyo_feetcausethisissoneat • Code: +(>[(-)*19[+]]>[(+)*19[-]])*15

An alternating polarity offset clear that leaves no decoys and takes forever to reach the other flag. It's a wonder this thing ever won.

Patashu_rushpolarity • Code: >(+)*20>(-)*19>(-)*19>(+)*19>+>->->+>([(+)*19[-]](+)*15>[(-)*19[+]](-)*15>)*11

leonid__ugh • Code: ((>(+)*97>(-)*97)*2(>[-[+]])*4(<)*7)*59

ais523_defend9 • Trace and animation (with syntax fixes to replace unbalanced brackets with ({})%-based compression)

A lock-based defensive program that times how long the opponent takes to clear a large decoy, and uses that information in order to switch between one of many different lock algorithms, each tuned for a different cycle length and polarity. The free cycles in the lock are used for a full-tape clear.

Patashu_weave • Code: -->([-[+]]--->>)*15

Patashu_2_3weave • Code: (>(+)*23>(-)*23)*1>+>->->+>+>-(>[(-)*20[+]]->[(+)*21[-]]+>+)*10

ais523_defend7 • Trace and animation (Warning: This will take a long time to load)

A simple lock-based defensive program, which uses one decoy to defeat tripwire-avoiders, and one tripwire to judge its timing correctly. The lock itself is designed to beat two-cycle clears with either polarity; for one possible polarity, the flag never becomes 0 not even for an instant, preventing the opponent switching to a different sort of clear loop in order to break free. Free cycles in the lock are used for a full-tape clear.

jix_wiggle3

2010

jix_wiggle3 and myndzi_slowrush fought for first during 2010, no other competitor ever achieved first place.

2011

ais523_defend10

An evolved version of defend7. The main difference is a simpler and more efficient lock, that uses 256-cycle rather than 128-cycle intervals; this allows the full-tape clear to be shorter, simpler, and faster.

myndzi_careless • Trace and animation • Code: >+++++>+++++>----->----->+>->>>((>[(-)*126(-.)*3)*22(])*22)*22

ais523_defend13

A complex defence program that switches between several different strategies depending on what its opponent does. The program uses two reverse tripwires for the purpose of detecting whether the opponent is a rush program. Assuming either is tripped, it sets a regular tripwire nearer its flag, and observes the way it is cleared in order to attempt to determine the opponent's polarity (on the assumption that the opponent will likely use an offset clear, and thus trip the tripwire for one cycle first, then two cycles a little later, on only one polarity). It picks an appropriate lock algorithm based on the opponent's behaviour, generally assuming a two-cycle clear. Additionally, if the opponent appears to be stuck on the tripwire cell, it assumes a two-cycle clear and attempts to lock it there; should it escape, it assumes that it got the polarity right but the interval wrong, and uses a lock algorithm that works for multiple cycle lengths but only one polarity on its own flag. If the antitripwires are never tripped at all, it eventually assumes that the opponent is using a defensive program, and switches to a five-cycle rush algorithm that evades most locks.

ais523_decoybooster2 • Trace and animation • Code: (>)*7++<(-)*85(<(-)*85<(+)*85)*3(-)*43(>)*8(>[(+)*5[-.]])*21(+(.)*5)*10000

A slow rush program using reverse decoy setup to set several very large decoys (the first being small to avoid outright loss to tripwire avoiders). It actually contains a bug due to miscounting the number of decoys; although it means to change its own flag in order to avoid careless clears, it does so in an inefficient manner. It uses a three-cycle offset clear in order to defeat defence programs.

quintopia_wireless • Trace and animation

A slow rush with a large offset clear, a reverse decoy build of rather larger decoys, a flag decrement to foil turtles, and an alternating polarity clear to mess with the timing guessing of things like defend9. Uses a 3-cycle clear and anti-shudder techniques. Also tests a cell is nonzero four times before attempting to clear it to outwit small reverse tripwires in tight loops.

quintopia_wireless_frownie • Trace and animation

Uses a reverse decoy placement, plus a novel reverse offset clear. wherein it tests the value of the cell after every bump in the offset 25 times before decrementing and beginning a standard 3-cycle clear with shudder defense. The fact that it has to waste over 30 cycles after clearing a cell slows it down, thus further confusing defense programs. Other than this innovation, it's basically identical to the original version of wireless.

Gregor_mapping_turtle • Trace and animation • Code: -(>(+)*10>(-)*10)*4>([(+)*120(+.)*16.+>]+>[(+)*120(+.)*16.->]->)*11

Simple decoys and a careless turtle clear with a range of +/-8, leaving a trail of 1s and -1s. Takes advantage of the fact that taking the time to substantially change your flag is too expensive for many other opponents, but leaves you vulnerable to turtles.

quintopia_i_like_turtles • Trace and animation • Code: (+)*17>>>>(+)*33<(-)*65<(+)*91<(-)*128>>>>>>>>([-[++[(+)*15[.-]]]]>)*21

A basic 3-cycle offset clear rusher with a reverse decoy build. Primarily intended to defeat the slew of "turtle" warriors that assumed the flag was close to 128. The fact that this made it a champion reflects only the make-up of the hill at the time.

Gregor_high_fructose_corn_philip • Trace and animation

Essentially a careless turtle clear with the slight twist that it first checks within a small range of zero to avoid very small obstacles.

Gregor_sucralose_philip • Trace and animation

Same as high_fructose_corn_philip, but after finding four decoys, switches to a simple two-cycle clear strategy to avoid spending too many cycles on closing loops.

Gregor_lead_acetate_philip • Trace and animation

Same as sucralose_philip, but now with a quick offset of 64 before starting the inner clear strategy for both big decoys (which were popular at the time) and starting off the flag low.

quintopia_space_elevator • Trace and animation

Utterly insane.

Deewiant_pendolino • Trace and animation • Code: ->++(>)*5->+>+(>[-([+{[(+)*8[-].[.+]]}])%3])*2(+<)*4(+)*23<(-)*23<(-)*30<(+)*30<(-)*30<(+)*29(>)*9++(>[-([+{[(+)*8[-].[.+]]}])%3])*19

Bumps its flag to avoid simple careless clears before heading off with a fast rush for tape lengths 10 and 11. If the game is still on, it then backtracks to place decoys. Uses a clear that is adept at taking out small decoys and is typically shudder-proof, but can be tricked by locks and vibrators.

Gregor_furry_furry_leather_discipline_girls • Trace and animation

furry_furry_leather_discipline_girls is an extremely complicated slew of multiple strategies. The algorithm is something like this:
  • First leave a trail of small decoys (rule-of-nine length)
  • Now, using the poke strategy, find the enemy (still leaving a trail)
  • If we poked them at cell (0-indexed) 10 or before, set up about four decoys by the flag then use sucralose_philip.
  • If we poked them later:
    • Go back to the fourth cell. If it is not equal to 1 (what we set it to), the enemy is super-speedy and has been here, so switch immediately to sucralose_philip (no additional decoys since we suspect they're super-fast and probably on our flag, they have small or no decoys).
    • If the fourth cell is as we expect, then set the previous two cells to very large decoys (+/- 97, respectively)
    • We now treat the fourth cell as a tripwire, to very-slightly synchronize with the enemy.
    • If the fourth cell does not trip within 1000 cycles, we assume the enemy is either defensive or very clever, and switch to an extremely-conventional offset clear rush.
    • When the tripwire is tripped, we switch to a triplock strategy, going to the detected cell and spending 66 cycles in a two-cycle clear, then returning and simply doing (+)*255 or (-)*255 at the inner decoy. We go back and forth doing this until all cells are cleared, in hopes of locking the opponent at our inner decoy.

Deewiant_allegro • Trace and animation • Code: ->++>-->>+>>->+>+(>[(+)*9[-].[.+]])*2(+<)*4(+)*23<(-)*23<(-)*30<(+)*30<(-)*30<(+)*29(>)*9++(>[(+)*16[-].[.+]][-[+]])*19

Gregor_furry_furry_strapon_pegging_girls • Trace and animation

This program introduced two new strategies, the deep poke and breadcrumb decoys. It starts by doing a deep poke against the opponent, then goes back, building as many as three large decoys while filling every other intervening space with breadcrumbs. Then it reverses, turning every breadcrumb decoy into a large decoy until one has been perturbed. Finally, it advances to the location it found by the deep poke and uses a simple rush with offset clear and shudder avoidance from there.

ais523_waterfall3 • Trace and animation (warning: very long and very slow to load)

A defence program based on a series of locks; as each lock is broken, it reveals more information about the opponent's strategy, giving an idea of which lock to try next. It starts by setting up some small decoys for the purpose of not losing horrifically to pokes, and some reverse tripwires in order to be able to detect being overtaken by fast rush programs, then starts a reverse decoy setup, periodically interrupting to check the tripwires. If it notices that any have been tripped during the decoy setup, it switches to a simple two-cycle lock. If the opponent does not interfere, it sets a series of large decoys, many of which are also used for locking or as tripwires later. An advanced reverse tripwire is then periodically checked for a while to see if the opponent is attacking; and a reverse tripwire much nearer the flag is checked more frequently, in case the advance tripwire is detected somehow. (If the tripwire near the flag is tripped, it attempts a triplock combined with a full-tape clear on the cell next to its flag; should it find that the cell it's trying to triplock on is unexpectedly 0, typically a sign that the lock has been broken, it switches to a two-cycle lock on its flag, written with the assumption that the reason the lock was broken was due to a two-cycle reverse offset clear with the polarity that would break the lock, given the relative lack of information.) Another possibility is that neither tripwire will be tripped for a long time, indicating a passive or waiting enemy; in such a case, it switches to a 4-cycle anti-shudder reverse offset clear (a combination which none of the defence programs at the time were capable of locking; although 4-cycle clears are vulnerable to 2-cycle locks, making them reverse offset clears avoids that issue), with an unusually large trail, on the basis that the opponent is probably defensive enough that it might actually have some effect. More commonly, the advance reverse tripwire (8 cells from the flag) will be tripped first (as opposed to the early tripwire, or neither tripwire), in which case the program's main strategy begins.
Unlike many other programs, waterfall3 uses the tape for computation (rather than just in an attempt to confuse the enemy); the cell 2 cells from the flag is maintained blank for that purpose, and once the cell 8 from the flag has been seen to have been attacked, its value is changed to distinguish it from a reverse tripwire on the cell 3 cells from the flag. Then, an "offset tripwire" strategy is used, where it attempts to offset-clear the cell 7 from the flag (which has a large decoy on), except that it stops after a while and uses the cell as a tripwire instead. (The idea is to synchronize with the opponent, but to start moving again rather than go into an infinite loop if the opponent had already cleared the cell and left a trail.) In order to break out of its loop safely, it moves back to the cell 2 from the flag if it detects a zero, so that its flow control is not disrupted by enemy trails; and it then uses the reverse tripwire on the next cell to detect whether it made such a move or not. Meanwhile, it also tries to detect enemy careless clears (which would otherwise leave it stuck on its tripwire forever), which is only successful on one polarity; if it does, it goes and deletes its own decoys, in order to prevent decoy-counting careless clears (which were high on the hill at the time) changing strategy on the basis that the clear seemed not to be working, and thus letting them fall off the end of the tape (and meanwhile, trying to triplock a different cell just in case the "careless clear" was actually a misdetected reverse offset clear). Once this feat of synchronization has been accomplished, it moves onto its first actual lock.
The first lock is a 3-cycle lock on a large decoy 6 from the flag. It has two major purposes. First, it locks 3-cycle programs with the right polarity, like any other lock does. (If the lock seems to be holding, the cell before is converted to a reverse tripwire, then it alternates between locking and checking the reverse tripwire to see if it really is a perfect lock or not. If it is, it simply does a full-tape clear while maintaining the lock, randomizing the polarity of its clear in order to defeat defence programs on short tapes which have been misdetected due to an unfortunate clash of decoy patterns.) Second, the length of time it takes to break the lock, for the vast majority of programs that happen not to be 3-cycle clearing with the desired polarity, gives away what polarity the opponent is using for their clear, because a large decoy takes much longer to clear with a 2-cycle clear and a 3-cycle lock in opposite directions, than in the same direction. (This is the main difference between waterfall2 and waterfall3, incidentally; and also the most common reason for waterfall3 losing, as it can end up getting accidentally locked in the process due to bad timing interactions on the loop in question causing it to not notice that the cell was temporarily zeroed, something which means that changing the value of constants slightly can drastically affect its performance. The version that came first on the hill had a genetic algorithm tweak the constants until they beat all other existing programs.)
If (or most likely when) that lock is broken, the next lock depends on the polarity in question. If the 3-cycle lock had the right polarity, a standard 2-cycle lock is done on a decoy two squares before (so that enemies that alternate polarity in their clears will be on the same polarity as they had on the cell where their polarity was detected). (It's used first to finish decoy setup, then to do a full-tape clear). A reverse tripwire before the cell it locks on is also checked during the lock, to see if it was broken; if it was, then it triplocks with an inline clear (to keep the length of the program down) on a decoy on the cell next to the flag (and if even that triplock is also detectably broken, it moves back to its flag and shudders in the hope of salvaging a draw). If the 3-cycle lock had the wrong polarity, the setup is similar, except that it maintains two locks at once (on two different cells), using the spare cycles in the 2-cycle lock to maintain the 3-cycle lock and vice versa. This leaves only a small number of cycles to do decoy setup and full-tape clear, not to mention the reverse tripwire checks, but it's enough to maintain it over the majority of the tape. However, this is sufficiently slow that the full-tape clear is in danger of not finishing before the cycle limit, so if the clear reaches the 5th-from-last cell and still no program has won, it instead uses its locks to set up large decoys on every cell between the lock and the flag, and then changes to a standard 2-cycle offset clear rush on the remaining cells. (This is the codepath shown in the trace-and-animation above, and takes over 97000 cycles to win, dangerously close to the cycle limit.)

ais523_slowpoke • Trace and animation

Another program based around the deep poke strategy. The main difference between it and similar programs was the relatively fast decoy setup (designed to beat other deep-poking programs), and the use of a two-cycle anti-shudder offset timer clear, to beat rush programs quickly whilst still evading locks.

2012

david_werecat_dreadnought • Trace and animation

Leaves a trail of alternating small decoys until the enemy is found, then switches to the defensive. If the enemy is found early or late, the tape size is known and so the program will seek directly to their flag. While in the defensive, it tweaks the flag and strengthens the decoys using a 2n scheme, placing one decoy per every second space before the enemy was found with a maximum of 6 or 8 decoys. The program then seeks forward to either the tenth space or where the enemy was first found, whichever is further. It then uses an order 6 fast clear and an order 38 offset clear to attack. The clear is also offset with a secondary clear with reverse polarity to confuse intelligent programs. If a cleared space is re-enabled after 3 cycles, it moves onto the next space since the enemy is probably using a triplock.

quintopia_space_elevator • Trace and animation

Lays two reverse tripwires in opposite directions before running off to do a fast/shallow poke, leaving a minimal trail as it goes. Upon identifying the enemy, it backs up and leaves a medium-sized decoy to delay slow rushers while it does further processing. Then it backs up to check its reverse tripwires, leaving a size 1 trail along the way to slow down tripwire-avoiders long enough to put decoys in front of them.
If either are tripped, it assumes it is facing a fast rusher on a short tape, which therefore has few/small decoys. In this case, it runs back to where it poked and starts a reverse offset clear rush under the assumption that the fast-rushing opponent is already working on its flag. If it finds a large decoy at the position it poked to, it will tear it halfway down, then return to its own flag to repair it. This code path is illustrated here: Trace and animation. If it does not find a large decoy, it will clear the small decoy it found, return to its own flag, then wait a while before repairing it. (Hopefully, it waits long enough that the opponent has made significant progress on the flag, though, without proper synchronization, it sometimes fails.) It then returns to its regularly-scheduled reverse-offset clear rush, praying that it bought itself enough time to finish off the opponent's flag. This code path is illustrated here: Trace and animation.
If neither are tripped, it bumps its own flag to foil careless and reverse offset clears before building more very large decoys backwards from the first decoy it laid. Depending on how far away it believes the opponent is, it will lay as many as nine more decoys this way. The decoys do not alternate polarity, but rather change polarity in an unpredictable fashion. If the opponent was poked at a greater distance, it finishes its decoy build before attacking. If the opponent is believed to be close, it will build two decoys, rush the opponent long enough to clear two more cells, then return to build a third decoy. This is so that, if the opponent was detected because the tape is actually very short, it will avoid wasting more time building decoys against opponents who are already attacking its flag. After it returns to build this extra decoy, it assumes it must be on a longer tape and rushes ahead to two spaces ahead of where it knows it is safe to go. This causes it to suicide against some opponents on certain tape lengths, but successfully compensates for the fact that it builds far fewer decoys in this situation by ignoring some of the opponent's decoys. This code path is illustrated here: Trace and animation.
The rush it uses checks for small decoys before using a clear with a very large offset. This large offset is a disadvantage against opponents who use lots of small decoys, but a significant advantage against opponents using large decoys. This large offset, combined with the fact that it changes the polarity of its clear after two cells have been cleared, also serves to confuse defenders who try to determine what sort of clear it uses. It has simple anti-shudder, anti-triplock, and anti-vibration tactics built in, and leaves a trail of size 2.

david_werecat_leviathan • Trace and animation • Code: (>++>-->-->++)*2((+)*6<(-)*6<(-)*5<(+)*5<)*2--(>(+)*50>(-)*42>(-)*46>(+)*48)*2>>>(([----[+[+[+[+[+[+[+[+[(+)*38[-][+][+--]]>{}]>]]]]]]]]>)%21)*21

Sets up eight large decoys using multiple passes, then moves to the twelfth space to commence its attack. The clear strategy is an order 4 wiggle clear paired with a order 38 offset clear. It also utilizes several methods to avoid locks; such as polarity reversal, a four cycle vibrating clear and a loop escape mechanism.

quintopia_a • Trace and animation

Leaves a series of reverse tripwires moving away from the flag until evidence of the opponent is encountered. If this happens early, a fast rush is attempted. Otherwise, a medium-small decoy is left at the 11th cell and larger decoys are built in a forward setup away from the flag until one of the reverse tripwires is found tripped. (This is the breadcrumb decoy strategy.) Then, the decoys behind this decoy are increased until they are 85 tall (which is the tallest reasonable size for a decoy, since an offset higher than this would be madness unless it were a reverse clear). Finally, it rushes beginning from a cell that is further ahead the further away the opponent was first encountered. It uses a wiggle clear with offset 70, the largest offset ever used to date. This large offset causes it to lose against opponents who leave many small decoys and use small offsets, since, having spent less time building decoys, they will have made more progress through the reverse tripwires by the time the forward decoy setup reaches them, and since quintopia_a requires around 240 cycles on average to clear even a reasonably small decoy. This program builds at most 10 large decoys, so it can be defeated also by programs that build many decoys (such as Gregor_furry_furry_strapon_pegging_girls on long tapes). Compare the two versions of the breadcrumb decoy strategy used by the two programs jousting in the "Animation" link above.

quintopia_space_hotel • Trace and animation

An upgrade of quintopia_a. It adds a space_elevator-style poke, beginning in the middle of building the decoy at the 11th cell, and behaves differently depending on far away it finds the opponent. It builds decoys using quintopia_a's strategy before returning to the poked position. If it found the opponent close to its decoys, it will skip several cells past this position, assuming those cells contain decoys. If it finds the opponent far away, it assumes it's facing a fellow slow rusher and builds a few extra small decoys in front of its decoy build on its way to the poked position.

2013

ais523_anticipation2 • Trace and animation

The code that generates this program (the program itself is heavily golfed via the generation script, so that it fits within implementation limits of the egojoust hill)
A vibration program with heavy synchronization. It starts via a complex (mostly reverse) decoy setup to buy time for its synchronization pattern. (The decoys used for synchronization themselves are only set up partially to start with, and start to be enlarged to the required height just before the opponent reaches them, using the principle that decoys can be set faster than they can be cleared, in order to save time in the initial decoy setup and thus increase the chance it completes before the enemy gets inside it.) Two tripwires are used to check whether the enemy has nonetheless got inside it; if the one nearer the flag is tripped, it instantly switches to a lock and full tape clear algorithm (from shudderlock) on the flag, because the opponent is probably there already, and if the one further from the flag is tripped, it synchronizes on a tripwire and then uses the shudderlock algorithm from there.
If the decoy setup works, anticipation2 tests how long the opponent takes to move on from clearing a very large decoy to clearing a size 1 decoy. (The large decoys are used to reset any special-casing that the opponent might be using for small decoys that might leave them in an unusual place in their control flow; anticipation2 relies heavily on the opponent doing the same thing in the same circumstances.) Most programs will only take a few cycles to clear a size 1 decoy no matter what was before it, but there are exceptions (and the exceptions make up the bulk of the program, which is just repeats over and over again for the various possible times). What anticipation2 is actually trying to measure is not when the cell is cleared, but when the cell is tested for zero; it does this by assuming that cells are adjusted immediately after zero-testing them and finding them nonzero (which is true in the vast majority of programs), because doing anything else would simply waste time. Obviously, half the time, the cell will be adjusted in the wrong direction and anticipation2 won't be able to observe the zero test; in order to allow for this, it does two tests, one for one polarity, one for the other polarity, and two cycles apart (in order to leave the enemy program on the same polarity if it alternates polarity).
When anticipation2 has a good idea of when the opponent's zero test will be (or failing that, when it sets the size-1 decoy to zero, which is always observable), it sets up the same situation as the situation it had already measured, but with the size-1 decoy as its own flag. Then it sets it to zero on, hopefully, the cycle when the opponent zero-tests it; and because most programs don't test cells that were zero when encountered again before moving on, those programs fall off the end of the tape. (As such, anticipation2 is a true vibration program; its main method of winning relies on setting its flag to zero when the opponent encounters it. It was actually written as a follow-up to a vibration program doing unexpectedly well on the hill.)
If the game is still continuing at this point, the primary strategy has failed, but there is a strong secondary strategy: it has a very good idea of when the zero occurs in the opponent's clear loop, which allows shudderlock's lock algorithm to be used (it's independent of the cycle length of a clear, as long as it's an integer, but requires knowing when the locked-on cell is approximately zero). The lock is combined with a full-tape clear, and beats many programs that are running enough counter-vibration to not lose to the main strategy.
There is one other codepath: if none of the tripwires are tripped for 8000 steps, it assumes that it's facing a defence program, and rushes it (very slowly) with a 5/3-cycle clear algorithm with antishudder and antivibration. (Non-integer clear loops are very slow because they inevitably end up missing the fact that they've zeroed the cell they're on more than half the time, and as such end up having to clear it multiple times before being able to move on.) No defence programs at the time could lock that sort of clear, and it seems unlikely that any will be developed.
The standard example program beats anticipation2 because its complete lack of antishudder/antivibration/wiggle causes it to move from one cell to the next faster than anticipation2 can detect it, so the example linked above shows anticipation2's performance against a typical slow rush program.

ais523_omnipotence • Trace and animation

omnipotence has properties both of a defence program, and of a fast rush program. It starts off with a slow poke that clears and continues poking upon encountering any decoys of size 1, 2, or 3; as such, against the programs common at the time that do a poke or slow poke and just leave a few decoys to detect fast rush programs, it pokes all the way to the enemy flag. The enemy will probably poke all the way to omnipotence's flag at the same time (especially because it's intentionally tripped the enemy tripwires to encourage them not to bother with their normal decoy setup), but it's designed to allow for this. Alternatively, if the opponent is a rush program that doesn't poke, it will just move to omnipotence's flag naturally, because it sets only one decoy (of size 1). (The decoy is increased to size 5 after the poke is finished, and serves to slow down programs that are confused by small decoys or that don't poke yet spend a long time on their own decoy setup. Perhaps surprisingly, such programs actually exist.)
After the poke, it moves back to its flag and adjusts it (first down, then back up again); this forms the start of a lock algorithm. (This is required because the opponent has probably made progress on omnipotence's flag, and thus would clear first in a straight race.) After fixing its flag, it moves to the poked location and starts clearing it with a reverse offset clear (returning once during the clear to its own flag to repair it). If the game is still going at this point, the poke failed to find the opponent's flag (e.g. against traditional non-poking slow rush programs, or against defence programs), or found it but it had an unusual value (shudder/vibration programs, or programs with really extreme anti-turtling). It continues in such cases with an attempted lock on its flag. Due to the complete lack of synchronization, it uses defend7's lock algorithm: against 2-cycle clears, this gets a perfect lock 9/16 of the time, a detectable lock (i.e. one that the opponent can break out of via noticing the flag not being zero just after it was cleared) 3/16 of the time, and simply loses 1/4 of the time. (This still gives it a good win percentage against a majority of programs.) It tends to lose quickly against programs that don't use a 2-cycle clear loop, though. However, because it intentionally trips enemy tripwires early, opponents tend to conclude they're facing a fast rush program and thus don't use countermeasures against defence programs, and so the lock is broken less often than a typical defensive lock would be.
While locking, its own clear is a modified full-tape clear designed to do well against defence programs. (Against rush programs that are correctly locked, it doesn't matter how long it takes to win, because it will win eventually, and it'll lose anyway against timer clears that aren't beaten quickly, so optimizations against defence are worthwhile.) As such, it attempts to clear the detected flag location twice in both directions, and the two cells after it once in both directions, before moving on. (Other cells are just cleared once. Just in case there's some program which it's still in race with that's moving really slowly.)
omnipotence also has some shameless special casing against a couple of programs (waterfall3 and space_hotel); it detects them via recognising their decoy setup, and switches to a very fast rush algorithm against space_hotel (a wiggle clear for getting past its decoys as fast as possible, and a reverse offset clear for its flag, probably the most all-in of rush strategies), and a very slow rush algorithm against waterfall3 (a 7-cycle full tape clear which intentionally corrupts tape elements that waterfall3 normally uses for calculations; being 7-cycle prevents it being tricked off the end of the tape, and being a full tape clear prevents it being locked).
The example linked above shows omnipotence picking on its natural prey, a slow poke program (ais523_slowpoke). (Although it beats the standard example program, and on every tape length and polarity, it does so via a full tape clear, so the resulting trace and animation takes a long time to load.)

Oj742_smartlock • Trace and animation

smartlock is a program that uses an absurd amount of timing cases based on multiple, irregular tripwires to determine the polarity, offset, cycle, and other properties of the clear of an opponent program, so that an accurate lock can be created. The standard cases assume a 2-cycle or 3-cycle clear of a certain polarity, an offset (near the values 0, 16, 32, 64, 128, or 256) of another polarity, and whether a wiggle clear is used. To prevent any kind of irregular/timer clears from breaking the lock, the program attempts to trap the opponent on a decoy flag for a large number of cycles. If they break free, the program switches to shuddering the flag and hopes for the best.
The lock itself is more dynamic than the standard lock strategy, as it skips any cell that has a value of -1, 0, or 1. To do this, it uses three cells for computation, which have to be cleared before the lock begins. If they cannot be cleared quickly enough, the program modifies the decoy flag to buy some more time, then switches to an offensive strategy.
There is also quite a lot of special casing against programs smartlock normally wouldn't be able to beat. For most of them, it's simply a lock that is different from the standard cases, due to an abnormal clear method and/or an offset that tricks the program. However, some make the program switch to a different (and likely offensive) strategy, specialized to work against the program that it thinks its up against.
smartlock's backup offensive strategy is a combination of large decoy avoidance, timer clear, and reverse offset clear. It's anti-defense strategy (which is used if the first tripwire is not cleared within 6200 cycles) involves a complex flexible timer clear based off of Oj742_smart_timerclear.

2014

ais523_preparation • Trace and animation (warning: very long and slow to load even in 2014)

The dramatic debut of the probabilistic lock strategy. preparation follows a variety of different strategies:
Initially, it sets ten decoys (most of which are subsequently used as tripwires). This causes an immediate loss on tape length 10, but the tenth decoy gains more against tripwire avoiders than it loses against programs which might actually be beaten on tape length ten.
It then checks for a clash in decoy setup via checking to see if the eighth of these decoys has been disturbed. If it has been, it switches to a fast rush strategy based loosely on ais523_stealth; it moves right, attempting to preserve the structure of the tape, via undoing the ninth and tenth decoys and then using a method (adapted from a wiggle clear) that can preserve with many but not all sequences of decoys valued 1, 2, and 3 (specifically, it can only move forwards, or one step backwards, in the sequence of decoy values 0, -1, 1, 2, -2, -3, 3, 0, 1, -1, -2, 2, 3, -3, -4, 4, 5, -5. Upon finding a cell with a larger value, it's most likely a flag, and thus a reverse offset inflexible timer clear (with anti-vibration; the timer is used to beat shudder programs) is used. This algorithm works well against the dominant-in-2014 poke-and-slow-rush programs that use reverse tripwires to guard against fast rushes; restoring the value of the tripwire means that the opponent often doesn't realise that its flag is under attack and continues setting decoys rather than taking countermeasures.
If there wasn't a clash of decoys, the first seven decoys are all then raised to size 2 and then 3, checking in the process to see if they've been zeroed (which is faster than a true reverse tripwire check). If any have been zeroed, it assumes it's facing a fast rush program that set only minimal decoys, and switches into a very fast rush algorithm, moving forwards until it finds a cell of magnitude 9 or larger, then trying to clear values near 128, then if that fails, switching into a three-cycle clear in the other direction (which at this point is effectively an order-136 offset clear, which completely throws off the synchronization of any defence program that might be intentionally tripping tripwires to disguise itself as a fast rush program. If there appears to be time (i.e. the opponent was found far from the flag), it sets some small decoys to aid with this; the first decoy is increased to size 12, and if the enemy was detected on the second check, the second and third decoys are increased to size 52 if they are undisturbed.
At this point, the eight decoy is increased to be a very large decoy; this is the cell that the opponent will be locked on. Before the lock starts, the first seven decoys are checked once more, this time checking them to see if they have the expected value of 3, rather than just if they're zero. If they're found to have been disturbed, their actual value is checked to gain an idea of the enemy's activity on the cell; values near 3 are considered to be small decoys, values near 0 to be clears/trails, and other values to be large decoys. If the enemy seems to be clearing, they're probably already on the flag; the flag is repaired, then a fast rush (similar to the previous fast rush strategy but simpler) is used, with the starting point estimated as the ninth cell after the first cell cleared (which is the enemy flag, if the enemy is using the rule of nine). Otherwise, the opponent is probably among the decoys, and so each undisturbed cell is made into a large decoy before entering the clear loop; an attempt is made to detect whether the opponent is actively clearing via checking the order in which the decoys are removed (under the assumption that a clear loop moves forwards, and a decoy setup moves backwards because reverse decoy setups are so common), but this is only used to decide whether to start at the 11th cell or to the ninth cell after the first cell cleared (as in the previous case).
The program then starts the probabilistic lock loop. It does the following things with its spare cycles:
  • First, it checks the first seven decoys to see if they have the expected values. Again. (This is the fourth time, for people counting.) If the decoys are broken at this point, the assumption is that outracing the opponent is impossible (it's probably on the flag, and probably has too many decoys to race). Thus, it switches to the defend10 strategy, after waiting 128 cycles (spending the time engaging in counter-turtle tactics) in order to get a good estimate of synchronization with the enemy. During this time, a 16-cycle gap is left in the probabilistic lock.
  • The lock is strengthened to a 15-cycle gap for the rest of the program. It now spends its time building a large decoy on two cells to the left of the lock cell. It repeatedly checks tripwires to be able to observe the lock breaking. If the one near the end collapses, it uses one of five algorithms depending on how much progress the opponent seems to have made:
    • If the opponent appears to be on the flag, it shudders the flag in the hope of a draw.
    • If the opponent appears to have made a lot of progress but not quite reached the flag, it uses a lock on cell 1 and a full-tape clear.
    • If the opponent has disturbed distant cells but not nearby ones (perhaps due to tripwire avoidance), it shudders on the flag, using a shudder algorithm designed to maximise the chance of a draw against two- and three-cycle clears (produced via computer search on all repeating sequences of six +-. commands).
    • If the opponent appears to have made only marginal progress (i.e. the cell to the left of the lock cell is not near zero), the program's main strategy is replicated but moved to the left one cell, giving a second try at getting lucky with the probabilistic lock. If the lock breaks a second time, a shudder is attempted on the flag (because the most likely reason to break two probabilistic locks is that the opponent has broken anti-shudder mechanisms).
    • If the opponent has cleared the cell to the left of the lock cell, but not the cell to its left (this is quite a likely codepath, as the cell to its left was a small decoy, and the cell to its left was much larger), this works mostly the same way as the previous case, except one further cell to the left. However, in this case, there is a serious risk of not being able to set up enough decoys. Thus, the lock is held much longer than is necessary to set the decoys; in fact, it's left until just before the cycle limit. The idea is that if the opponent has set few or small decoys, there will still usually be enough time to take its flag; but if it has set enough decoys that it would clear first, it runs out of time before being able to take preparation's flag.
  • Once this decoy is large enough, preparation continues by building two more large decoys. One tripwire continues to be checked; if the tripwire is broken, the most likely reason is a timer clear, and preparation reacts by abandoning the lock attempt, just setting decoys on all remaining cells, and then racing. A timer clear is used in case the opponent is a lock-based program that uses no synchronization (and probably thinks it has preparation locked on an entirely different cell); it wouldn't do to run right into the lock and make that program's incorrect assumption correct.
  • After this point, checking the tripwires is abandoned in favour of making yet more decoys. There are four more remaining cells, each of which is made into a large decoy. Then all the decoys are adjusted to size 128, mostly for aesthetics.
At this point, the lock is no longer necessary; no matter what, preparation is planning to rush. (It's taken over 30000 cycles to reach this point; doing things in the spare cycles of a probabilistic lock is slow.) However, it first waits in place for 1280 cycles to see if the lock cell touches zero. The reason is that there are two reasons the program could reach this point; either the opponent was clearing and successfully locked, or the opponent was passively defending and never even reached the lock cell. Two different clear algorithms are used based on this:
  • If the lock cell was not zeroed even in 1280 cycles, the opponent is assumed to be a passive defender (within 1280 cycles, any clear algorithm with a denominator less than or equal to 5 will make the cell touch zero at some point, even if the non-integral clear algorithms might fail to actually clear it). The clear algorithm used is a "normal" two-cycle clear (with no offset); however, every 828 cycles (512 times the golden ratio, which guarantees that every possible timing will be tried eventually), it changes the clear direction, or the clear parity (i.e. clearing on even cycles or odd cycles). This is guaranteed to beat even a probabilistic clear eventually. (Note that a reasonably fast clear algorithm is necessary, in case the clear attempt trips a tripwire that causes the opponent to start rushing; the seven max-height decoys might not necessarily be enough.)
  • If the lock cell was zeroed, the opponent is assumed to be a rush program that got caught up in the lock. The resulting rush is a very simple order-12 offset clear with nothing fancy involved at all, because the opponent is assumed to never be touching the portion of the tape beyond where the lock was. (Using a small order increases the chance of outracing even a slightly superior number of decoys.) This is the codepath shown in the animation above, and probably the one responsible for the most wins.

ais523_monolith • Trace and animation • Code: (>+)*4 (>--)*4 ((-)*5<)*4 ((+)*6<)*3 (+)*5 (>)*7 ((-)*20<)*4 ((+)*20<)*3 (+)*20 (>)*7 ((-)*20<)*4 ((+)*20<)*4 (+)*50 (>)*10 (>[(-)*4([+{[.---]}][.-[.-]]>(-)*12)%3000][..++-----[..++-----]])*21

A remarkably simple program compared to the other hill-toppers from this period. The basic idea is to set eight large decoys regardless of what the opponent does, then rush. Multiple layers of reverse decoy setup are used to beat fast rush programs (setting up the first layer of decoys using a forwards decoy setup to provide some measure of defence against pokes). Thus, the clear loop is specialised to beat slow rush programs that set a lot of decoys, via using only a small offset on the offset clear; it assumes that there won't be many small decoys to offset against anyway, and avoids wasting the time spent setting and then clearing the offset. Perhaps surprisingly, these tweaks are enough to be able to bulldoze past the much larger number of decoys that poke-based programs can often set, at least on medium-length tapes (where this program does best).
In order to deal with defensive programs, monolith uses an (inflexible) timer clear that falls into a 3/5 cycle clear (because nowadays, almost any reasonable integral clear loop can be locked by some program or other), and the now-standard comprehensive anti-shudder/anti-vibration countermeasures. (In particular, it is physically incapable of falling off the end of the enemy tape, because it will only ever move forwards after observing two zeroes in a row on its current cell.)

Lymia.nyuroki • Trace and animation

This bot is actually very simple, despite the long final output. It starts at cell 8, and starts setting up decoys in reverse. If it encounters a set cell during this, it jumps straight to its clear loop, bypassing the skip to 14 on smaller tape sizes. Otherwise, it builds up 8 rather large decoys, and then jumps straight to cell 14. The actual clear loop checks the cell twice to deal with stuff like anticipation, and does an offset clear of size 10. This offset clear has a 500 cycle timer, after which it switches to an opposite polarity five-cycle clear. This five-cycle clear is also triggered if the cell is still set after the timer clear exits. After clearing a cell, it leaves behind size 1 trail. This warrior originated no innovations in strategy, but was the first champion assembled by a generalized BF Joust macro system created to simplify construction of such programs. (Although there has been a longstanding tradition of using scripts to generate warriors, all prior champions had been produced by special purpose one-off scripts.)

2015

ais523_growth2 • Trace and animation

(The source is heavily golfed via a generation script; for comments and a readable algorithm, look at the generation script that's embedded in the source.) Starts by building small decoys until it reaches an enemy decoy (small or otherwise, it doesn't really matter; the idea is to not place decoys beyond a place where the opponent has definitely been, because they wouldn't do their job), or cell 17. The decoys change polarity every two steps. Then it goes back through the decoys, making them larger over time, and if the opponent does nothing, repeats until the ones nearer the starting position are around size 128 (those decoys are incremented twice as fast as the ones further from the starting position, because they're more likely to have an effect), and then rushes with an inflexible timer clear with many anti-defence protections (2 cycle before the timer expires, 5 cycles afterwards, and the usual anti-shudder protection). The flag is also adjusted after seven cycles, to avoid losing to careless clears.
If a decoy is observed to be zero while trying to make it bigger, growth2 assumes it was cleared by the opponent (the alternative possibility, that it was an opponent's decoy and the opponent uses a forward decoy setup, normally causes growth2 to lose). It checks the cell two squares back for values near 0; if the cell still appears to be far from 0, it sets a large decoy on that cell and every previous cell. Whether it is or not, it then rushes. In most cases, this uses the same clear loop as if the decoy setup wasn't interrupted by an enemy clear. Notably, this uses an offset (a small offset of 5) only for the first 99 cycles, and then switches to an offset of 0 (on the basis that the opponent can be assumed to have decoys larger than any sensible offset, and if you're not going to be able to out-offset the enemy decoys, 0 is the fastest offset to use). The rush starts nine cells from the enemy clear; this can often locate the enemy flag directly on the assumption that the enemy is using rule of 9 (although if the enemy leaves a trail, the clear only has a 50% chance of being observable (if the parity of the trail and decoy are the same, it can't be observed)).
If the opponent appears to be a fast rush program, the details are a little different. If the opponent is first seen within two cells of the flag, growth2 assumes its flag is under attack, and repairs it before starting the rush. And if the opponent is discovered on the very first cycle of checking the decoys, growth2 assumes it's facing a very fast rush program and uses a reverse offset clear for the first cell it clears (not counting cells near zero; the assumption is that a program that can clear growth2's decoys that quickly wouldn't have time to set large decoys itself).

2016

ais523_margins3 • Trace and animation

One of the weirdest programs ais523 has ever written (and one that's short enough to have been written by hand, if still somewhat long). At a very broad level, the program starts by looking at the tenth cell (the first one that can be the enemy flag). If it's large, it tries to clear it; if it's small but nonzero, it does a fast rush (and abandons the rest of its strategy); if it's zero, it retreats and plays for a draw rather than a win. In other words, the margins series of programs cares about winning short tapes and drawing long ones, to produce a winning record overall. The scoring differences between the two hills thus make a huge difference, with margins3 coming #1 on zemhill, but #28 on egojoust (at the time of writing).
Looking at margins3 in more detail, it starts by setting a few decoys (reverse tripwire on the second cell, medium decoy on the third, then trailing up to the tenth – speed is very important for a fast rush, so only minimal decoys can be set). The codepath that gets most wins against aggressive programs is if the cell happens to be small (no larger than ±3) and nonzero, in which case the cell is left clear (margins3 has forgotten its original value), and it starts a stealth clear on the rest of the tape. This clear restores the values of nonzero cells that it encounters under some (common, but relatively complex to define precisely) circumstances, meaning that an opponent will be mislead as to how far it got (and may incorrectly think that the change to its most distant decoy is a clash in decoy setups). Once it finds a cell it can't restore (most likely a large decoy), it sets two size-60 decoys, at the locations 9 and 10 positions behind its current position (as it's lost track of where it is on the tape by now). Then it returns to the unrestorable cell, and does a sort of modified reverse offset clear; the reverse offset is -83 for the first cell cleared this way, and -50 for subsequent cells, meaning that in the common case in which the opponent sets very large decoys (≥50) by its flag, there's a 50:50 chance (based on polarity matchup) that it "turtle clears" the decoy. There's an inflexible timer (of 900 total cycles clearing) to fall into a 3/5-cycle clear; if the timer is hit against a non-defensive program margins3 has probably lost anyway, so it can afford to take anti-defensive countermeasures at that point.
The strategy for if the tenth cell is large or zero is very defensive (although if the tenth cell is large, margins3 will attempt to clear it before starting to defend in case the tape length happens to be ten exactly). It removes most of its own decoys (to defeat decoy-skipping programs, which would tend to beat it otherwise), leaving a reverse tripwire on the second cell (of size 1), a reverse tripwire on the fourth cell (of size 3), and a size 10 decoy on the third cell, which is used as a lock. Because margins3 is not attempting to win at this point, it can deploy a very strong lock (technically a probabilistic one, but with a very high chance of working): it locks for 122 out of every 128 cycles, using the other six to check tripwires. On almost every occasion, it checks the tripwire nearer its flag (which alternates value between 1 and 2 to make good use of spare cycles that are needed for parity reasons). Assuming it remains undisturbed, this continues until very near the cycle limit, at which point margins3 moves backwards one cell, sets a large decoy, then rushes to the twelfth cell and turtle-clears it. (In the case where the tenth cell was large rather than zero, the eleventh cell is cleared instead if it's non-blank, to avoid issues with running off the end of the tape; it's normally safe to assume that the tape is longer than 11 if the 10th cell is blank, though.) If the tape length isn't 12, this will cause a draw, as there is not enough time left for the opponent to zero the decoy with a 2-cycle clear and the flag with a turtle clear, the fastest sensible strategy.
If the tripwire nearer the flag is disturbed (meaning that the lock was broken), margins3 starts shuddering its flag (hoping for a draw or to trick the opponent off the tape; the opponent has already moved on once from a cell that it's unlikely to have been able to observe at zero two cycles in a row, given that margins3 changes the cell basically every cycle and thus would change it during the first zero test, making it nonzero for the second). It starts with a shudder designed to lock 2-cycle clear algorithms for 1024 cycles, then changes to a shudder designed to lock 3-cycle clear algorithms, in a crude (yet surprisingly helpful) method of defending against timer clears. This codepath tends to beat turtles and full-tape clears, and sometimes manages a draw or even win against more traditional clear loops.
The remaining cases involve the reverse tripwire further from the flag. This is checked once, on cycle 4780, and the strategy described so far holds if its value has changed (indicating, in almost all cases, that the opponent is trying to attack). On the other hand, if that tripwire is unchanged, the opponent may well be passive or defensive. In this case, continuing on with the standard go-for-a-draw strategy may be disastrous, as defence programs that decide to change to the attack after a long period of inactivity are often completely biased towards anti-defense measures and willing to forgo rushing speed to be as nasty to defensive programs as possible. As such, margins3 needs to use yet another different strategy.
The first thing it does in this case is to determine the reason for no change in the tripwire. The possible reasons are that the opponent is a defence program, that the opponent is a program that skips (or restores tripwires on) some cells, that the opponent has a size 3 trail, or that the opponent sets no more than one decoy and the tape length is exactly 12. To test for the first case, defend3 stays still, constantly zero-checking the lock cell but otherwise doing nothing, for 500 cycles. A defensive program won't zero it; other programs will. If it does get zeroed, margins3 immediately sets a very large decoy on the second cell, and zeroes the twelfth cell (if the twelfth cell turns out to be near zero already, it uses its spare time to zero the thirteenth cell instead; this won't hurt and has a chance of stealing wins); this handles the tape length 12 case. Otherwise (in the remaining two cases, which are luckily quite rare), it shudders its flag for the rest of the game, as the only real remaining chance to not lose.
Finally, if the opponent's been established as defensive, it attacks cautiously. (This is the codepath shown in the animation above.) First it places a maximum size decoy on every zeroed cell between its current location and the enemy's decoys, to buy itself time if the opponent starts rushing. Then it uses an inflexible timer clear on a very short timer to clear a total size of 100 enemy small decoys (after an offset of 5); this will quickly skip through small decoys, and yet bail out soon enough on large ones, whilst being impossible to lock (as margins3 always stays in control of its control flow). Once the timer runs out, it clears with a 3-cycle clear that changes position modulo 3 or polarity every 621 adjustments (the idea being that this will eventually guarantee hitting a clear pattern that's maximally unfavourable for an enemy lock). If the current cell is observed at zero (and the game isn't over), it moves backwards a little to adjust the timing immediately without getting stuck in a loop, thus eventually beating shudder and vibration programs too.

2017

The list of major programs from 2017 onwards is not yet known to be complete.

Lymia.nyuroki2

Nyuroki2 is a rush program that uses a lot of strong (but probabilistic) strategies in tandem to beat most reasonable bots, rather than using more theoretically grounded strategies. In practice, Nyuroki acts similarly to margins3 in many situations, winning on most tape lengths by sacrificing tape lengths around 11-14 due to the use of risky strategies.
It starts with a reverse decoy setup, then chooses between one of three rush algorithms based on whether it observed an opponent's decoy "inside" its own, in a similar style to the original nyuroki.
If there is no obvious clash of decoy setups, this program acts as a slow rush program setting four medium decoys and four large decoys, then rushes with a size-20 offset and anti-vibration / anti-shudder protection. It starts clearing some distance after the first possible enemy flag in this case, assuming that it would likely have seen decoys if the tape were shorter. A brief one-time probabilistic lock is done on the flag right around the moment where a 2-cycle fast rush that didn't set any decoys would reach its flag and have cleared it; this forces such programs to clear the flag twice, and gives nyuroki2 a high chance of clearing the opposing flag first.
If an opponent's decoy is observed within the decoy setup, it immediately begins a fast rush and does not set up further decoys (as the opponent has already been observed past where they would have been set up anyways). This uses a smaller offset, of 5 cells; additionally, the counter-vibration and counter-shudder protections are dropped if the opponent's decoys are observed very early (on the theory that a vibration program cannot possibly have zeroed flag within the first 128 cycles, and thus, any cleared cells it encounters can't be a hidden flag).
In the clear loop itself, a few small tricks are used to help defeat defense programs. It uses a rather standard timer clear, but the construction is different from normal. Instead of trying to observe that a cell is clear for two consecutive cycles, it only attempts to observe that the cell is clear for two cycles total. This works because the inner clear is 7 cycles and attempts to execute as many different two-cycle combinations of .+- as possible. There is a high chance (assuming the defense program doesn't have a defense loop of exactly 7 cycles) that eventually, the exact right combination of cell changes will cancel out a probabilistic lock/shudder and kill the flag. By the time the cell is observed to be clear two times, this should (in theory) have won the game already if it were the flag, so nyuroki moves on assuming that it is a decoy.
The script that generated nyuroki2

2018

It is currently unknown whether any programs first topped the hill in 2018.

2019

david_werecat.mist • Code: ++++>(+)*7([{(>)*8(>(-)*9[+-+][+--+](-)*7)*-1}]<(+-++-+++)*-1)%1333

A fairly simple shudder-based program (but with a different shudder loop than the normal one). Before starting the shudder, it adjusts its flag to protect against careless clears, and ensures that the opponent is attacking by waiting on a large tripwire next to the flag (if the opponent does not attack, it will eventually change to an anti-defense rush strategy that leaves a large trail).

westonian.Sookie

A defensive program that primarily works by exploiting its opponents' anti-shudder loops.
It starts by creating a lock on the third cell, alternating between incrementing the cell and testing it for zero. This means that against a typical program, which tests a cell for zero twice before moving on, the most common outcome will be that the opponent increments the cell on the cycle where Sookie zero-tests it (causing Sookie to not see the zeroing), then on the next cycle, the other program zero-tests it as Sookie increments it, then on the cycle after the other program observes it as nonzero (causing it to assume that it is facing a shudder program and fall into an anti-shudder loop, refusing to move on until the cell is cleared for two cycles). Sookie then continues to alternate between incrementing and zero-testing the cell – this means that the only situation in which it would be possible for the other program to observe the cell as zero for two cycles is to zero it as Sookie increments it / let Sookie zero it, observe the cell as zero (as Sookie zero-tests it), and then observe the cell as zero again. However, this means that Sookie necessarily sees the cell as zero before the other program does. (If the program does not have a suitable anti-shudder capable of clearing the cell, then Sookie allows the match to time out rather than trying to lock, because the opponent probably has more decoys and would win the race.)
Sookie then usually continues by allowing the opponent to move on, and trying to lock on the second cell, using a similar algorithm to the previous lock; however, this one is designed to trap the opponent on the cell if possible, in a manner similar to a triplock (and changes polarity the first time the opponent zeroes it in a way that lets Sookie observe the zeroing). There's also an attempt made to discover whether the opponent is trapped on the second or third cell (because anti-shudder clear algorithms don't necessarily realise that they have double-zeroed the cell immediately – they're typically intended for attacking flags, where zeroing the cell for two cycles is more important than realising you have done so); if Sookie wraps the cell all the way round back to 0 with the alternating increments and zero-tests, and the opponent does not appear to be changing it, then the opponent is likely on the third cell; and if it doesn't, the opponent is likely on the second cell and Sookie plays for a draw, trying to hold them there.
If the opponent seems to be stuck on the third cell (i.e. is taking a very long time to clear due to how the anti-shudder loop works), Sookie sets a small decoy on the second cell, repairs the third cell (by attempting to clear it to 0 at a moment in the opponents' clear loop where they will not see it zeroed for two cycles, and then rushes, hoping that the opponent will be stuck on the third and second cells for long enough that it can get to the flag first. (Before rushing, it double-checks to make sure that the second has not been cleared and that the lock on the third cell is holding.) The rush assumes that the tape length is at least 12 (otherwise, the opponent would probably have skipped over the lock on the second cell). It uses an offset clear for the first two cells, and then attempts to special-case by recognising the opponent's decoy setup, but if it does not recognise the opponent, it will guess that they do not have exactly 3 decoys, skipping the third nonzero cell; offset-clear the fourth and fifth cells with an offset of 2; and then do a trivial 2-cycle clear with no offset (which is fastest if the opponents' decoys are assumed to be too large to offset against).
The remaining cases, in which the locks are broken, is rare (the common codepaths are the ones in which Sookie's lock holds forever and it never rushes, and the one in which the opponent is stuck on the third cell and Sookie rushes). As such, they contain special-case code to recognise the opponent, and occasionally even the tape length, by looking at the time it took to clear the cells and/or the pattern of values left on the tape, and lock and clear appropriately. These cases tend to lose when playing against opponents that did not exist at the time Sookie was created.

2020–2023

During this time period, there were no functioning BF Joust hills, so there were no new winning programs because no new programs could be submitted.

2024

ais523.impatience

A slow rush program with turtle elements. This was heavily inspired by ais523.monolith (using a similar decoy setup, and a clear loop that was optimised for the same goals, despite being of a somewhat different general nature).
It starts by setting eight moderately large decoys and one small decoy, using several layers of reverse decoy setup (and one layer of forward decoy setup) in the hope of catching fast rush programs before they reach the flag and of stopping pokes. While setting the fifth to eighth decoys, a check is made for clashing decoy setups – if this is detected, the decoy setup is curtailed, setting one or two medium decoys next to the flag and leaving the other decoys in their current state, thus turning into a faster rush program. In this codepath, the program looks for the first large decoy (specifically: a total value 40 of decoys, after applying an offset of 3), offset-turtle clears it, then enters the program's normal clear loop (except that it doesn't leave a trail and uses a consistent offset of 3).
If there is no clash in decoy setups, the program completes setting up its decoys, adjusts its flag for turtle protection, then starts a clear loop starting with the 11th cell (assuming that on tape length 10, the opponent's decoys would have been noticed earlier). This makes use of a flexible timer clear, with a very short timer (starting at 135 and gradually increasing to 180 as the program gets further to the right), and a small offset (typically 3 near the start, gradually decreasing to 0 as the program gets further to the right, although it returns to 3 if a cell is cleared before the timer expires); the offset is applied unconditionally (rather than checking to see if the cell is 0 first) to ensure that a different timer is used for each cell. When the timer expires, if the cell has not been observed at 0 in that time, the program simply moves onto the next cell, hoping that it wasn't a lock on the opponent's flag (or a flag with a very unusual value). This means that cells that have the polarity that can be cleared quickly are cleared quickly – but if the cell has the other polarity, the clear will be abandoned rather than spending all the time to take the cell back to 0. It also means that large-valued tripwires can be skipped half the time without actually tripping them. Combined with not wasting time with large offsets, this technique means that it is often possible to outrace the opponent's clear even with fewer and smaller decoys (e.g. see this match on tape length 30).
A trail is left with value 1 (the most common value for a reverse tripwire), in the hope that after the timer breaks a lock on a cell other than the opponent's flag, this randomly happens to restore reverse tripwires to their previous value (causing the opponent to not realise their flag is under attack). If a cell is observed having changed from 0 during a clear attempt, the program switches to a 5/3-cycle clear loop in an attempt to break locks, shudder and vibration programs (and will not move on from the cell until it has been verified to be 0 for two cycles).

ais523.ash

A triplock-based defence program, inspired by westonian.Sookie (but with a somewhat different, and hopefully less fragile, strategy) and to some extent also by ais523.margins3.
It starts by setting a height-4 reverse tripwire on the second cell, and a large decoy on the third, then adjusts its flag to protect against careless clears. The reverse tripwire is checked – if it was disturbed (meaning that the opponent is probably on the flag), it repairs the flag and then attempts an offset careless clear on the first cell (after a rule-of-9 decoy skip) that does not have value -1, 0, or 1, hoping to outrace the opponent's clear loop.
The rest of the program's strategy is based on a newly discovered sort of triplock, in which a decoy cell (here the third cell) is alternately incremented and tested; if the cell is ever observed at zero, it is immediately decremented, and then the program does something else for a while before returning to the decoy cell and going back to alternating between incrementing and testing it, and repeating. The basic idea is to perform a probabilistic triplock on the opponent's anti-shudder code: opposing programs will only observe a cell at zero for two cycles if they happen to decrement it on the same cycle that ash is incrementing it, which is a 1 in 4 probability for a simple two-cycle clear (and the probability goes down with other sorts of clear loop). In other cases, the opposing program will be unable to distinguish the triplock from an attempt to shudder the flag, and thus will attempt to observe it clear for two cycles before moving on. There is a reasonable chance that the opposing program will observe the cell clear for one cycle, and then not clear on the next cycle – this will push them into an anti-shudder loop, which is typically a good thing for ash because such loops a) are slow, thus more likely to be probabilistically locked, b) tend not to have timers or other similar anti-defence enhancements, and c) necessarily have to check twice before moving on because beating shudder programs is their whole purpose.
Immediately before entering and immediately after leaving the triplock cell, a test is made to see if the reverse tripwire is holding. If it seems to be broken, the strategy depends on when it broke:
  • at the start of the program this prompts a careless clear (as explained above);
  • if it is observed as broken after the first time the triplock cell zeroes, an attempt is made to lock the opponent on the reverse tripwire cell (aiming for a draw rather than a win), or to shudder the flag if they seem to have moved past it (or if the lock is observed to have broken);
  • in the remaining cases, the strategy is similar to the previous case, but weighted more towards attempting to shudder the flag in unclear cases rather than trying to lock.
Shuddering the flag works particularly well in this context because the triplock is aimed at the opponent's anti-shudder; if they don't have one, it will break, but in these cases the shuddering of the flag is likely to win rather than to draw.
In the normal case (in which the triplock seems to be holding), an inline clear is used in order to clear the tape and eventually the opponent's flag. It adjusts one cell by 100, or leaves it clear it if it is observed at 0 during the adjustments, on each triplock cycle; and the information about how far the clear has reached is stored on the tape, rather than via using control flow, meaning that ash has surprisingly short and simple source code for a winner.
Unlike normal triplocks, this sort of triplock will eventually trip when playing against a passive defender, because 256 increments restore a cell to its original value. ash detects passive defenders using the second triplock cycle, starting the cell at 1 and counting how many increments it takes for the triplock to trip: any number other than 255 (either lesser or greater) implies the opponent has visited the cell, and the normal strategy is usable, but if it trips after exactly 255 increments the opponent is assumed to be a defence program that is waiting for something. In this situation, ash sets 6 large decoys, then cautiously rushes using an offset of 5, a 3-cycle clear, and anti-shudder and anti-vibration loops.

iddi01.β

β is a relatively simple program, with the attack algorithm based on the now deleted another_rush_program and the overall strategy "mildly reminiscent of growth2". Initially, it sets reverse tripwires forwards at cell 1-9. From cell 5 onwards, it checks for enemy decoys. If any are spotted, it immediately goes back 4 cells and sets the appropriate decoys backwards, and rush with a three-level clear strategy: a small wiggle, followed by a large wiggle, then a careless clear. Once it reaches the careless clear point, it will only do the same careless clear for every cell onwards.
If none are spotted, it goes back to cell 5 and checks the reverse tripwires after that one-by-one. If any are tripped, it sets lots of decoys backwards, and goes a long distance forwards, assuming it's safe since the tripwire might not be tripped otherwise, and does the same clear strategy as above but with a larger wiggle.
If none are tripped, it goes back to cell 1 and checks the reverse tripwires one-by-one again, except this time, instead of restoring them, it sets them to 65. If any are tripped, it does not set further decoys and rushes forward the same way as above, except with a slightly smaller wiggle and a trail.
If still none are tripped, it rushes forward with the same way as above, but with an even larger wiggle, a trail (or medium decoys before spotting a nonzero cell), and the careless clear replaced with an anti-shudder reverse offset timer clear with a long timer and an anti-defense clear when the timer expires.

iddi01.clock

Inspired by ais523.ash, but much simpler: It uses a probabilistic lock without alternating polarity on the third cell. Programs with anti-shudder will most likely be trapped forever, while others will be finished off by the shudder anyway. Cell two is a reverse tripwire, checked once per 128 increments 8 times, and then cell three becomes a reverse tripwire. If tripped, it then checks cell two 8 times once per 256 increments, and then stops checking. It uses the last cycles before timeout to rush, similarly to ais523.margins3. If cell three is not tripped, it does an anti-defense rush (reverse offset anti-shudder clear). In any case where cell two is tripped, it begins shuddering on the flag, however before the cell three check it also attempts to clear the tenth and eleventh cell before starting the shudder, repairing the flag in the process.

See also

Retrieved from "https://esolangs.org/w/index.php?title=BF_Joust_champions&oldid=145839"