¿Qué hay de malo con las variables públicas?

33

Code Bots

Odio las variables privadas y protegidas. ¡Solo quiero acceder a todo!

Si eres como yo, ¡este desafío es para ti!

Escribe un bot que funcione en armonía con otros bots para que otros hagan lo que quieras. Eres programador y sabes cómo se supone que funcionan las cosas. Su trabajo es convertir tantos bots a su manera como sea posible.

El código

Tendrás 24 líneas de código para escribir tu bot. Cada turno, cada bot ejecutará 1 línea secuencialmente.

Cada bot almacena 5 variables a Através E. Ay Bson para uso personal, Calmacena la siguiente línea para ejecutar, Dalmacena la dirección actual y Ees un número aleatorio. Las variables comienzan en 0, excepto para D, que comenzará en un valor aleatorio. Todas las variables solo tienen tienda 0-23. Los números mayores o menores serán modulados por 24.

En esta publicación, usaré al oponente como el bot adyacente al que te enfrentas

Cada línea debe contener uno de los siguientes 5 comandos:

  1. Flagno hace nada. Excepto que así es como ganas
  2. Movemueve tu bot en la Ddirección th. Si un bot ya ocupa el espacio, no ocurrirá ningún movimiento
  3. Copy Var1 Var2 copia el contenido de Var1 en Var2
  4. If Condition Line1 Line2 Si la condición es verdadera, ejecuta Line1, de lo contrario Line2
  5. Block Var1 bloquea la próxima escritura en una variable

Una variable se puede usar de la siguiente manera:

#Varusará la variable como un número de línea. Si Aes 17, Copy #8 #Acopiará el contenido de la línea 8 en la línea 17. *Varusará la variable de su oponente. Copy 5 *Cconfigurará la Cvariable del oponente para 5 Var+Varagregar las dos variables. Copy D+1 Drotará el bot hacia la derecha

Cuando Dse usa como una dirección, [North, East, South, West][D%4]se usará

Estos modificadores se pueden encadenar: Copy *#*C #9copiará la siguiente línea que su oponente ejecutará en su propio código en la línea 9. se **Drefiere a la Dvariable del oponente .

Una condición se evaluará de la siguiente manera:

  1. Si Var:
    1. Si Var ha Aterminado C, devolverá verdadero si Var es distinto de cero, de lo contrario falso.
    2. Si Var es D, devolverá verdadero si hay un bot en la Ddirección th, de lo contrario falso
    3. Si Var es E, devolverá verdadero si E es impar, de lo contrario falso
    4. Si Var es una línea, devolverá verdadero si es una línea de bandera
  2. Si Var1=Var2:
    1. Devuelve verdadero si ambos son A-E, e igual al mismo número
    2. Devuelve verdadero si ambas son líneas y el tipo de línea es igual
  3. Si Var1==Var2:
    1. Devuelve verdadero si ambos son A-E, e igual al mismo número
    2. Devuelve verdadero si ambas son líneas y son idénticas (las banderas de diferentes bots no serán iguales)

Se colocarán 50 bots de cada tipo en un mundo toroidal con el siguiente patrón:

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

Después de cada juego de 5,000 turnos, se contarán las banderas en cada bot. Obtienes un punto si un bot tiene más de tu bandera que cualquier otro tipo de bandera. Si se trata de un empate entre Nbots, no se otorgan puntos.

Habrá 10 juegos y los puntajes se acumularán al final.

Notas al margen

Los comentarios de fin de línea están permitidos y se denotan con //

Intentar hacer algo que no tiene sentido, como agregar a una línea, no hará nada

Intentar hacer algo en un bot inexistente no hará nada

La recursión infinita en un Iftestamento terminará sin que se ejecute ninguna línea.

If no cambia el valor de C

A Blockno caduca hasta que alguien intente escribirle

Se pueden bloquear varias variables y líneas a la vez

BlockInventar una variable varias veces se bloqueará varias veces siempre que la segunda instrucción de bloque esté en una línea de código diferente a la primera.

Los espacios solo se permiten entre argumentos (y después del comando)

Si un bot tiene menos de 24 líneas, Flag será el resto de las líneas.

Programa de muestra

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

El programa será ejecutado por mi controlador Python aquí .

El controlador Java está aquí. Es rápido y se ve mucho mejor que el de Python.

Marcador:

  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 bloqueador
  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 Nulificador
  33. 19 Nanoviris
  34. 17 aburrido
  35. 16 Movebot
  36. 14 Flagbot
  37. 13 neutralizador
  38. 12 cáncer
  39. 9 DNAbot
  40. 9 parásito
  41. 8 MetaInsidious
  42. 8 Rebranding
  43. 8 AdaptiveBot
  44. 8 ReproducciónBot
  45. 8 KungFuBot
  46. 5 QuickFreezerbot
  47. 4 atacante
king-of-the-hill 
— Nathan Merrill
fuente
1
Me ocuparé de esto una vez que Java esté disponible para que lo pruebe.
— Wasmoo
2
Supongo que nunca has jugado Core War. en.wikipedia.org/wiki/Core_War
— matt_black
No lo he jugado, pero leí un poco al escribir este desafío.
— Nathan Merrill
Tengo un parche para el controlador Python y traté de devolvérselo en github ... pero no tengo permisos / realmente no sé git. El parche reemplaza todos los "16" con "num_lines" para permitir el acceso de escritura / salto a las últimas 8 instrucciones; también elimina "max_flag_count = 0" de la condición de empate en declare_flags (), que a veces otorga un empate bidireccional a un tercer bot.
— Adipy
1
¿Alguna ETA sobre cuándo se realizará la próxima ronda de batalla? No hay prisa en absoluto. Tengo curiosidad. Gracias.
— COTO

Respuestas:

13

Flagbot

Flag

¿Por qué molestarse en hacer algo cuando otros bots serán lo suficientemente amables como para darme su código?

— Sparr
fuente
8

Etiqueta de congelación

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

Atrapa al oponente en un bucle, llénalo con banderas, pasa al siguiente oponente.

— Sparr
fuente
Copy C+23 CEsta tiene que ser la línea de código más maliciosa xD.
— Cruncher
Estoy interesado. Esto puede ser mejorable. En lugar de llenarlos con banderas, ¿puedes poner un lazo en ellos que se llene de banderas? ¿O eso no contaría como tus banderas?
— Cruncher
Esa es una idea ordenada y viable, pero más complicada. Deberías escribir un bot que lo use :)
— Sparr
2
¿Conoces la respuesta a la última pregunta? Or would that not count as your flags?. Porque si no cuentan como sus propias banderas, definitivamente no es una buena solución
— Cruncher
@Cruncher, puedes darles una de tus banderas y hacer que la copien, lo que contaría como una de las tuyas.
— Sparr
8

Parásito

¿Por qué matar a otros bots? Este bot mira el código del oponente y reemplaza solo las banderas.

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
fuente
8

$ Copia

Este bot utiliza muchas de las mismas técnicas que Lockheed de COTO, por lo que pediré prestado y mejoraré descaradamente.

Esto explota una Cvulnerabilidad para romper bloques e incluso revierte el neutralizador. También está escrito en absolutos debido a esto. Creo que esto podría romperse si Cse restablece el turno, pero mientras el turno sea constante, se puede reescribir para combatirlo.

Por alguna razón, la falta de bucle al final hizo que este bot fuera súper bueno.

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
fuente
1
Me inclinaré ante tu diseño mejorado y te enfrentaré nuevamente en la competencia Bots v. 3. ;)
— COTO
Sinceramente, creo que fue un esfuerzo grupal de todos. Esto no existiría si no fuera por varios bots para modelar. Curiosamente, la adición de este bot reorganizó completamente el marcador ya que los bots que dependían del bloqueo se rompieron mientras que otros que dependían del reemplazo de la bandera ascendieron.
— Wasmoo
¿Alguien puede resumir, en algún lugar, el comportamiento real de Block y cómo este bot y Lockheed lo aprovechan?
— Sparr
Cada línea puede acumular bloques, como lo describe HappyAsAClam . Lo más importante, no se apila para bloques llamados con los mismos Cvalores. Por lo tanto, un bloque se puede apilar cuando se llama desde una Ifdeclaración, que es el exploit que se usa aquí. $ Copiar rompe bloques (como la almeja) al ejecutar Copyen la misma línea una y otra vez hasta que tenga éxito, lo que le da una ventaja sobre Lockheed.
— Wasmoo
7

Lockheed

Mi tercera (y probablemente final) sumisión a esta guerra de bot en particular: el Reactor Lockheed, o "Lockheed" para abreviar.

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 agradecimiento especial a @Wasmoo, que compartió su descubrimiento del "'Bloquear una variable varias veces se bloqueará varias veces siempre que la segunda instrucción de bloqueo esté en una línea de código diferente a la primera'. simplemente no es cierto "explotar. Lo uso ampliamente.

Además, gracias a Nathan Merill por administrar la competencia y por publicar el simulador. El simulador es absolutamente invaluable en el ajuste de bots. No lo habría creído si no lo hubiera simulado con mis propios ojos, pero la adición o eliminación de la función de bot más conceptualmente menor puede significar la diferencia entre un gran éxito y un fracaso absoluto. Tengo dudas sobre si eso es bueno o no.

— COTO
fuente
El bloqueo de una variable varias veces falla. Sin embargo, solo falla al bloquear si: Está ejecutando la misma línea (un Ifapuntar a esa línea no fallará), Está bloqueando el mismo valor (Una sola línea puede bloquear las líneas 1-24 con una variable incremental), y el bloque aún no se ha liberado (alguien intentó modificar esa variable)
— Nathan Merrill
Disputo la declaración en el OP porque la instrucción de bloqueo está codificada para la IP, no la declaración de bloque. Por lo tanto, una declaración de bloque único puede instituir hasta 24 bloques separados en todas las instrucciones. Sostengo que la cláusula en el OP que establece "siempre y cuando la segunda instrucción de bloque esté en una línea de código diferente a la primera" debe modificarse a "siempre y cuando un bloque para par ( C, <block target>) no esté vigente". Es decir, la línea en la que se encuentra la instrucción de bloque no tiene relevancia para el apilamiento, excepto que si el bloque se ejecuta directamente, C= dirección de instrucción de bloque.
— COTO
1
¡Este bot es increíble! Combina todos los mejores conceptos en uno. Se protege hasta que encuentra un enemigo, luego lo congela dos veces y carga una copia de sí mismo en el objetivo antes de liberarlo en la dirección opuesta. En las simulaciones, vi una de sus copias reparar un original que había sido dañado. ¡GUAUU! ¡Buen trabajo, COTO!
— Wasmoo
6

Ataque o más

Al ver que a los robots defensivos como Bizantino les iba tan bien, decidí hacer un robot defensivo también.

Esto tiene dos conjuntos de patrones, dependiendo de si el enemigo está presente o no.

  • Si el enemigo no está presente, bloquea sus líneas durante 3 turnos y luego se mueve.
  • Si el enemigo está presente, alterna entre copiar su bandera y copiar el código que hará que el enemigo copie esa bandera (un replicador débil) que copia su bandera
  • Al final del ciclo, cambia a una dirección aleatoria y continúa
  • La mayoría de los aspectos de su código están duplicados

Más pruebas mostraron algunos conceptos importantes:

  • "Girar al azar" se desempeñó dramáticamente mejor que "Girar a la derecha" (+2700 sobre la alternativa)
  • El incremento de bloque de A+7mostrado es más efectivo que cualquier otro incremento (+200 sobre el siguiente mejor)
  • Se ha demostrado que "ataque directo" es mejor que "replicador débil" (+900 sobre la alternativa)
  • Defensa de "3-1-2-1" mejor que otras combinaciones (+200 sobre el siguiente mejor)
  • El código duplicado de ataque, bloqueo y bucle mejora su puntaje (+300 sobre no duplicado)
  • El incremento de bloque duplicado no mejora su puntaje (+400 sobre duplicado)

Observar la simulación gráficamente a través de la interfaz de usuario de Java ayudó mucho. ¡Gracias! A continuación se muestra el código nuevo y mejorado. No creo que pueda hacer nada más.

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
fuente
Este bot lo hizo realmente increíble. Y eres bienvenido para la GUI.
— Nathan Merrill
Lo actualicé para incluir un segundo ciclo, que mejoró drásticamente su rendimiento. También noté que el bloqueo en Java se basa en lo Cque lo bloqueó. Debido a que este bot tiene un Bloque giratorio basado en Cél, acumulará múltiples bloques en cada uno de sus comandos. Eso hace que este bot sea más defensivo.
— Wasmoo
Entiendo que solo se podría establecer un bloque por instrucción de origen, por lo tanto, su código anterior solo podría establecer un solo bloque en cualquier instrucción (y tomaría un total de 24 * 17 turnos para establecer un solo bloque en cada instrucción). Si mi comprensión es incorrecta, entonces el lenguaje "Bloquear una variable varias veces se bloqueará varias veces siempre que la segunda instrucción de bloque esté en una línea de código diferente a la primera". en el OP necesita ser enmendado, porque esta declaración es (francamente) falsa si el código de Wasmoo puede establecer múltiples bloques en cualquier instrucción.
— COTO
@COTO: El simulador de Java agrega un bloque por Iflínea a una lista, ingresando la Cvariable que lo llamó. Entonces, con el 1 Bloque y los 9 Si que ejecutan la declaración de Bloqueo, el bot puede obtener hasta 10 Bloques para cada línea, (tomando al menos 24 * 10 * 10 turnos) Quizás el OP no transmitió la simulación correctamente.
— Wasmoo
He actualizado el código nuevamente para reflejar mejoras en las iteraciones mientras mantengo el concepto central. Pensé que esto sería mejor que inundar el foro con cada iteración, como el cambio de Replicación débil a Ataque directo y No duplicado a Duplicado. Si desea que vuelva a publicar mi original, puedo hacerlo.
— 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!

Se moverá hasta que encuentre un robot.
Pondrá a ese robot en la misma dirección que él.
Luego copiará su código en el robot.
Esto debería hacer una fila de Robots "Row Bot". :)

— MegaTom
fuente
Hay dos problemas (fácilmente reparables). Primero, las Ifdeclaraciones deben estar en mayúscula. En segundo lugar, no debe haber espacios a ambos lados del =, como D=*D.
— PhiNotPi
Esta es una idea impresionante.
— Sparr
Sin una bandera no vas a ganar.
— Paŭlo Ebermann
3
@ Los bots de PaŭloEbermann están llenos de banderas de hasta 24 líneas, por lo que este bot tiene 12 banderas implícitas al final.
— Sparr
5

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

Este bot sigue tratando de congelar el bot frente a él hasta que funcione, luego escribe un grupo de banderas en líneas aleatorias, y después de 8 turnos de eso, gira y pasa a otro oponente.

— Sparr
fuente
5

bizantino

Un bot altamente defensivo que instituye múltiples bloques en sus banderas e instrucciones más sensibles, incluidos metabloques (es decir, bloques en instrucciones de bloque crítico).

También se mueve constantemente de maneras impredecibles, y coloca banderas en numerosos lugares en los oponentes en una base de mejor esfuerzo.

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

No estoy seguro de cómo funcionará, ya que no puedo simular. Pero lo intentaremos. ;)

Renuncia

Escribí esto antes de ser amablemente informado por PhiNotPi de que la lógica condicional es gratuita. Sin embargo, he decidido dejarlo puesto ya que uno nunca puede tener demasiados bots.

— COTO
fuente
¡Este bot está ganando!
— justhalf
4

Cadmyllion

"Acabo de ingresar a un bot en la batalla real", le digo. "Se mueve cada pocos turnos para evitar ataques de robots más lentos".

"¿Qué quieres decir con robots más lentos?" PhiNotPi pregunta.

"Bots que están atrapados evaluando largas cadenas de lógica condicional", respondo.

"Las declaraciones 'If' que redirigen a otras declaraciones --- incluidas otras declaraciones 'if' --- se ejecutan todas en el mismo turno", dice PhiNotPi.

"¡Dulces reglas masacradas del código de ensamblaje!" Lloro. "¿A quién se le ocurrió esa idea?"

... y así es la historia de cómo surgió Cadmyllion.

Cadmyllion: el bot que explota felizmente la capacidad surrealista de evaluar infinitas expresiones condicionales en una sola instrucción ... al hacer que casi todo lo que haga sea condicional.

Código

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
fuente
4

Meta Insidioso

Este bot se congela y luego convierte a los oponentes en versiones menos eficientes de Insidious de Sparr , que a su vez, convertirá a los oponentes en bots que marcan spam para mí. Este es probablemente el bot más complejo que he escrito y, por lo tanto, espero que sea terrible, no hubo espacio para bloquear y solo un indicador se ajustó en el código. Convertir un bot en un clon insidioso también lleva demasiado tiempo.

El mayor desafío fue escribir el código para los clones insidiosos de tal manera que funcione independientemente de su posición en el bot. La congelación se elimina cuando pego el penúltimo código exactamente donde se encuentra la congelación, esto inicia al oponente justo a tiempo.

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
fuente
Esa es una idea inteligente. Sin embargo, no veo ningún comando Mover. ¿Eso significa que ni su bot ni su bot de spam se moverán?
— Wasmoo
Los clones insidiosos podrían moverse dependiendo de lo que haya en el código original de los bots, debido al espacio limitado, se tuvo que desechar un poco de funcionalidad para que esto fuera posible con 24 líneas. Fue más un ejercicio mental que cualquier otra cosa realmente.
— overactor
3

Repara y protege

Este bot repara su propio código, mientras protege las líneas recién reparadas.

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

Explicación:

El valor inicial de Aes 0, y las líneas están numeradas del 0 al 23. Si la Ifdeclaración se ejecuta y es falsa, intenta ejecutar la misma línea nuevamente. El controlador no permite que un bot ejecute la misma línea dos veces, por lo que el turno finaliza y Cse incrementa a 1.

La siguiente línea, en Copy #A #A+8realidad se realiza independientemente del valor de la Ifdeclaración. La diferencia es que se ejecuta dos veces si es verdadero y una vez si es falso. Si la línea #A+8está bloqueada (lo que sucede eventualmente), realizarla dos veces con copia real, mientras que realizarla una vez solo la desbloqueará. Luego, la línea recién copiada se bloquea para preservarla.

— PhiNotPi
fuente
Estoy tratando de entender a todos ustedes, bots, pero estoy atascado. ¿Cuáles son los valores iniciales de A? ¿No es así 0? Si es así, su primera línea compara la línea 0 con la línea 16, pero como entendí por el bot de ejemplo de OP, la primera línea es la línea 1, ¿no es así? Además, todavía en su primera línea, se #Crefiere a esta misma línea, entonces, ¿significa que si la Ifdeclaración devuelve falso está atrapado en un bucle sin fin?
— plannapus
@plannapus Agregué alguna explicación.
— PhiNotPi
3

Neutralizador

Este bot hace que su víctima reescriba todo su programa, por lo que vale 0 puntos. Una vez que el virus está en su lugar, continúa. Este es un enfoque de tierra quemada para la victoria.

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]

La comparación *#*C==#7no parece ajustarse correctamente al cambio del oponente, pero el bot eventualmente avanza.

— Wasmoo
fuente
Copy C+1 Ces todo lo que se necesita para omitir una sola línea.
— Nathan Merrill
2
'Saltar la siguiente línea' significa que su bot pasará 16 turnos ejecutando instrucciones de marca antes de continuar. Es posible que desee Copy 23 Callí, para volver a la primera línea.
— Sparr
'Saltar la línea siguiente' solo ocurrirá si se sobrescribió 'GOTO A'. Hay otras formas en que puedo hacer que este bot sea más ofensivo y defensivo, como repetir 'A', duplicar el código y bloquear 'GOTO A'. Sin embargo, si este bot es golpeado, está muerto de todos modos.
— 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

Inspirado por @Cruncher, este bot infecta a otros bots con un pequeño bloque de código, llenando al otro bot con las banderas de este bot. Esos bots son patos sentados para un ataque adicional, pero estarán llenos de mis banderas cuando alguien más los vuelva a infectar.

Editar: gracias a @PhiNotPi por su asistencia en el golf, a @overactor por sus consejos de eficiencia

— Sparr
fuente
¡Felicidades por golpear 2k!
— bjb568
3

Feliz como una almeja

Este es un ejercicio de bloqueo. Funcionó notablemente bien hasta que $Copyllegó.

La almeja tiene 22 comandos de bloque. Debido a que Ase desplaza cada bucle, harán referencia a diferentes líneas cada vez a través del bucle. Esto permite que cada comando apile bloques en cualquier otra línea, alcanzando un máximo de 22 bloques por línea. Por lo tanto, para romper la almeja completamente blindada, uno necesitaría escribir 22 veces en una línea.

Por ejemplo, #10estará protegido cada vez a través del ciclo por las siguientes líneas:

  • Lazo 0, A = 0 #10protegido por la línea 7 ( 7+0+3= 10)
  • Lazo 1, A = 7 #10protegido por la línea 0 ( 0+7+3= 10)
  • Lazo 2, A = 14 #10protegido por la línea 17 ( 17+14+3= 34 = 10)
  • Lazo 3, A = 21 #10protegido por la línea 10 ( 10+21+3= 34 = 10)

Entonces, después de la línea 10 del bucle 3, #10se ha bloqueado 4 veces, lo que requiere 4 escrituras #10para romper los bloques, con un quinto para sobrescribir la línea.

Tenga en cuenta que los bloques están codificados por su Cvalor y no se apilarán si la línea protegida ya estaba bloqueada por el mismo Cvalor. Entonces, después de establecer 22 bloques para cada línea, los bloques ya no se acumularán.

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
fuente
3

Control mental

¿Supongo que nunca es demasiado tarde?

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 surge de mi idea de que tomaría un tiempo considerable copiar todo mi programa al oponente, durante el cual mi bot es vulnerable a los ataques desde otras direcciones. Entonces, ¿por qué no hacer que el oponente copie mi programa mientras escaneo en busca de enemigos?

Una vez que encuentra un enemigo, MindControl inmediatamente lo congela para evitar escapar. Luego carga el descargador al oponente y deja que la víctima descargue el programa MindControl. El descargador explota el hecho de que pocos bots usan By se repetirán hasta que descargue las 24 líneas. Cuando el descargador reescribe #19desde Copy 16 Ca Copy 23 C, significa que la víctima ha descargado todas las líneas y se reiniciará.

Las primeras versiones de mi bot no incluyen bloques. Y fue tan vulnerable que casi cualquier cambio es paralizante. Así que decidí agregar Bloques basados ​​en $ Copy de Wasmoo (que se basa en Lockheed de COTO). La desventaja que encontré es que es difícil para el original corregir errores en las copias. Pero esto está lejos de ser paralizante y la puntuación aumentó significativamente, así que mantuve los Bloques.

ACTUALIZACIONES

Mejoré el descargador para seguir intentando descargar hasta una reescritura exitosa para eludir los bloques. ¡Significa que se necesita un turno más para cargar el descargador, pero mi puntaje se duplicó después de este cambio! No puedo discutir con números.

Otra actualización Como habrás notado, MindControl decide si atacar al objetivo comparando una línea aleatoria entre él y su objetivo. Si coinciden, MindControl simplemente asume que el objetivo ya está infectado y lo deja solo. (Nota al margen: solía usar una línea estática para la comparación, pero eso da muchos falsos positivos y negativos) Resulta que da muchos falsos negativos. Así que decidí explotar ==y hacer algunos cambios triviales como C+23a 23+C. El programa es funcionalmente idéntico pero diferente a los ojos de ==. Ahora que MindControl no tiene una línea que sea idéntica a cualquier línea en cualquier otro bot, llegará al 100% a cualquier bot intacto. Nuevamente, el puntaje aumentó significativamente.

Mejorado el descargador de nuevo. Ahora se ejecuta en un bucle más corto. (que parece tener una gran correlación con mi puntaje)

Descargador mejorado una vez más. Utiliza el código original del bot para que se cargue más rápido. También se agregaron 2 bloques aleatorios que parecen mejorar la puntuación

— TwiNight
fuente
¡Nunca es demasiado tarde!
— Nathan Merrill
Estoy considerando cambiar el nombre a BrainWash ...
— TwiNight
O BunkerBuster después de ver la descarga del descargador a través de HappyAsAClam the bunker
— TwiNight
Había pensado probar esta idea de cargar un descargador primero, pero no pude hacerlo tan pequeño como tú. ¡Gran trabajo! También me encanta tu uso de D como el delta del bloque itinerante; Guarda un comando y acelera su diseño. Estoy sorprendido de que un bot sin un comando 'Mover' funcione tan bien. Las simulaciones muestran que los bots tienden a agruparse, pero no sabía que sería una estrategia ganadora. Y estoy de acuerdo, hay algo especialmente satisfactorio en romper la almeja.
— Wasmoo
@Wasmoo Obviamente, el diseño de descarga requiere que el bot permanezca inmóvil y hace que los bots se agrupen. Me gusta pensar que son las raíces de un árbol que se extienden y asimilan otros robots para crecer. Pero supongo que la agilidad es la razón por la cual $ Copy y Lockheed me ganaron.
— TwiNight
2

Agresor

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
fuente
2

Movebot

Move
Copy 23 C
Flag

Como Flagbot, pero muévete mientras aceptas regalos de código para ir con todas nuestras banderas.

— Sparr
fuente
2

Bot de reproducción

Este bot intenta congelar a su oponente y luego copiar todo su código en ese bot antes de reiniciar el otro bot. Esto también debería funcionar (principalmente) si el oponente usa el bloqueo, aunque eso lo hace aún más lento de lo que ya es.

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
fuente
No hay espacios en la condición
— Nathan Merrill
@NathanMerrill gotcha
— overactor
2

Mago

Magus es un simple intento de un virus que se propaga por sí mismo. Intenta copiarse en los programas de otros bots. (Editado para eliminar números negativos, arreglar condiciones, recortar líneas).

Block #A
Copy #A *#A
Copy A+1 A
If A #0 #4
Copy 0 *C
Flag
Move
Copy 0 C
— Isaac
fuente
Los valores negativos no están permitidos. Utilice 23 para B
— Nathan Merrill
Utilice 23, no 25.
— Nathan Merrill
A menos que esté malinterpretando, eso haría que no bloqueara o copiara las líneas 23 o 24 (nota: ha cambiado ligeramente desde la primera revisión, A se incrementa en 1, no B)
— Isaac
+0 = 24 +1 = 25, -1 = 23. Si quieres que sea -1, debería ser 23.
— Nathan Merrill
Así era antes, porque pensé que solo se podía comparar con 0 (omití la parte '=' de alguna manera, culpo al descremado), pero ahora ha cambiado, así que A comienza en 1 y termina en 25. Solo imagine la línea 3 como 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

Este bot repara su propio código mientras se mueve y ataca.

— Sparr
fuente
1

Congelador rápido

Intenta copiar banderas en la línea que se ejecutará junto a su oponente, se mueve si no hay enemigo para atacar.

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
fuente
Las dos primeras líneas no son válidas. Necesitan # 13 y # 14
— Nathan Merrill
1

Bloquear, congelar, atacar

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

Bloquea las 24 líneas, luego realiza un bucle 24 veces moviéndose o atacando, luego se repite. Un ataque implica intentar congelar al oponente, luego copiar cuatro banderas en ubicaciones aleatorias y luego girar.

— Sparr
fuente
1

Ocultar, bloquear, atacar

Este bot se basa en Block Freeze Attack. Cambié la ubicación de algunas Ifdeclaraciones para hacerlo más compacto, lo que me permitió plantar más banderas. También tengo que huir al comienzo de un juego para ganar algo de tiempo para bloquear.

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
fuente
1

Virus itinerante

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

Este bot deambula hasta que encuentra un enemigo, luego lo congela, reemplaza todo su código con el suyo, lo descongela y luego vuelve a deambular.

— Sparr
fuente
1

El frio comun

Te infecta prácticamente de inmediato y lo propagarás. basado en el parásito de PhiNotPi , el resfriado común comprueba casi de inmediato si puede copiar su bandera sobre la suya. Bloquea un valor aleatorio si no puede. Se mueve un poco si no hay oponente.

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
fuente
1

Influenza

Esto se basa estrechamente en el resfriado común (que se basó en mi parásito) con una velocidad ligeramente mayor.

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
fuente
Espero ver el tipo de diferencia que esto hará. Sin embargo, el # 5 en la línea 5 provocará un bucle infinito, y es poco probable que esos # 7 sean lo que pretendías.
— overactor
@overactor Gracias, esos fueron errores creados al agregar una línea adicional.
— PhiNotPi
¿Conozco alguna vez el dolor?
— 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

Este bot intenta localizar al azar banderas en bots enemigos y reemplazarlas con banderas amigas, alejándose después de detectar el éxito. Inspirado por el cáncer bot.

— Sparr
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.