Boty kodowe

Nienawidzę zmiennych prywatnych i chronionych. Chcę tylko uzyskać dostęp do wszystkiego i wszystkiego!

Jeśli jesteś podobny do mnie, to wyzwanie jest dla Ciebie!

Napisz bota, który współpracuje w harmonii z innymi botami, dzięki czemu inne boty będą robić to, co chcesz. Jesteś programistą i wiesz, jak mają działać. Twoim zadaniem jest konwersja jak największej liczby innych botów na twoje sposoby.

Kod

Będziesz miał 24 linie kodu do napisania swojego bota. W każdej turze każdy bot wykona kolejno 1 linię.

Każdy bot przechowuje 5 zmiennych Aprzez E. Ai Bsą do użytku osobistego, Cprzechowuje następny wiersz do wykonania, Dzapisuje bieżący kierunek i Ejest liczbą losową. Zmienne zaczynają się od 0, z wyjątkiem D, które zaczynają się od losowej wartości. Wszystkie zmienne przechowują tylko 0–23. Liczby większe lub mniejsze będą modulowane przez 24.

W tym poście użyję przeciwnika jako sąsiadującego bota, z którym się zmierzysz

Każda linia musi zawierać jedno z następujących 5 poleceń:

1. Flagnic nie robi. Z wyjątkiem tego, jak wygrywasz
2. Moveprzesuwa twojego bota w Dkierunku th. Jeśli bot już zajmuje to miejsce, nie nastąpi ruch
3. Copy Var1 Var2 kopiuje zawartość Var1 do Var2
4. If Condition Line1 Line2 Jeśli warunek jest spełniony, wykonuje wiersz 1, w przeciwnym razie wiersz 2
5. Block Var1 blokuje następny zapis zmiennej

Zmiennej można użyć w następujący sposób:

#Varużyje zmiennej jako numeru linii. Jeśli Ajest 17, Copy #8 #Askopiuje zawartość linii 8 do linii 17. *Varużyje zmiennej twojego przeciwnika. Copy 5 *Custawi Czmienną przeciwnika na 5 Var+Vardodanie dwóch zmiennych. Copy D+1 Dobróci bota w prawo

Gdy Dzostanie użyty jako kierunek, [North, East, South, West][D%4]zostanie użyty

Te modyfikatory mogą być powiązane: Copy *#*C #9skopiują kolejną linię, którą przeciwnik wykona do twojego własnego kodu w linii 9. **Dodnosi się do Dzmiennej przeciwnika przeciwnika .

Stan zostanie oceniony w następujący sposób:

1. Jeżeli Var:
   1. Jeśli Var jest Aprzez C, zwróci true jeśli Var jest niezerowe, inny fałszywy.
   2. Jeśli Var jest D, zwróci true, jeśli w tym Dkierunku jest bot, w przeciwnym razie false
   3. Jeśli Var jest E, zwróci true, jeśli E jest nieparzyste, w przeciwnym razie false
   4. Jeśli Var jest linią, zwróci true, jeśli jest linią Flag
2. Jeżeli Var1=Var2:
   1. Zwraca true, jeśli oba są A-Ei są równe tej samej liczbie
   2. Zwraca true, jeśli oba są liniami, a typ linii jest równy
3. Jeżeli Var1==Var2:
   1. Zwraca true, jeśli oba są A-Ei są równe tej samej liczbie
   2. Zwraca true, jeśli oba są liniami i są identyczne (flagi z różnych botów nie będą równe)

50 botów każdego typu zostanie umieszczonych w świecie toroidalnym według następującego wzoru:

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

Po każdej grze w 5000 tur, flagi każdego bota zostaną policzone. Dostajesz punkt, jeśli bot ma więcej twojej flagi niż jakikolwiek inny rodzaj flagi. W przypadku remisu między Nbotami punkty nie są przyznawane.

Będzie 10 gier, a wyniki zostaną zgromadzone na końcu.

Notatki dodatkowe

Komentarze na końcu linii są dozwolone i są oznaczone symbolem //

Próba zrobienia czegoś, co nie ma sensu, takiego jak dodanie do linii, nic nie da

Próba zrobienia czegoś na nieistniejącym bocie nic nie da

Nieskończona rekurencja w Iftestamencie zakończy się bez wykonania linii

If nie zmienia wartości C

A Blocknie wygasa, dopóki ktoś nie spróbuje do niego napisać

Wiele zmiennych i linii może być blokowanych jednocześnie

Blockwprowadzenie zmiennej wiele razy będzie blokować wiele razy, dopóki druga instrukcja blokowa będzie w innym wierszu kodu niż pierwsza

Spacje są dozwolone tylko między argumentami (i po poleceniu)

Jeśli bot ma mniej niż 24 linie, flaga będzie resztą linii.

Przykładowy program

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

Program będzie prowadzony przez mojego kontrolera Python tutaj .

Kontroler Java jest tutaj Jest szybki i wygląda znacznie lepiej niż Python.

Tablica wyników:

1. 6837 $ Kopiuj
2. 3355 Lockheed
3. 1695 MindControl
4. 967 bizantyjskie
5. 959 AttackOrElse
6. 743 Cadmyllion
7. 367 Grypa
8. 251 TheCommonCold
9. 226 Mag
10. 137 HideBlockAttack
11. 129 RowBot
12. 123 FastMoveCloneDodge
13. 112 FastForwardClone
14. 96 QuickFreeze
15. 71 RepairAndProtect
16. 96 SuperFreeze
17. 93 RovingVirus
18. 80 ForwardClone
19. 77 FreezeTag
20. 68 Palimpseste
21. 62 BlockFreezeAttack
22. 51 RushAttackDodge
23. 46 Blocker
24. 40 TurretMaker
25. 37 Copycat
26. 37 Kamikaze
27. 35 FlagInjector
28. 33 RandomCopier
29. 31 Podstępny
30. 29 HappyAsAClam
31. 25 NanoVirus
32. 21 Nullifier
33. 19 Nanoviris
34. 17 BoringCopybot
35. 16 Movebot
36. 14 Flagbot
37. 13 Neutralizator
38. 12 Rak
39. 9 DNAbot
40. 9 Pasożyt
41. 8 MetaIndidious
42. 8 Zmiana marki
43. 8 AdaptiveBot
44. 8 ReproducingBot
45. 8 KungFuBot
46. 5 QuickFreezerbot
47. 4 Atakujący

Flagbot

Flag

Po co zawracać sobie głowę robieniem czegokolwiek, skoro inne boty będą na tyle miłe, by dać mi swój kod?

Freeze Tag

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

Uwięź przeciwnika w pętlę, wypełnij go flagami, przejdź do następnego przeciwnika.

Pasożyt

Po co zabijać innych botów? Ten bot przegląda kod przeciwnika i zastępuje tylko flagi.

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

$ Kopiuj

Ten bot używa wielu takich samych technik jak Lockheed COTO, więc bezwstydnie pożyczę i poprawię.

Wykorzystuje to Clukę w łamaniu bloków, a nawet odwraca neutralizator. Z tego powodu jest również napisane w absolutach. Myślę, że może się to Czmienić, jeśli zmiana zostanie przywrócona, ale dopóki zmiana jest stała, można ją przepisać, aby z nią walczyć.

Z jakiegokolwiek powodu brak pętli na końcu sprawił, że ten bot był bardzo dobry.

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

Lockheed

Moje trzecie (i prawdopodobnie ostateczne) poddanie się tej konkretnej wojnie z botami: reaktor Lockheed lub w skrócie „Lockheed”.

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

Specjalne podziękowania należą się @Wasmoo, który podzielił się swoim odkryciem: „Wielokrotne blokowanie zmiennej będzie blokować wiele razy, dopóki druga instrukcja blokowa będzie w innym wierszu kodu niż pierwsza”. po prostu nieprawda ”. Korzystam z tego w szerokim zakresie.

Podziękowania należą się również Nathanowi Merillowi za zarządzanie konkurencją i opublikowanie symulatora. Symulator jest całkowicie nieoceniony w tuningu botów. Nie uwierzyłbym, gdybym nie symulował tego na własne oczy, ale dodanie lub usunięcie najbardziej koncepcyjnie mniejszej funkcji bota może oznaczać różnicę między wielkim sukcesem a całkowitą porażką. Jestem rozdarty, czy to dobrze, czy nie.

Atak lub jeszcze raz

Widząc, że roboty defensywne, takie jak Bizancjum, mają się tak dobrze, postanowiłem również stworzyć robota obronnego.

Ma dwa zestawy wzorów, w zależności od tego, czy wróg jest obecny, czy nie.

• Jeśli wróg nie jest obecny, blokuje linie na 3 tury, a następnie się porusza.
• Jeśli wróg jest obecny, na przemian kopiuje swoją flagę i kopiuje kod, który spowoduje, że wróg skopiuje tę flagę (słaby replikator) , skopiuje swoją flagę
• Na końcu pętli zmienia się w losowym kierunku i kontynuuje
• Większość aspektów jego kodu jest powielona

Więcej testów wykazało kilka ważnych koncepcji:

• „Turn random” działał znacznie lepiej niż „Turn right” (+2700 w stosunku do alternatywy)
• Zablokuj przyrost A+7pokazany jako bardziej efektywny niż jakikolwiek inny przyrost (+200 w stosunku do następnego najlepszego)
• „Bezpośredni atak” okazał się lepszy niż „Słaby replikator” (+900 w stosunku do alternatywy)
• Obrona „3-1-2-1” lepiej niż w przypadku innych kombinacji (+200 w stosunku do następnego najlepszego)
• Zduplikowany kod ataku, bloku i pętli poprawia wynik (+300 w stosunku do niepowielonego)
• Zwiększenie bloku zduplikowanego nie poprawia jego wyniku (+400 ponad duplikat)

Bardzo pomocne było graficzne obserwowanie symulacji za pomocą interfejsu Java. Dziękuję Ci! Poniżej znajduje się nowy i ulepszony kod. Nie sądzę, żebym mógł zrobić nic więcej.

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

Row Bot

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

Porusza się, dopóki nie znajdzie robota.
Ustawi robota w tym samym kierunku co on sam.
Następnie skopiuje swój kod do robota.
To powinno zrobić rząd robotów „Row Bot”. :)

Super Freeze

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

Ten bot próbuje zamrozić robota przed sobą, dopóki nie zadziała, a następnie zapisuje kilka flag do losowych linii, a po 8 obrotach obraca się i przechodzi do innego przeciwnika.

Bizantyjski

Wysoce defensywny bot, który tworzy wiele bloków na swoich flagach i najbardziej wrażliwe instrukcje, w tym meta-bloki (tj. Bloki na krytycznych instrukcjach bloków).

Porusza się również stale w nieprzewidywalny sposób i umieszcza flagi w wielu miejscach na przeciwnikach na zasadzie najlepszych starań.

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

Nie jestem pewien, jak to będzie działać, ponieważ nie mogę symulować. Ale spróbujemy. ;)

Zrzeczenie się

Napisałem to przed uprzejmym poinformowaniem przez PhiNotPi, że logika warunkowa jest bezpłatna. Jednak zdecydowałem się to zostawić, ponieważ nigdy nie można mieć zbyt wielu botów.

Cadmyllion

„Właśnie wszedłem do bota w Battle Royale” - mówię. „Porusza się co kilka tur, aby zapobiec atakom wolniejszych botów”.

„Co rozumiesz przez wolniejsze boty?” Pyta PhiNotPi.

„Boty, które utknęły, oceniając długie łańcuchy logiki warunkowej” - odpowiadam.

„Instrukcje„ Jeśli ”przekierowujące do innych instrukcji --- w tym inne instrukcje„ jeśli ”--- są wykonywane w tej samej turze”, mówi PhiNotPi.

„Słodka zmasowana zasada kodeksu asemblacyjnego!” Płaczę. „Kto wpadł na ten pomysł?”

... i tak oto historia powstania Cadmyllionu.

Cadmyllion: bot, który z radością wykorzystuje surrealistyczną zdolność do oceny nieskończenie wielu wyrażeń warunkowych w pojedynczej instrukcji ... poprzez uzależnienie praktycznie wszystkiego, co robi.

Kod

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

Meta Podstępna

Ten bot zawiesza się, a następnie przekształca przeciwników w mniej wydajne wersje Podstępnego Sparra , co z kolei zamieni przeciwników w boty, które spamują dla mnie flagi. Jest to prawdopodobnie najbardziej złożony bot, który napisałem, i dlatego spodziewam się, że będzie on działał okropnie, nie było miejsca na blokowanie i tylko jedna flaga została dopasowana w kodzie. Przekształcenie bota w podstępny klon również zajmuje zbyt dużo czasu.

Największym wyzwaniem było napisanie kodu dla podstępnych klonów w taki sposób, aby działał niezależnie od jego pozycji w bocie. Zamrożenie zostaje usunięte, gdy wklejam od drugiego do ostatniego kodu dokładnie w miejscu, w którym znajduje się zamrożenie, to uruchamia przeciwnika w samą porę.

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

Napraw i chroń

Ten bot naprawia własny kod, jednocześnie chroniąc nowo naprawione linie.

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

Wyjaśnienie:

Wartość początkowa Ato 0, a linie są ponumerowane 0–23. Jeśli Ifinstrukcja jest wykonana i jest fałszywa, próbuje ponownie wykonać tę samą linię. Kontroler nie zezwala botowi na dwukrotne wykonanie tej samej linii, więc tura jest zakończona i Czwiększa się 1.

Następny wiersz Copy #A #A+8jest faktycznie wykonywany niezależnie od wartości Ifinstrukcji. Różnica polega na tym, że jest on wykonywany dwukrotnie, jeśli jest prawdziwy, i raz, jeśli jest fałszywy. Jeśli linia #A+8jest zablokowana (co się ostatecznie zdarza), wówczas wykonanie jej dwukrotnie z faktycznym kopiowaniem, a wykonanie tego tylko raz spowoduje jej odblokowanie. Następnie nowo skopiowana linia jest blokowana, aby ją zachować.

Neutralizator

Ten bot zmusza ofiarę do przepisania całego programu, dzięki czemu jest wart 0 punktów. Gdy wirus jest na swoim miejscu, przechodzi dalej. To jest wypalona ziemia podejście do zwycięstwa.

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

Porównanie *#*C==#7nie wydaje się odpowiednio dostosowywać do przesunięcia przeciwnika, ale bot ostatecznie się porusza.

Podstępny

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

Zainspirowany @Cruncherem, ten bot infekuje inne boty małym blokiem kodu, wypełniając drugiego bota flagami tego bota. Te boty następnie siedzą kaczki do dalszego ataku, ale będą w większości pełne moich flag, kiedy zostaną ponownie zainfekowane przez kogoś innego.

Edycja: dzięki @PhiNotPi za pomoc w golfie, @overactor za porady dotyczące wydajności

Szczęśliwy jak małż

To ćwiczenie z blokowania. Działał wyjątkowo dobrze, dopóki się nie $Copypojawił.

Małż ma 22 polecenia blokowania. Ponieważ Ajest przesuwana w każdej pętli, będą one odnosić się do różnych linii za każdym razem w pętli. Pozwala to każdemu poleceniu układać bloki w każdej innej linii, maksymalnie 22 bloki na linię. Tak więc, aby przełamać w pełni opancerzony małż, trzeba by pisać do linii 22 razy.

Na przykład #10będzie chroniony za każdym razem przez pętlę następującymi liniami:

• Pętla 0, A = 0 #10chronione linią 7 ( 7+0+3= 10)
• Pętla 1, A = 7 #10chroniona linią 0 ( 0+7+3= 10)
• Pętla 2, A = 14 #10chroniona linią 17 ( 17+14+3= 34 = 10)
• Pętla 3, A = 21 #10chroniona linią 10 ( 10+21+3= 34 = 10)

Więc po 10 linii Loop 3 #10został zablokowany 4 razy, wymagając 4 zapisów, #10aby przełamać bloki, a piątego, aby faktycznie nadpisać linię.

Zauważ, że bloki są kluczowane według ich Cwartości i nie będą się układać, jeśli chroniona linia została już zablokowana przez tę samą Cwartość. Więc po ustanowieniu 22 bloków dla każdej linii, bloki nie będą się już kumulować.

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

Kontrola umysłu

Chyba nigdy nie jest za późno?

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

MindControl wywodzi się z mojego pomysłu, że skopiowanie całego programu do przeciwnika zajęłoby sporo czasu, podczas którego mój bot jest podatny na ataki z innych kierunków. Dlaczego więc nie zmusić przeciwnika do skopiowania mojego programu podczas skanowania w poszukiwaniu wrogów?

Gdy znajdzie wroga, MindControl natychmiast zamraża go, aby zapobiec ucieczce. Następnie przesyła downloader do przeciwnika i pozwala ofierze pobrać sam program MindControl. Program pobierający wykorzystuje fakt, że niewiele botów używa Bi zapętla się, dopóki nie pobierze wszystkich 24 linii. Gdy program pobierający przepisuje #19od Copy 16 Cdo Copy 23 C, oznacza to, że ofiara pobrała wszystkie linie i uruchomi się ponownie.

Pierwsze wersje mojego bota nie zawierają bloków. I był tak wrażliwy, że prawie każda zmiana jest paraliżująca. Postanowiłem więc dodać bloki w oparciu o kopię $ Wasmoo (opartą na Lockheed COTO). Minusem, który znalazłem, jest to, że oryginałowi trudno jest poprawić błędy w kopiach. Ale to jest dalekie od kalectwa, a wynik znacznie wzrósł, więc zachowałem bloki.

AKTUALIZACJE

Ulepszyłem program do pobierania, aby kontynuować pobieranie, aż do pomyślnego przepisania w celu obejścia bloków. Oznacza to, że przesłanie downloadera zajmuje jeszcze jedną turę, ale mój wynik podwoił się po tej zmianie !! Nie mogę się kłócić z liczbami.

Kolejna aktualizacja. Jak zapewne zauważyłeś, MindControl decyduje, czy zaatakować cel, porównując losową linię między sobą a celem. Jeśli się zgadzają, MindControl po prostu zakłada, że ​​cel jest już zainfekowany i zostaw go w spokoju. (Uwaga dodatkowa: Kiedyś używałem linii statycznej do porównania, ale daje to dużo fałszywych wyników pozytywnych i negatywnych). Okazuje się, że daje wiele fałszywych negatywów. Więc postanowiłem wykorzystać ==i wprowadzić pewne zmiany, jak trywialne C+23do 23+C. Program jest funkcjonalnie identyczny, ale różni się w oczach ==. Teraz, gdy MindControl nie ma linii identycznej z żadną linią w żadnym innym bocie, w 100% uderzy w nietkniętego bota. Ponownie wynik znacznie wzrósł.

Ponownie poprawiłem Downloader. Teraz działa w krótszej pętli. (który wydaje się mieć dużą korelację z moim wynikiem)

Jeszcze raz ulepszony Downloader. Używa oryginalnego kodu bota, dzięki czemu ładuje się szybciej. Dodano również 2 losowe bloki, które wydają się poprawiać wynik

Napastnik

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

Movebot

Move
Copy 23 C
Flag

Podobnie jak Flagbot, ale poruszaj się, przyjmując prezenty z kodem, aby pasowały do ​​wszystkich naszych flag.

Odtworzenie bota

Ten bot próbuje zamrozić przeciwnika, a następnie skopiować cały kod do tego bota przed ponownym uruchomieniem drugiego bota. Powinno to również działać (głównie), jeśli przeciwnik korzysta z blokowania, ale to sprawia, że ​​wszystko jest jeszcze wolniejsze niż jest już.

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

Mag

Mag jest prostą próbą rozprzestrzeniania się wirusa. Próbuje skopiować się do programów innych botów. (Edytowane w celu usunięcia liczb ujemnych, ustalenia stanu, przycięcia linii).

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

DNAbot

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

Ten bot naprawia własny kod podczas ruchu i ataku.

Blocker

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

Copycat

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

Szybki zamrażalnik

Próbuje skopiować flagi w linii, która zostanie wykonana obok jego przeciwnika, porusza się, jeśli nie ma wroga do ataku.

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

Blokowanie, zamrażanie, atak

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

Blokuje wszystkie 24 linie, następnie zapętla 24 razy, poruszając się lub atakując, a następnie powtarza. Atak obejmuje próbę zamrożenia przeciwnika, następnie skopiowanie czterech flag do losowych lokalizacji, a następnie obrócenie.

Ukryj, Zablokuj, Atakuj

Ten bot jest oparty na Block Freeze Attack. Zmieniłem rozmieszczenie niektórych Ifinstrukcji, aby były bardziej kompaktowe, co pozwala mi na umieszczenie większej liczby flag. Mam też ucieczkę na początku gry, żeby zyskać trochę czasu na zablokowanie.

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

Wędrujący wirus

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

Ten bot błąka się, dopóki nie znajdzie wroga, a następnie zamraża go, zamienia cały swój kod na własny, odblokowuje go, a następnie wędruje ponownie.

Przeziębienie

Zaraża cię praktycznie natychmiast i rozprzestrzeniasz go. w oparciu o pasożyty PhiNotPi , zwykłe przeziębienie sprawdza niemal natychmiast, czy może skopiować swoją flagę na twoim. Blokuje losową wartość, jeśli nie może. Porusza się trochę, jeśli nie ma przeciwnika.

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

Grypa

Jest to ściśle oparte na zwykłym przeziębieniu (które było oparte na moim pasożycie) z nieznacznie zwiększoną prędkością.

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

Rebranding

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

Ten bot próbuje losowo zlokalizować flagi w botach wroga i zastąpić je przyjaznymi flagami, odwracając się po wykryciu sukcesu. Zainspirowany botem Cancer.