Witamy w Code Bots 2!

Nauczyłeś się tej lekcji od ostatnich botów Code. Próbowałeś wymyślić więcej sposobów dopasowania większej liczby akcji w mniejszej liczbie linii, a teraz w końcu to masz. Stworzysz Code Bot sterowanego zdarzeniami.

Twój bot musi składać się z 24 linii. Każda linia ma jeden z dwóch formatów:

Condition:Action

lub

Action

Twój bot posiada również wystarczającą pamięć do przechowywania liczb całkowitych 5 nazwanych Aprzez E. Liczba całkowita może przechowywać wartości od 0 do 23.

W każdej turze wykonasz linię C, chyba że jeden z warunków jest spełniony. Jeśli tak, wówczas Cbędzie zawierał numer wiersza warunku, który jest prawdziwy, a następnie wiersz zostanie wykonany. Pod koniec każdej tury Cbędą zwiększane.

Dostępne są warunki:

1. Startdotyczy tylko pierwszej tury. Musisz to mieć w swoim kodzie dokładnie raz
2. BotAt(N) jest prawdą, jeśli w miejscu zdefiniowanym przez N znajduje się bot
3. Equals(A,B) jest prawdziwe, jeśli A jest równe B. Mogą być różnych typów, jeśli tak, to nie będą równe.
4. Modified(A)jest prawdziwe, jeśli Azostało skopiowane podczas ostatniej tury. Amusi być nazwą zmiennej, linią lub warunkiem
5. Any(C1,C2,...) jest prawdziwe, jeśli spełniony jest dowolny z warunków
6. None(C1,C2,...) jest prawdziwe, jeśli żaden z warunków nie jest spełniony
7. All(C1,C2,...) jest prawdziwe, jeśli wszystkie warunki są spełnione
8. Not(C)jest prawdziwe, jeśli C jest fałszywe. Cmusi być warunkiem.

Zmienne mogą mieć jeden z następujących formatów. Pierwszych 9 jest numerycznych i można z nich korzystać za każdym razem, gdy na tej stronie użyto N.

1. A, B, C, D,E
2. Liczba od 0 do 23
3. This zwróci numer linii, na której się aktualnie znajduje
4. Add(N1,N2,...) zwróci sumę wszystkich wartości
5. Sub(N1,N2) zwróci N1 minus N2
6. Mult(N1,N2,...) zwróci iloczyn wszystkich wartości
7. Div(N1,N2) zwróci N1 podzielone przez N2
8. Mod(N1,N2) zwróci N1 mod N2
9. OVar(N) zaakceptuje nazwę zmiennej i zwróci zmienną przeciwnika
10. Line(N) zwróci N-tą linię w twoim kodzie
11. Type(N) zwróci N-ty typ linii w twoim kodzie (typy to nazwy akcji)
12. Cond(N) zwróci warunek w N-tej linii
13. CondType(N) zwróci typ warunku w N-tej linii (typy to nazwy warunków)
14. OLine(N) zwróci N-tą linię w kodzie przeciwnika
15. OType(N) zwróci N-ty typ linii w kodzie przeciwnika
16. OCond(N) zwróci warunek w N-tej linii
17. OCondType(N) zwróci typ warunku w N-tej linii

Ai Bsą do użytku osobistego, Csłużą do określania, która linia ma zostać wykonana w kodzie i Dsłuży jako kierunek. Każda wartość Dodnosi się do innej pary kwadratów i kierunków. Eza każdym razem tworzy losową wartość. Di Ezostanie zainicjowany na losową wartość, w przeciwnym razie 0.

Zastosowany kierunek będzie [North,East,South,West][D%4]. Twój przeciwnik jest botem na bezpośrednim polu w tym kierunku.

Dostępne są 4 akcje:

1. Moveprzesunie cię o 1 pole do przodu w tym Dkierunku. Jeśli jest tam bot, nie będziesz się ruszać.
2. Copy(A,B)skopiuje zmienną Ado B. Bnie może być wartością liczbową, z wyjątkiem nazwy zmiennej. Ai Bnie mogą być różnych typów. Kopiowanie linii nie kopiuje warunku.
3. Flagnic nie robi. Bot z największą liczbą flag w twoim kodzie dostanie punkt. Bot z największą liczbą punktów wygrywa.
4. If(C,L1,L2)wykona wiersz, L1jeśli Cjest prawdą, w przeciwnym razie wykona L2. Cjest warunkiem L1i L2musi być liniami.

Wielkie zdjęcie

50 kopii każdego bota zostanie umieszczonych na świecie. Twoim celem jest doprowadzenie flagi do jak największej liczby botów. Za każdego bota, który ma więcej typów flag niż jakikolwiek inny typ flagi, otrzymasz punkt.

Boty zostaną umieszczone w następujący sposób:

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

Rozegranych zostanie 10 gier, a punkty zostaną uśrednione we wszystkich grach, określając, kto jest zwycięzcą.

Notatki dodatkowe

Jeśli ma zastosowanie wiele warunków, Startzostanie wykonany ten, który nastąpi bezpośrednio

Boty będą ściśle zapakowane, ale nie zaczniesz sąsiadować z innym botem. (Technicznie będzie to ten sam format, co ostatnie CodeBots)

Ponieważ to wyzwanie nie zostało opublikowane w piaskownicy (aby dać nikomu przewagę), zastrzegam sobie prawo do zmiany drobnych szczegółów w celu zapewnienia uczciwości lub dodatkowych możliwości. Ponadto, jeśli w programie Run CodeBots występuje błąd, zmienię go, nawet jeśli bot odniósł sukces. Staram się być jak najbardziej sprawiedliwy .

IfInstrukcje rekurencyjne nie będą wykonywane

Jeśli twój bot ma mniej niż 24 linie, pozostałe linie zostaną wypełnione Flag

Pamiętaj, gdy kopiujesz do własnego C, który Cjest zwiększany pod koniec twojej tury.

Interpretator CodeBots można znaleźć tutaj . Zawiera plik .jar dla łatwego wykonania. Po prostu dodaj swojego bota do folderu botów

Wyniki

1. 893,9 Borg
2. 1.3 Leniwy
3. 0,9 obrońca
4. 0,5 Flagger
5. 0.4 CliqueBot
6. 0.4 Podstępny
7. 0.3 Atakujący
8. 0,3 Gard
9. 0.3 SingleTarget
10. 0.2 FreezeBot
11. 0.2 Sentinel
12. 0.2 Driveby
13. 0.0 Przeciwnie do podejrzeń
14. 0.0 MoveBot
15. 0,0 CliqueBorg
16. Kalkulator 0,0
17. 0.0 TestBot
18. 0.0 Imitator

AKTUALIZACJA

Linie kodu są teraz obracane podczas przeglądania kodu przeciwnika. Oznacza to, że linia 1 przeciwnika może być linią 14 (lub dowolną linią). Bot będzie miał stałe przesunięcie, które spowoduje przesunięcie jego linii o Xkwotę, gdy ogląda go przeciwnik . CZmienna przeciwnika również zostanie zrównoważona o tę samą Xkwotę. Xnie zmieni się w tej samej grze, ale zmieni się z gry do gry.

Borg

Przekształca wszystkie inne boty w klony samego siebie. Opór jest bezcelowy.

Start:Copy(2,A)                               # Cloning will begin at line 2
All(Not(BotAt(D)),Not(Equals(2,A))):Copy(2,A) # Reset A if the opp left before we were done
Not(BotAt(D)):Move
All(Equals(Line(Sub(This,3)),OLine(0)),Equals(Line(Sub(This,2)),OLine(1)),Equals(Line(Sub(This,1)),OLine(2)),Equals(Line(This),OLine(3)),Equals(Line(Add(This,1)),OLine(4)),Equals(Line(Add(This,2)),OLine(5)),Equals(Line(Add(This,3)),OLine(6)),Equals(Line(Add(This,4)),OLine(7)),Equals(Line(Add(This,5)),OLine(8))):Copy(E,D) #  Check if cloning is complete
All(Equals(A,2),Not(Equals(OCond(1),Cond(Add(This,4))))):Copy(Cond(Add(This,4)),OCond(1)) # Copy freeze cond to OLine(1) before cloning starts
All(Equals(A,2),Not(Equals(OLine(1),Line(Add(This,3))))):Copy(Line(Add(This,3)),OLine(1)) # Copy freeze line
Not(Equals(Cond(Add(Sub(This,6),A)),OCond(A))):Copy(Cond(Add(Sub(This,6),A)),OCond(A))    # Copy Cond(A) to OCond(A)
Not(Equals(Line(Add(Sub(This,7),A)),OLine(A))):Copy(Line(Add(Sub(This,7),A)),OLine(A))    # Copy Line(A) to OLine(A)
Equals(A,A):Copy(Add(A,1),A) # Increment A. It will wrap around all 24 lines before the completion check matches

Edycja: Mała poprawka, aby zresetować A, jeśli przeciwnik poruszy się, zanim skończę z nim. Wydaje się, że nie wpływa to na wynik, ale sprawia, że ​​czuję się lepiej.

Edycja nr 2: Dodano bardziej kompletną kontrolę, aby upewnić się, że proces klonowania został poprawnie zakończony (linia 3)

Edycja # 3: Zaktualizuj, aby obsługiwał nowe losowe przesunięcia. Trudność polegała na tym, że nowe klony miałyby swój kod umiejscowiony w przypadkowych przesunięciach, co oznacza, że ​​nie znają lokalizacji własnych linii. Oznacza to, że wszystkie odniesienia do moich własnych linii muszą być względne (do This). Numery linii przeciwnika nadal mogą być bezwzględne, ponieważ i tak są losowe.

Flagger

Strzelaj do księżyca

Start:Flag

A reszta zostaje automatycznie wypełniona flagą.

Kalkulator

Ten bot nie rozumie celu tego wyzwania, więc postanowił obliczyć pewne liczby dla wroga.

Equals(Mod(OVar(E),5),0):Copy(Add(OVar(A),OVar(B)),OVar(D))
Equals(Mod(OVar(E),5),1):Copy(Sub(OVar(A),OVar(B)),OVar(D))
Equals(Mod(OVar(E),5),2):Copy(Mult(OVar(A),OVar(B)),OVar(D))
Equals(Mod(OVar(E),5),3):Copy(Div(OVar(A),OVar(B)),OVar(D))
Equals(Mod(OVar(E),5),4):Copy(Mod(OVar(A),OVar(B)),OVar(D))
Start:Move

CliqueBot

Flag
Start: Copy(11,B)
Not(Equals(Line(20),Line(21))): If(Equals(Line(21),Line(22)),Line(7),Line(8))
Not(Equals(Line(21),Line(22))): If(Equals(Line(20),Line(21)),Line(9),Line(10))
All(BotAt(D),Not(Equals(11,OVar(B)))): If(Equals(Line(20),OLine(OVar(C))),Line(10),Line(11))
Any(BotAt(D),Equals(E,B)): Copy(Add(D,1),D)
Equals(1,1): Move
Copy(Line(21),Line(20))
Copy(Line(20),Line(21))
Copy(Line(21),Line(22))
If(Equals(Line(20),OLine(Sub(OVar(C),1))),Line(5),Line(12))
Copy(Line(20),OLine(OVar(C)))
Copy(Line(20),OLine(E))

Rozpoznaje znajomych po ich Bwartości, wypełnia linie wszystkich innych flagami. Dąży również do zachowania integralności jednej z własnych flag (ta część jest urocza, ale prawdopodobnie niezbyt przydatna).

Edycja: Nic dziwnego, że wydaje się, że gdzieś tutaj jest błąd, sądząc po wyniku.

Podejrzewam, że linie są indeksowane 0, a mój kod ma indeks 1. Naprawdę powinienem to sprawdzić wcześniej. Dodano flagę na początku, aby podnieść wszystko jeden.

Obrońca

Start:Copy(0,A)
Copy(0,B)
Flag
Flag
All(Modified(Line(2)),Equals(A,0)):Copy(1,A)
Copy(Line(3),Line(2))
Copy(0,A)
Copy(10,C)
All(Modified(Line(3)),Equals(B,0)):Copy(1,B)
Copy(Line(2),Line(3))
Copy(0,B)
BotAt(D):Copy(Line(2),OLine(E))

MoveBot

Start:Move
Copy(E,D)
Copy(-1,C)

Napastnik

Start:Move
BotAt(D):Copy(Line(Add(Mod(E,6),4)),OLine(E))
Any(BotAt(0),BotAt(1),BotAt(2),BotAt(3)):Move
None(BotAt(0),BotAt(1),BotAt(2),BotAt(3)):Copy(E,D)

Pojedynczy cel

Start:Move
All(BotAt(D),Not(Equals(OVar(D),D))): Copy(D,OVar(D))
BotAt(D):Copy(Line(E),OLine(E))
Equals(A,A):Move

Poluje na ciebie i wypełnia cię flagami!

Podstępny

Start:Flag           # comments -->                                                                                 # why move when we can fit another flag here?
Equals(E,0):Copy(Add(D,Sub(Mult(2,Mod(E,2)),1)),D)                                                                  # 1/24 chance to turn left or right
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),1)),Cond(Add(This,4))))):Copy(Cond(Add(This,4)),OCond(Sub(OVar(C),1)))    # Copy the freeze condition
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),1)),Line(Add(This,4))))):Copy(Line(Add(This,4)),OLine(Sub(OVar(C),1)))    # Copy the flag-copying line
All(BotAt(D),Not(Equals(OLine(Add(OVar(C),0)),Line(Add(This,Add(4,Mod(E,14))))))):Copy(Line(Add(This,Add(4,Mod(E,14)))),OLine(Add(OVar(C),0))) # copy one of my flags to them
BotAt(D):Copy(Add(D,Sub(Mult(2,Mod(E,2)),1)),D)                                                                     # turn left or right if we've infected our target
Equals(A,A):Move                                                                                                    # move if all else fails, also infection freeze condition
Copy(Line(Add(This,1)),Line(Add(This,Mod(E,22))))                                                                   # infection line 1
Flag                                                                                                                # first of many flags

Podobny pomysł do bota o tej samej nazwie w poprzednim konkursie. Poruszaj się, dopóki nie uderzę innego bota, a następnie zamroź go w pętlę, nadpisując własny kod moimi flagami. Tym razem zainfekowane boty nadpisują losowe linie zamiast linii sekwencyjnych, dzięki czemu proces infekcji jest nieco mniej skuteczny, ale znacznie szybszy.

Gard

Start: Move
BotAt(D):IF(Equals(Line(7),OLine(C)),Line(6),Line(5))
BotAt(Add(D,1)):Copy(Add(D,1),D)
BotAt(Add(D,2)):Copy(Add(D,2),D)
BotAt(Add(D,3)):Copy(Add(D,3),D)
Copy(Line(7),OLine(OVar(C)))
Copy(Cond(7),OCond(Sub(OVar(C),1)))

Atakuje dowolnego robota obok niego.

Freeze Bot

Start:Move
All(BotAt(D),Not(Equals(OCond(1),Cond(5)))):Copy(Cond(5),OCond(1))
All(BotAt(D),Not(Equals(OLine(1),Line(6)))):Copy(Line(6),OLine(1))
All(BotAt(D),Equals(Mod(OVar(A),24),0)):Copy(Add(D,1),D)
BotAt(D):Copy(Line(20),OLine(OVar(A)))
Equals(A,A):Move
Copy(Add(A,1),A)

Uwięzia cię w pętli Obciążanie własną Azmienną, a następnie wypełnia cię flagami i przechodzi do następnej ofiary.

Imitator

Start:Move
BotAt(D):If(OCond(0),OLine(0),Line(2))
If(OCond(1),OLine(1),Line(3))
If(OCond(2),OLine(2),Line(4))
If(OCond(3),OLine(3),Line(5))
If(OCond(4),OLine(4),Line(6))
If(OCond(5),OLine(5),OLine(OVar(C)))
Not(BotAt(D)):If(BotAt(Add(D,1)),Line(8),Line(0))
Copy(Add(D,1),D)

Przewiduje, co byś zrobił, a następnie robi to.

Leniwa lwica

Pierwotnie po prostu „Lwica”, moje pierwsze zgłoszenie do konkursu zyskało tytuł „leniwy”, dosłownie nic nie robiąc po wprowadzeniu do symulatora.

Jej letarg jest w rzeczywistości spowodowany błędem (lub być może moim niezrozumieniem modelu zdarzenia), w którym warunki w pierwszych trzech wierszach (zwykłe sprawdzenie parzystości w celu upewnienia się, że flagi nie zostaną zastąpione) czasami, w niewytłumaczalny sposób oceniają true, blokując Leo w pętli lemniscate . Kilka innych warunków (szczególnie tych, które opierają się na tym BotAt()stanie) również ocenia się truew czasie, gdy nie ma sąsiadujących botów. Wreszcie, Movei Copydyrektywy są wyraźnie ignorowane przy przechodzeniu symulatora. Ponieważ moje łańcuchy logiki warunkowej są dość epickie, w moim kodzie i symulatorze jest dużo miejsca na błędy . ;)

W każdym razie przesyłam Lazy Lioness jako przypadek testowy do diagnozy błędów lub debugowania symulatora, co, miejmy nadzieję, doprowadzi do pojawienia się niezbyt leniwej lwicy, którą będę mógł symulować i udoskonalać jako moje pierwsze bona fide poddanie się botom zawody v2.

Nic nie robi

All(Not(Equals(Line(18),Line(21))),Equals(Line(21),Line(22))):Copy(Line(21),Line(18))
All(Not(Equals(Line(21),Line(22))),Equals(Line(22),Line(18))):Copy(Line(22),Line(21))
All(Not(Equals(Line(22),Line(18))),Equals(Line(18),Line(21))):Copy(Line(18),Line(22))
All(Any(BotAt(Add(D,1)),BotAt(Add(D,2)),BotAt(Add(D,3))),Not(BotAt(D))):Move
All(Any(All(BotAt(D),BotAt(Add(D,2))),All(BotAt(D),BotAt(Add(D,1))),All(BotAt(Add(D,1)),BotAt(Add(D,2)))),Not(BotAt(Add(D,3)))):Copy(Add(D,3),D)
Any(All(Any(All(BotAt(D),BotAt(Add(D,2))),All(BotAt(D),BotAt(Add(D,3))),All(BotAt(Add(D,2)),BotAt(Add(D,3)))),Not(BotAt(Add(D,1)))),All(BotAt(Add(D,1)),BotAt(D),Any(Equals(OCond(2),Cond(20)),Equals(OLine(2),Line(19))))):Copy(Add(D,1),D)
All(BotAt(Add(D,3)),BotAt(D),Any(Equals(OCond(2),Cond(20)),Equals(OLine(2),Line(19)))):Copy(Add(D,3),D)
All(BotAt(D),Not(Equals(OCond(2),Cond(20))),Not(Equals(OLine(2),Line(19)))):Copy(Cond(20),OCond(2))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OLine(3),Line(18)))):Copy(Line(18),OLine(3))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OLine(4),Line(21)))):Copy(Line(21),OLine(4))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OCond(0),Cond(22)))):Copy(Cond(22),OCond(0))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OLine(0),Line(17)))):Copy(Line(17),OLine(0))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OCond(1),Cond(21)))):Copy(Cond(21),OCond(1))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OLine(1),Line(20)))):Copy(Line(20),OLine(1))
All(BotAt(D),Equals(OCond(2),Cond(20)),Not(Equals(OLine(2),Line(19)))):Copy(Line(19),OLine(2))
All(BotAt(D),Not(Equals(OCond(2),Cond(20))),Equals(OLine(2),Line(19))):Copy(Add(D,A),D)
Equals(E,1):Copy(Add(A,2),A)
Any(Equals(E,4),Equals(E,8)):Copy(Add(D,E,A),D)
Not(Equals(A,A)):Flag
Not(Equals(A,A)):Copy(Line(3),OLine(E))
Equals(A,A):Move
Any(Equals(E,4),Equals(E,5),Equals(E,6),Equals(E,7),Equals(E,8),Equals(E,9)):Flag
Any(Equals(E,10),Equals(E,11),Equals(E,12),Equals(E,13)):Flag
Start:Copy(1,A)

strażnik

poprawa na Gard. Trafia pobliskich botów flagami na pierwszych 8 liniach. (czyli wszystkie najczęściej używane)

flag
flag
Start:Copy(11,B)
All(BotAt(D),Not(Equals(OLine(Mod(E,8)),Line(0))),Not(BotAt(Add(D,1,Mod(E,3))))):If(Equals(OVar(D),Add(D,2)),Line(7),Line(8))
BotAt(Add(D,1)):Copy(Add(D,1),D)
BotAt(Add(D,2)):Copy(Add(D,2),D)
BotAt(Add(D,3)):Copy(Add(D,3),D)
copy(D,OVar(D))
copy(Line(Mod(E,2)),OLine(Mod(E,8)))
Not(Equals(Line(0),Line(1))):copy(Line(Add(9,Mod(E,16))),Line(Mod(E,2)))

CliqueBorg

Flag
BotAt(D): Copy(Line(Sub(This,1)),OLine(E))
Equals(1,1): Copy(Line(Sub(This,2)),Line(Add(This,Mod(E,21))))
Start: Move
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),1)),Line(3)))):Copy(Line(3),OLine(Sub(OVar(C),1)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),1)),Cond(3)))):Copy(Cond(3),OCond(Sub(OVar(C),1)))
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),2)),Line(2)))):Copy(Line(2),OLine(Sub(OVar(C),2)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),2)),Cond(2)))):Copy(Cond(2),OCond(Sub(OVar(C),2)))
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),3)),Line(1)))):Copy(Line(1),OLine(Sub(OVar(C),3)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),3)),Cond(4)))):Copy(Cond(4),OCond(Sub(OVar(C),3)))

Próba połączenia technologii CliqueBot i Borg w celu stworzenia bota, który rozpoznaje kopie samego siebie pomimo przesunięcia linii. Zaczyna także proces kopiowania od ostatniego wykonanego wiersza kodu na przeciwnym bocie, zamiast wiersza 0, co z większym prawdopodobieństwem zamrozi go w miejscu, ale także bardziej prawdopodobne, że spowoduje uszkodzenie kopii (w rzeczywistości nie jestem na pewno to działa, nie testowałem tego i jest to dość skomplikowane).

Przejeżdżać obok

Ostatnia próba przed terminem.

Flag
Flag
BotAt(D):Copy(Line(Sub(This,1)),OLine(E))
Equals(1,1):Copy(Line(Sub(This,2)),Line(Add(This,Mod(E,21))))
Start:Move
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),1)),Line(3)))):Copy(Line(3),OLine(Sub(OVar(C),1)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),1)),Cond(3)))):Copy(Cond(3),OCond(Sub(OVar(C),1)))
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),2)),Line(2)))):Copy(Line(2),OLine(Sub(OVar(C),2)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),2)),Cond(2)))):Copy(Cond(2),OCond(Sub(OVar(C),2)))
All(BotAt(D),Not(Equals(OLine(Sub(OVar(C),3)),Line(1)))):Copy(Line(1),OLine(Sub(OVar(C),3)))
All(BotAt(D),Not(Equals(OCond(Sub(OVar(C),3)),Cond(4)))):Copy(Cond(4),OCond(Sub(OVar(C),3)))
BotAt(D):Copy(Add(D,1),D)
Equals(1,1):Move