Cosa c'è che non va nelle variabili pubbliche?

33

Bot di codice

Odio le variabili private e protette. Voglio solo accedere a qualsiasi cosa!

Se sei come me, questa sfida è per te!

Scrivi un robot che lavora insieme in armonia con altri robot per far sì che altri robot facciano quello che vuoi. Sei un programmatore e sai come dovrebbero funzionare le cose. Il tuo compito è convertire il maggior numero possibile di robot nei tuoi modi.

Il codice

Avrai 24 righe di codice per scrivere il tuo bot. Ad ogni turno, ogni bot eseguirà 1 riga in sequenza.

Ogni bot memorizza 5 variabili Aattraverso E. Ae Bsono per uso personale, Cmemorizza la riga successiva da eseguire, Dmemorizza la direzione corrente ed Eè un numero casuale. Le variabili iniziano da 0, ad eccezione di D, che inizierà con un valore casuale. Tutte le variabili hanno solo un archivio da 0 a 23. I numeri più grandi o più piccoli saranno modulati di 24.

In questo post, userò l'avversario come bot adiacente che stai affrontando

Ogni riga deve contenere uno dei seguenti 5 comandi:

  1. Flagnon fa nulla. Solo che è come vinci
  2. Movesposta il tuo robot nella Dth direzione. Se un bot occupa già lo spazio, non si verificherà alcuna mossa
  3. Copy Var1 Var2 copia il contenuto di Var1 in Var2
  4. If Condition Line1 Line2 Se la condizione è vera, esegue Line1, altrimenti Line2
  5. Block Var1 blocca la scrittura successiva su una variabile

Una variabile può essere utilizzata come segue:

#Varutilizzerà la variabile come numero di riga. Se Aè 17, Copy #8 #Acopierà il contenuto della riga 8 sulla riga 17. *Varutilizzerà la variabile del tuo avversario. Copy 5 *Cimposterà la Cvariabile dell'avversario per 5 Var+Varaggiungere le due variabili. Copy D+1 Druoterà il bot verso destra

Quando Dviene utilizzato come direzione, [North, East, South, West][D%4]verrà utilizzato

Questi modificatori possono essere concatenati: Copy *#*C #9copieranno la riga successiva che il tuo avversario eseguirà nel tuo codice alla riga 9. si **Driferisce alla Dvariabile dell'avversario del tuo avversario .

Una condizione verrà valutata come segue:

  1. Se Var:
    1. Se Var è Apassato C, restituirà true se Var è diverso da zero, altrimenti false.
    2. Se Var è D, tornerà vero se c'è un bot nella Ddirezione th, altrimenti falso
    3. Se Var è E, tornerà vero se E è dispari, altrimenti falso
    4. Se Var è una linea, tornerà vero se è una linea Flag
  2. Se Var1=Var2:
    1. Restituisce vero se entrambi lo sono A-Eed equivale allo stesso numero
    2. Restituisce vero se entrambe sono linee e il tipo di linea è uguale
  3. Se Var1==Var2:
    1. Restituisce vero se entrambi lo sono A-Eed equivale allo stesso numero
    2. Restituisce vero se entrambe sono linee e sono identiche (le bandiere di diversi robot non saranno uguali)

50 robot di ogni tipo verranno posizionati in un mondo toroidale nel seguente schema:

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

Dopo ogni partita di 5.000 turni, verranno conteggiate le bandiere su ciascun bot. Ottieni un punto se un bot ha più bandiera di qualsiasi altro tipo di bandiera. Se il caso di un pareggio tra i Nrobot, non viene assegnato alcun punto.

Ci saranno 10 partite e i punteggi verranno accumulati alla fine.

Note laterali

I commenti di fine riga sono consentiti e sono indicati con //

Tentare di fare qualcosa che non ha senso, come aggiungere a una linea, non farà nulla

Tentare di fare qualcosa su un bot inesistente non farà nulla

La ricorsione infinita su una Ifterminerà senza che venga eseguita alcuna linea

If non cambia il valore di C

A Blocknon scade fino a quando qualcuno non tenta di scrivergli

Più variabili e linee possono essere bloccate contemporaneamente

Blockl'inserimento di una variabile più volte si bloccherà più volte a condizione che la seconda istruzione di blocco si trovi su una riga di codice diversa dalla prima

Gli spazi sono consentiti solo tra argomenti (e dopo il comando)

Se un bot è più corto di 24 linee, Flag sarà il resto delle linee.

Programma di esempio

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

Il programma verrà eseguito dal mio controller Python qui .

Il controller Java è qui È veloce e sembra molto meglio di quello di Python.

Pagelle:

  1. 6837 $ Copia
  2. 3355 Lockheed
  3. 1695 MindControl
  4. 967 bizantino
  5. 959 AttackOrElse
  6. 743 Cadmyllion
  7. 367 Influenza
  8. 251 TheCommonCold
  9. 226 Magus
  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 Insidioso
  30. 29 HappyAsAClam
  31. 25 NanoVirus
  32. 21 annullatore
  33. 19 Nanoviris
  34. 17 BoringCopybot
  35. 16 Movebot
  36. 14 Flagbot
  37. 13 Neutralizzatore
  38. 12 Cancro
  39. 9 DNAbot
  40. 9 Parassita
  41. 8 MetaInsidious
  42. 8 Rebranding
  43. 8 AdaptiveBot
  44. 8 ReproducingBot
  45. 8 KungFuBot
  46. 5 QuickFreezerbot
  47. 4 Attaccante
king-of-the-hill 
— Nathan Merrill
fonte
1
Ci penserò una volta che Java sarà disponibile per il test.
— Wasmoo,
2
Presumo che tu non abbia mai giocato a Core War. en.wikipedia.org/wiki/Core_War
— matt_black
Non ci ho giocato, ma ho letto un bel po 'su di esso mentre scrivevo questa sfida.
— Nathan Merrill,
Ho una patch per il controller Python e ho provato a rispedirti su github ... ma non ho i permessi / non conosco davvero git. Patch sostituisce tutte le "16" con "num_lines" per consentire l'accesso in scrittura / salto alle ultime 8 istruzioni; rimuove anche "max_flag_count = 0" dalla condizione di pareggio in declare_flags (), che a volte assegnava un pareggio a due vie a un terzo bot.
— adipia,
1
Qualche ETA attivo quando si svolgerà il prossimo round di battaglia? Nessuna fretta. Sono solo curioso. Grazie.
— COTO,

Risposte:

13

Flagbot

Flag

Perché preoccuparsi di fare qualcosa quando altri robot saranno abbastanza carini da darmi il loro codice?

— Sparr
fonte
8

Tag congelamento

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

Intrappola l'avversario in un ciclo, riempilo di bandiere, passa al prossimo avversario.

— Sparr
fonte
Copy C+23 CQuesta deve essere la riga di codice più dannosa xD.
— Cruncher,
Sono interessato. Questo può essere migliorabile. Invece di riempirli di bandiere, puoi inserirvi un anello che si riempie di bandiere? O questo non conta come le tue bandiere?
— Cruncher,
È un'idea chiara e praticabile, ma più complicata. Dovresti scrivere un bot che lo utilizza :)
— Sparr,
2
Conosci la risposta all'ultima domanda? Or would that not count as your flags?. Perché se non contano come le tue bandiere, non è sicuramente una buona soluzione
— Cruncher,
@Cruncher potresti dare loro una delle tue bandiere e fargliele copiare, che conterebbe come una delle tue.
— Sparr,
8

Parassita

Perché uccidere altri robot? Questo bot guarda attraverso il codice dell'avversario e sostituisce solo le bandiere.

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
— PhiNotPi
fonte
8

$ Copy

Questo bot utilizza le stesse tecniche del Lockheed di COTO, quindi prenderò spudoratamente in prestito e migliorerò.

Questo sfrutta una Cvulnerabilità per rompere i blocchi e persino invertire il neutralizzatore. È anche scritto in assoluto per questo. Penso che questo potrebbe rompersi se ilC turno viene ripristinato, ma fintanto che il turno è costante, può essere riscritto per combatterlo.

Per qualsiasi motivo, la mancanza di loop alla fine ha reso questo bot super buono.

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
— Wasmoo
fonte
1
Mi inchinerò al tuo design migliorato e ti affronterò di nuovo nella competizione Bots v. 3. ;)
— COTO
Sinceramente credo che questo sia stato uno sforzo di gruppo da parte di tutti. Questo non esisterebbe se non fosse per diversi robot là fuori da modellare. È interessante notare che l'aggiunta di questo bot ha completamente riorganizzato il tabellone mentre i robot che dipendevano dal blocco venivano rotti mentre altri che dipendevano dalla sostituzione della bandiera erano ascesi.
— Wasmoo,
Qualcuno può riassumere, da qualche parte, l'effettivo comportamento di Block e come questo bot e Lockheed ne traggono vantaggio?
— Sparr,
Ogni riga può accumulare blocchi, come descritto da HappyAsAClam . Soprattutto, non si impila per blocchi chiamati con gli stessi Cvalori. Pertanto, un blocco può essere impilato quando chiamato da Ifun'istruzione, che è l'exploit utilizzato qui. $ Copy rompe i blocchi (come la vongola) eseguendolo Copysulla stessa riga più volte fino a quando ha esito positivo, il che gli conferisce un vantaggio rispetto a Lockheed.
— Wasmoo,
7

Lockheed

La mia terza (e probabilmente definitiva) sottomissione a questa particolare guerra bot: il Lockheed Reactor, o "Lockheed" in breve.

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

Un ringraziamento speciale va a @Wasmoo, che ha condiviso la sua scoperta del "'Blocco di una variabile più volte si bloccherà più volte finché la seconda istruzione di blocco si trova su una riga di codice diversa dalla prima.' semplicemente non è vero "exploit. Ne uso ampiamente.

Inoltre, grazie a Nathan Merill per l'amministrazione del concorso e per la pubblicazione del simulatore. Il simulatore ha un valore inestimabile nell'ottimizzare i robot. Non ci avrei creduto se non l'avessi simulato con i miei occhi, ma l'aggiunta o la rimozione della caratteristica del bot più concettualmente minore può fare la differenza tra grande successo e fallimento assoluto. Sono lacerato dal fatto che sia una buona cosa o no.

— COTO
fonte
Il blocco di una variabile più volte non riesce. Tuttavia, non riesce a bloccare solo se: Stai eseguendo la stessa linea (un Ifpuntamento a quella linea non fallirà), Stai bloccando lo stesso valore (Una singola linea può bloccare le linee 1-24 con una variabile incrementale) e il il blocco non è già stato rilasciato (qualcuno ha provato a modificare quella variabile)
— Nathan Merrill
Contesto l'istruzione nell'OP perché l'istruzione di blocco è codificata sull'IP, non sull'istruzione di blocco. Pertanto, una singola istruzione di blocco può istituire fino a 24 blocchi separati su tutte le istruzioni. Sottolineo che la clausola nel PO affermando "fintanto che la seconda istruzione di blocco si trova su una riga di codice diversa dalla prima" dovrebbe essere modificata in "fintanto che un blocco per coppia ( C, <block target>) non è già attivo". Cioè, la linea su cui si trova l'istruzione di blocco non ha rilevanza per l'impilamento, tranne che se il blocco viene eseguito direttamente, C= indirizzo dell'istruzione di blocco.
— COTO
1
Questo bot è fantastico! Unisce tutti i migliori concetti in uno solo. Si protegge fino a quando non trova un nemico, quindi congela il nemico e ne carica una copia sul bersaglio prima di liberarlo nella direzione opposta. Nelle simulazioni, ho visto una delle sue copie riparare un originale che era stato danneggiato. WOW! Ottimo lavoro, COTO!
— Wasmoo,
6

Attacca o altro

Visto che i robot difensivi come i bizantini stavano facendo altrettanto bene, ho deciso di creare anche un robot difensivo.

Questo ha due serie di schemi, a seconda che il nemico sia presente o meno.

  • Se il nemico non è presente, blocca le sue linee per 3 turni e poi si muove.
  • Se il nemico è presente, si alterna tra copiare la sua bandiera e copiare il codice che farà sì che il nemico copi quella bandiera (un debole replicatore) , copia la sua bandiera
  • Alla fine del loop, cambia in una direzione casuale e continua
  • La maggior parte degli aspetti del suo codice è duplicata

Altri test hanno mostrato alcuni concetti importanti:

  • "Turn random" eseguito in modo drammatico migliore di "Turn right" (+2700 rispetto all'alternativa)
  • Incremento blocco di A+7 mostrato è più efficace di qualsiasi altro incremento (+200 al successivo migliore)
  • "Attacco diretto" ha dimostrato di essere migliore di "Replicatore debole" (+900 rispetto all'alternativa)
  • Difesa di "3-1-2-1" migliore delle altre combinazioni (+200 sul prossimo migliore)
  • Il codice di attacco, blocco e loop duplicato migliora il suo punteggio (+300 rispetto a non duplicato)
  • L'incremento del blocco duplicato non migliora il suo punteggio (+400 rispetto al duplicato)

L'osservazione grafica della simulazione tramite l'interfaccia utente Java ha aiutato molto. Grazie! Di seguito è riportato il codice nuovo e migliorato. Non penso di poter fare altro.

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
— Wasmoo
fonte
Questo bot è stato davvero fantastico. E sei il benvenuto per la GUI.
— Nathan Merrill,
L'ho aggiornato per includere un secondo loop, che ha notevolmente migliorato le sue prestazioni. Ho anche notato che il blocco in Java si basa sul Cblocco. Poiché questo bot ha un blocco rotante basato su C, accumulerà più blocchi su ciascuno dei suoi comandi. Questo rende questo bot ancora più difensivo.
— Wasmoo,
La mia comprensione è che è possibile stabilire un solo blocco per istruzione di origine, quindi il codice sopra riportato può stabilire un solo blocco su qualsiasi istruzione (e occorrerebbe un giro completo di 24 * 17 per stabilire un singolo blocco su ogni istruzione). Se la mia comprensione è errata, la lingua "Bloccare una variabile più volte si bloccherà più volte purché la seconda istruzione di blocco si trovi su una riga di codice diversa dalla prima." nel PO deve essere modificato, perché questa affermazione è (francamente) falsa se il codice di Wasmoo è in grado di stabilire più blocchi su qualsiasi istruzione.
— COTO
@COTO: il simulatore Java aggiunge un blocco per Ifriga a un elenco, digitando la Cvariabile che lo ha chiamato. Quindi con 1 Block e 9 If che eseguono l'istruzione Block, il bot può ottenere fino a 10 Block per ogni linea (prendendo almeno 24 * 10 * 10 turni) Forse l'OP non ha trasmesso correttamente la simulazione.
— Wasmoo,
Ho aggiornato di nuovo il codice per riflettere ulteriori miglioramenti iterativi mantenendo il concetto di base. Ho pensato che sarebbe stato meglio che inondare il forum con ogni iterazione, come il passaggio dalla replica debole all'attacco diretto e dal non duplicato al duplicato. Se desideri che ripubbidi il mio originale, posso farlo.
— Wasmoo,
5

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!

Si sposterà fino a quando non trova un robot.
Metterà quel robot nella stessa direzione di se stesso.
Copia quindi il suo codice nel robot.
Questo dovrebbe formare una fila di robot "Row Bot". :)

— Megatom
fonte
Esistono due problemi (facilmente risolvibili). Innanzitutto, le Ifdichiarazioni devono essere in maiuscolo. In secondo luogo, non dovrebbero esserci spazi su entrambi i lati del =, come D=*D.
— PhiNotPi,
Questa è un'idea fantastica.
— Sparr,
Senza una bandiera non vincerai.
— Paŭlo Ebermann,
3
I robot @ PaŭloEbermann sono riempiti con flag fino a 24 linee, quindi questo bot ha 12 flag impliciti alla fine.
— Sparr,
5

Congelamento eccellente

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

Questo robot continua a tentare di congelare il robot di fronte fino a quando non funziona, quindi scrive un gruppo di flag su linee casuali e dopo 8 turni di esso ruota e si sposta su un altro avversario.

— Sparr
fonte
5

bizantino

Un bot altamente difensivo che istituisce più blocchi sulle sue bandiere e le istruzioni più sensibili, inclusi i meta-blocchi (cioè blocchi su istruzioni di blocco critiche).

Inoltre, si muove costantemente in modi imprevedibili e pianta bandiere in numerose posizioni sugli avversari sulla base del massimo sforzo.

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

Non sono sicuro di come funzionerà, dal momento che non riesco a simulare. Ma ci proveremo. ;)

disconoscimento

Ho scritto questo prima di essere gentilmente informato da PhiNotPi che la logica condizionale è gratuita. Tuttavia, ho deciso di lasciarlo perché non si possono mai avere troppi robot.

— COTO
fonte
questo bot sta vincendo!
— solo
4

Cadmyllion

"Sono appena entrato in un bot nel battle royale", dico. "Si muove ogni pochi turni per prevenire gli attacchi di bot più lenti."

"Cosa intendi con robot più lenti?" Chiede PhiNotPi.

"I robot bloccati stanno valutando lunghe catene di logica condizionale", rispondo.

"Le istruzioni 'If' che reindirizzano ad altre istruzioni --- incluse altre istruzioni 'if' --- sono tutte eseguite nello stesso turno", dice PhiNotPi.

"Dolci regole massacrate del codice assembly!" Piango. "Chi ha avuto quell'idea?"

... e così è la storia di come è nato Cadmyllion.

Cadmyllion: il bot che sfrutta felicemente la capacità surreale di valutare infinite espressioni condizionali in una singola istruzione ... rendendo praticamente ogni cosa che fa condizionale.

Codice

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
— COTO
fonte
4

Meta insidioso

Questo bot congela e quindi converte gli avversari in versioni meno efficienti di Sparr's Insidious , che a loro volta trasformeranno gli avversari in robot che lo spam mi segnala. Questo è probabilmente il bot più complesso che ho scritto e quindi mi aspetto che faccia terribile, non c'è spazio per il blocco e nel codice è presente solo una bandiera. Anche la trasformazione di un bot in un clone insidioso richiede troppo tempo.

La sfida più grande è stata scrivere il codice per i cloni insidiosi in modo tale che funzioni indipendentemente dalla sua posizione nel bot. Il congelamento viene rimosso quando incollo il penultimo codice esattamente dove si trova il congelamento, questo avvia l'avversario appena in tempo.

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
— overactor
fonte
Questa è un'idea intelligente. Tuttavia, non vedo alcun comando di spostamento. Ciò significa che né il tuo bot né il tuo bot di spam si sposteranno?
— Wasmoo,
I cloni Insidious potrebbero spostarsi in base a ciò che è nel codice originale dei robot, a causa dello spazio limitato è stato necessario eliminare un po 'di funzionalità q per renderlo possibile anche con 24 righe. Era più un esercizio mentale che qualsiasi altra cosa in realtà.
— overactor
3

Riparare e proteggere

Questo bot ripara il proprio codice, proteggendo al contempo le linee appena riparate.

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

Spiegazione:

Il valore iniziale di Aè 0e le righe sono numerate da 0 a 23. Se l' Ifistruzione viene eseguita ed è falsa, tenta di eseguire nuovamente la stessa riga. Il controller non consente a un bot di eseguire due volte la stessa linea, quindi il turno termina e Cviene incrementato a1 .

La riga successiva Copy #A #A+8viene effettivamente eseguita indipendentemente dal valore Ifdell'istruzione. La differenza è che viene eseguito due volte se vero e una volta se falso. Se la linea #A+8è bloccata (cosa che succede alla fine), eseguirla due volte con la copia effettiva, mentre eseguirla una volta la sbloccherà. Quindi, la riga appena copiata viene bloccata per preservarla.

— PhiNotPi
fonte
Sto cercando di capire tutti voi ragazzi ma sono bloccato. Qual è il valore iniziale di A? No 0? In tal caso, la prima riga confronta la riga 0 con la riga 16, ma come ho capito dal bot di esempio OP, la prima riga è la riga 1, non è vero? Inoltre, ancora nella tua prima riga, si #Criferisce proprio a questa riga, quindi significa che se l' Ifistruzione restituisce false sei bloccato in un ciclo infinito?
— plannapus,
@plannapus Ho aggiunto alcune spiegazioni.
— PhiNotPi,
3

Neutralizer

Questo bot fa riscrivere alla vittima l'intero programma, vale 0 punti. Una volta che il virus è a posto, va avanti. Questo è un approccio di terra bruciata alla vittoria.

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]

Il confronto *#*C==#7non sembra adattarsi correttamente al turno dell'avversario, ma il bot alla fine si sposta.

— Wasmoo
fonte
Copy C+1 Cè tutto ciò che serve per saltare una singola riga.
— Nathan Merrill,
2
'Salta la riga successiva' significa che il tuo bot impiegherà 16 turni ad eseguire le istruzioni di bandiera prima di continuare. Potresti volerci Copy 23 C, invece, per tornare alla prima riga.
— Sparr,
"Salta la riga successiva" si verifica solo se "GOTO A" è stato sovrascritto. Ci sono altri modi in cui posso rendere questo bot più offensivo e difensivo, come ripetere "A", duplicare il codice e bloccare "GOTO A". Tuttavia, se questo bot viene colpito, è praticamente morto comunque.
— Wasmoo,
3

Insidioso

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

Ispirato da @Cruncher, questo bot infetta altri bot con un piccolo blocco di codice, riempiendo l'altro bot con i flag di questo bot. Quei robot fanno quindi sedere le anatre per ulteriori attacchi, ma saranno per lo più pieni delle mie bandiere quando vengono infettati nuovamente da qualcun altro.

Modifica: grazie a @PhiNotPi per assistenza golf, @overactor per consigli sull'efficienza

— Sparr
fonte
Congratulazioni per aver colpito 2k!
— bjb568,
3

Felice come una vongola

Questo è un esercizio di blocco. Ha funzionato straordinariamente bene fino al$Copy venuto in giro.

La vongola ha 22 comandi di blocco. PerchéA viene spostato ad ogni loop, faranno riferimento a righe diverse ogni volta attraverso il loop. Ciò consente a ciascun comando di impilare blocchi su ogni altra riga, raggiungendo il massimo a 22 blocchi per riga. Quindi, per spezzare la vongola completamente corazzata, bisognerebbe scrivere su una riga 22 volte.

Ad esempio, #10saranno protetti ogni volta attraverso il ciclo dalle seguenti righe:

  • Loop 0, A = 0 #10protetto dalla linea 7 (7+0+3 = 10)
  • Loop 1, A = 7 #10protetto dalla linea 0 (0+7+3 = 10)
  • Loop 2, A = 14 #10protetto dalla linea 17 ( 17+14+3= 34 = 10)
  • Loop 3, A = 21 #10protetto dalla linea 10 ( 10+21+3= 34 = 10)

Quindi, dopo la Linea 10 del Loop 3, #10è stata bloccata 4 volte, richiedendo 4 scritture #10per rompere i blocchi, con una quinta per sovrascrivere effettivamente la linea.

Nota che i blocchi sono codificati in base al loro Cvalore e volontà non impilati se la linea protetta era già bloccata dallo stesso Cvalore. Quindi, dopo aver stabilito 22 blocchi per ogni riga, i blocchi non verranno più impilati.

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
— Wasmoo
fonte
3

Controllo mentale

Immagino che non sia mai troppo tardi?

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 nasce dalla mia idea che occorrerebbe molto tempo per copiare l'intero programma sull'avversario, durante il quale il mio robot è vulnerabile agli attacchi da altre direzioni. Quindi perché non fare in modo che l'avversario copi il mio programma mentre cerco i nemici?

Una volta trovato un nemico, MindControl congela immediatamente il nemico per impedire la fuga. Quindi carica il downloader sull'avversario e lascia che la vittima scarichi il programma MindControl stesso. Il downloader sfrutta il fatto che pochi bot utilizzano Be eseguiranno il loop fino a quando non scarica tutte le 24 linee. Quando il downloader riscrive #19da Copy 16 CaCopy 23 C , significa che la vittima ha scaricato tutte le linee e continuerà a riavviarsi.

Le prime versioni del mio bot non includono Blocks. Ed era così vulnerabile che quasi ogni cambiamento è paralizzante. Così ho deciso di aggiungere i blocchi basati su Wasmoo $ Copy (che si basa sul Lockheed di COTO). L'aspetto negativo che ho riscontrato è che per l'originale è difficile correggere errori nelle copie. Ma questo è tutt'altro che paralizzante e il punteggio è aumentato in modo significativo, quindi ho mantenuto i blocchi.

AGGIORNAMENTI

Ho migliorato il downloader per continuare a provare a scaricare fino a una riscrittura riuscita per aggirare i blocchi. Significa che ci vuole un altro turno per caricare il downloader ma il mio punteggio è raddoppiato dopo questa modifica !! Non posso discutere con i numeri.

Un altro aggiornamento. Come avrai notato, MindControl decide se attaccare il bersaglio confrontando una linea casuale tra se stesso e il suo bersaglio. Se corrispondono, MindControl presuppone che il bersaglio sia già infetto e lo lascia da solo. (Nota a margine: ero solito usare una linea statica per il confronto, ma che dà molti falsi positivi e negativi) Si scopre che dà molti falsi negativi. Così ho deciso di sfruttare ==e apportare alcune modifiche banali come C+23a 23+C. Il programma è funzionalmente identico ma diverso agli occhi di ==. Ora che MindControl non ha una linea identica a quella di nessun altro bot, colpirà al 100% qualsiasi bot non toccato. Ancora una volta, il punteggio è aumentato in modo significativo.

Migliorato di nuovo il downloader. Ora funziona su un ciclo più breve. (che sembra avere una grande correlazione con il mio punteggio)

Downloader migliorato ancora una volta. Utilizza il codice del bot originale in modo che si carichi più velocemente. Aggiunti anche 2 blocchi casuali che sembrano migliorare il punteggio

— TwiNight
fonte
Non è mai troppo tardi!
— Nathan Merrill,
Sto pensando di rinominare BrainWash ...
— TwiNight,
O BunkerBuster dopo aver visto il busto del downloader attraverso HappyAsAClam il bunker
— TwiNight
Avevo pensato di provare prima l'idea di caricare un downloader, ma non sono riuscito a farlo piccolo come te. Ottimo lavoro! Adoro anche il tuo uso di D come delta del blocco errante; salva un comando e accelera il tuo design. Sono sorpreso che un bot senza un comando "Sposta" funzioni così bene. Le simulazioni mostrano che i robot tendono a raggrupparsi, ma non sapevo che sarebbe stata una strategia vincente. E sono d'accordo, c'è qualcosa di straordinariamente soddisfacente nel rompere la vongola.
— Wasmoo,
@Wasmoo Ovviamente il design del downloader richiede che il bot rimanga fermo e fa ammassare i robot. Mi piace pensarlo come le radici di un albero che raggiunge e assimila altri robot per crescere. Ma credo che l'agilità sia il motivo per cui $ Copy e Lockheed mi hanno battuto.
— TwiNight,
2

aggressore

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
— Nathan Merrill
fonte
2

Movebot

Move
Copy 23 C
Flag

Come Flagbot, ma spostati accettando doni di codice per andare con tutte le nostre bandiere.

— Sparr
fonte
2

Riproduzione di bot

Questo bot tenta di congelare il suo avversario e quindi copia l'intero codice in quel bot prima di riavviare l'altro bot. Questo dovrebbe funzionare anche (principalmente) se l'avversario usa il blocco, sebbene ciò renda tutto ancora più lento di quanto non sia già.

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
— overactor
fonte
Nessuno spazio nella condizione
— Nathan Merrill,
@NathanMerrill gotcha
— overactor
2

magio

Magus è un semplice tentativo di un virus auto-propagante. Tenta di copiarsi nei programmi di altri bot. (Modificato per rimuovere numeri negativi, correggere condizioni, tagliare le linee.)

Block #A
Copy #A *#A
Copy A+1 A
If A #0 #4
Copy 0 *C
Flag
Move
Copy 0 C
— Isaac
fonte
I valori negativi non sono ammessi. Si prega di utilizzare 23 per B
— Nathan Merrill il
Si prega di utilizzare 23, non 25.
— Nathan Merrill
A meno che non sia frainteso, ciò non gli farebbe bloccare o copiare le righe 23 o 24 (nota: è leggermente cambiato dalla prima revisione, A è incrementato di 1, non B)
— Isaac,
+0 = 24 +1 = 25, -1 = 23. Se vuoi che sia -1, dovrebbe essere 23.
— Nathan Merrill
Ecco com'era prima, perché pensavo che potessi confrontare solo con 0 (in qualche modo ho perso la parte '=', biasimo lo skimming), ma ora è cambiato, quindi A inizia da 1 e termina a 25. Immagina la linea 3 come for (int i = 1; i < 25; i++).. .
— Isaac
1

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

Questo bot ripara il proprio codice mentre si muove e attacca.

— Sparr
fonte
1

Congelatore rapido

Cerca di copiare le bandiere nella linea che verrà eseguita dopo il suo avversario, si muove se non c'è nemico da attaccare.

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
— overactor
fonte
Le prime due righe non sono valide. Hanno bisogno di # 13 e # 14
— Nathan Merrill il
1

Blocca, congela, attacca

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

Blocca tutte e 24 le linee, quindi esegue 24 loop in movimento o attaccando, quindi si ripete. Un attacco comporta il tentativo di congelare l'avversario, quindi copiare quattro bandiere in posizioni casuali, quindi girare.

— Sparr
fonte
1

Nascondi, blocca, attacca

Questo bot si basa su Block Freeze Attack. Ho cambiato il posizionamento di alcune Ifaffermazioni per renderlo più compatto permettendomi di piantare più bandiere. Devo anche scappare all'inizio di una partita per guadagnare tempo per bloccare.

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
— PhiNotPi
fonte
1

Virus Roving

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

Questo robot vaga fino a quando non trova un nemico, quindi li congela, sostituisce tutto il loro codice con il proprio, li libera, quindi vaga di nuovo.

— Sparr
fonte
1

Il Comune raffreddore

Ti infetta praticamente immediatamente e lo diffonderai in giro. basato sul Parassita di PhiNotPi , il comune raffreddore controlla quasi immediatamente se è in grado di copiare la sua bandiera sopra la tua. Blocca un valore casuale se non è possibile. Si muove un po 'se non c'è avversario.

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
— overactor
fonte
1

Influenza

Questo è strettamente basato sul Common Cold (che era basato sul mio Parassita) con una velocità leggermente maggiore.

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
— PhiNotPi
fonte
Non vedo l'ora di vedere il tipo di differenza che questo farà. Il numero 5 sulla linea 5 provocherà comunque un ciclo infinito e è improbabile che anche i numeri 7 siano ciò che intendevi.
— overactor
@overactor Grazie, questi erano errori creati aggiungendo una riga aggiuntiva.
— PhiNotPi,
Conosco mai il dolore.
— overactor
1

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

Questo bot cerca di individuare casualmente le bandiere nei robot nemici e di sostituirle con bandiere amichevoli, allontanandosi dopo aver rilevato il successo. Ispirato al bot Cancro.

— Sparr
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.