Quel est le problème avec les variables publiques?

33

Bots de code

Je déteste les variables privées et protégées. Je veux juste accéder à tout et n'importe quoi!

Si vous êtes comme moi, alors ce défi est pour vous!

Ecrivez un bot qui fonctionne bien en harmonie avec d'autres bots pour que les autres fassent ce que vous voulez Vous êtes un programmeur et vous savez comment les choses sont censées fonctionner. Votre travail consiste à convertir autant de bots que vous le souhaitez.

Le code

Vous aurez 24 lignes de code pour écrire votre bot. Chaque tour, chaque bot exécutera 1 ligne de manière séquentielle.

Chaque bot stocke 5 variables à Atravers E. Aet Bsont à usage personnel, Cstocke la ligne suivante à exécuter, Dstocke la direction actuelle et Econstitue un nombre aléatoire. Les variables commencent à 0, sauf pour Dqui commencera à une valeur aléatoire. Toutes les variables ont uniquement la mémoire 0-23. Les nombres plus grands ou plus petits seront modulés par 24.

Dans ce post, je vais utiliser l'adversaire pour être le bot adjacent auquel vous faites face.

Chaque ligne doit contenir l'une des 5 commandes suivantes:

  1. Flagne fait rien. Sauf que c'est comme ça qu'on gagne
  2. Movedéplace votre bot dans la Ddirection th. Si un bot occupe déjà l'espace, aucun mouvement ne se produira
  3. Copy Var1 Var2 copie le contenu de Var1 dans Var2
  4. If Condition Line1 Line2 Si la condition est vraie, exécute Line1, sinon Line2
  5. Block Var1 bloque la prochaine écriture sur une variable

Une variable peut être utilisée comme suit:

#Varutilisera la variable comme numéro de ligne. Si Ais est 17, Copy #8 #Acopiera le contenu de la ligne 8 sur la ligne 17. *Varutilisera la variable de votre adversaire. Copy 5 *Cmettra la Cvariable de l'adversaire à 5 Var+Varajouter les deux variables. Copy D+1 Dfera tourner le bot vers la droite

Quand Dest utilisé comme direction, [North, East, South, West][D%4]sera utilisé

Ces modificateurs peuvent être chaînés: Copy *#*C #9ils copieront la ligne suivante que votre adversaire exécutera dans votre propre code, à la ligne 9. **D fait référence à la Dvariable de l'adversaire de votre adversaire .

Une condition sera évaluée comme suit:

  1. Si Var :
    1. Si Var est A complet C, il retournera vrai si Var est différent de zéro, sinon faux.
    2. Si Var est D , il retournera vrai s'il y a un bot dans la Ddirection th, sinon faux
    3. Si Var est E , il retournera vrai si E est impair, sinon faux
    4. Si Var est une ligne, il retournera true s'il s'agit d'une ligne de drapeau
  2. Si Var1=Var2 :
    1. Renvoie true si les deux sont A-E valables et égalent le même nombre
    2. Renvoie true si les deux sont des lignes et si le type de ligne est égal.
  3. Si Var1==Var2 :
    1. Renvoie true si les deux sont A-E valables et égalent le même nombre
    2. Retourne vrai si les deux sont des lignes et sont identiques (les drapeaux de différents robots ne seront pas égaux)

50 robots de chaque type seront placés dans un monde toroïdal de la manière suivante:

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

Après chaque tour de 5 000 tours, les drapeaux de chaque bot seront comptés. Vous obtenez un point si un bot a plus de votre drapeau que tout autre type de drapeau. Si le cas d'égalité entreN robots, aucun point n'est attribué.

Il y aura 10 matchs et les scores seront accumulés à la fin.

Notes de côté

Les commentaires de fin de ligne sont autorisés et sont signalés par //

Essayer de faire quelque chose qui n'a pas de sens, comme ajouter à une ligne ne fera rien

Essayer de faire quelque chose sur un bot inexistant ne fera rien

Récursion infinie sur un If testament se termine sans qu'aucune ligne ne soit exécutée

If ne change pas la valeur de C

UNE Block n'expire pas jusqu'à ce que quelqu'un tente de lui écrire

Plusieurs variables et lignes peuvent être bloquées en même temps

BlockUne variable multiple bloquera plusieurs fois tant que la seconde instruction de bloc est sur une ligne de code différente de celle de votre première

Les espaces ne sont autorisés qu'entre les arguments (et après la commande)

Si un bot est plus court que 24 lignes, Flag sera le reste des lignes.

Exemple de programme

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

Le programme sera exécuté par mon contrôleur Python ici .

Le contrôleur Java est là C'est rapide et a une bien meilleure apparence que celui en python.

Tableau de bord:

  1. 6837 $ Copie
  2. 3355 Lockheed
  3. 1695 MindControl
  4. 967 byzantine
  5. 959 AttackOrElse
  6. 743 cadmyllion
  7. 367 grippe
  8. 251 TheCommonCold
  9. 226 mage
  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 bloqueur
  24. 40 Tourellière
  25. 37 Copycat
  26. 37 Kamikaze
  27. 35 FlagInjector
  28. 33 RandomCopier
  29. 31 insidieux
  30. 29 HappyAsAClam
  31. 25 NanoVirus
  32. 21 annulation
  33. 19 Nanoviris
  34. 17 BoringCopybot
  35. 16 Movebot
  36. 14 Flagbot
  37. 13 neutralisant
  38. 12 cancer
  39. 9 DNAbot
  40. 9 parasites
  41. 8 MetaInsidious
  42. 8 Rebranding
  43. 8 AdaptiveBot
  44. 8 ReproducingBot
  45. 8 KungFuBot
  46. 5 QuickFreezerbot
  47. 4 attaquant
king-of-the-hill Nathan Merrill
la source
1
Je serai tout à ce sujet une fois le Java est disponible pour moi de tester.
Wasmoo
2
Je suppose que vous n'avez jamais joué à Core War. en.wikipedia.org/wiki/Core_War
matt_black
Je n'y ai pas joué, mais j'ai lu pas mal de choses en écrivant ce défi.
Nathan Merrill
J'ai un correctif pour le contrôleur Python et j'ai essayé de vous le renvoyer sur github ... mais je n'ai pas les permissions / je ne sais pas vraiment git. Patch remplace tous les "16" par "num_lines" pour permettre un accès en écriture / saut aux 8 dernières instructions; supprime également "max_flag_count = 0" de la condition de rattachement dans declare_flags (), qui attribuait parfois un lien à double sens à un troisième bot.
Adipy
1
Une heure d'arrivée prévue pour le prochain round de bataille? Pas pressé du tout. Je suis juste curieux. Merci.
COTO

Réponses:

13

Flagbot

Flag

Pourquoi se donner la peine de faire quoi que ce soit alors que d'autres robots seront assez gentils pour me donner leur code?

Sparr
la source
8

Freeze Tag

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

Attrapez l'adversaire dans une boucle, remplissez-le de drapeaux, passez à l'adversaire suivant.

Sparr
la source
Copy C+23 CCe doit être la ligne de code xD la plus malveillante.
Cruncher
Je suis intéressé. Cela peut être améliorable. Plutôt que de les remplir de drapeaux, pouvez-vous y insérer une boucle qui se remplit de drapeaux? Ou est-ce que cela ne compterait pas comme vos drapeaux?
Cruncher
C'est une idée nette et viable, mais plus compliquée. Vous devriez écrire un bot qui l'utilise :)
Sparr
2
Connaissez-vous la réponse à la dernière question? Or would that not count as your flags?. Parce que s'ils ne comptent pas comme vos propres drapeaux, ce n'est certainement pas une bonne solution
Cruncher
@Cruncher, vous pouvez leur donner un de vos drapeaux et leur demander de le copier, ce qui compterait comme l'un des vôtres.
Sparr
8

Parasite

Pourquoi tuer d'autres robots? Ce bot regarde à travers le code de l'adversaire et ne remplace que les drapeaux.

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
la source
8

$ Copie

Ce bot utilise une grande partie des mêmes techniques que Lockheed de COTO, je vais donc emprunter et améliorer sans vergogne.

Cela exploite une Cvulnérabilité pour casser des blocs et même inverser le neutralisant. Il est également écrit en absolus à cause de cela. Je pense que cela pourrait casser si leC changement est rétabli, mais tant que le changement est constant, il peut être réécrit pour le combattre.

Pour une raison quelconque, le manque de boucle à la fin a rendu ce bot super bon.

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
la source
1
Je m'inclinerai devant votre design amélioré et vous affronterai à nouveau dans la compétition Bots v. 3. ;)
COTO
Je crois honnêtement que c'était un effort de groupe de la part de tous. Cela n'existerait pas s'il n'y avait pas plusieurs bots à modéliser. Il est intéressant de noter que l’ajout de ce bot a complètement réorganisé le tableau de bord. Des robots dépendant du blocage ont été cassés, tandis que d’autres, dépendant du remplacement du drapeau, sont en hausse.
Wasmoo
Quelqu'un peut-il résumer, quelque part, le comportement réel de Block et comment ce bot et Lockheed en profitent?
Sparr
Chaque ligne peut accumuler des blocs, comme décrit par HappyAsAClam . Plus important encore, il ne s'empile pas pour les blocs appelés avec les mêmes Cvaleurs. Ainsi, un bloc peut être empilé lorsqu'il est appelé à partir d'une Ifinstruction, qui est l'exploit utilisé ici. $ Copy casse des blocs (comme la palourde) en s'exécutant Copysur la même ligne encore et encore jusqu'à la réussite, ce qui lui confère un avantage sur Lockheed.
Wasmoo
7

Lockheed

Ma troisième (et probablement finale) soumission à cette guerre des botiers: le réacteur de Lockheed, ou "Lockheed" en abrégé.

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 merci tout spécial à @Wasmoo, qui a partagé sa découverte de "" Le blocage d'une variable à plusieurs reprises bloquera plusieurs fois, à condition que la deuxième instruction de blocage se trouve sur une ligne de code différente de la première. " n'est tout simplement pas vrai "exploit. Je m'en sers beaucoup.

Merci également à Nathan Merill d’avoir organisé le concours et publié le simulateur. Le simulateur est extrêmement précieux pour régler les robots. Je n'y aurais pas cru si je ne l'avais pas simulé de mes propres yeux, mais l'ajout ou la suppression de la fonctionnalité de bot la plus mineure sur le plan conceptuel peut faire toute la différence entre un grand succès et un échec cuisant. Je suis déchiré quant à savoir si c'est une bonne chose ou non.

COTO
la source
Bloquer une variable plusieurs fois échoue. Toutefois, le blocage n’est bloqué que si: vous exécutez la même ligne (un Ifpointage sur cette ligne n’échouera pas), vous bloquez la même valeur (une seule ligne peut bloquer les lignes 1 à 24 avec une variable d’incrémentation) et bloc n'a pas encore été publié (quelqu'un a essayé de modifier cette variable)
Nathan Merrill
Je conteste la déclaration dans l'OP car l'instruction de blocage est associée à l'IP, pas à l'instruction de blocage. Ainsi, une seule instruction de bloc peut instituer jusqu'à 24 blocs distincts pour toutes les instructions. Je soumets que la clause du PO indiquant "tant que la deuxième instruction de bloc se trouve sur une ligne de code différente de la première" devrait être modifiée en "tant qu'un bloc pour paire ( C, <block target>) n'est pas déjà en vigueur". C'est-à-dire que la ligne sur laquelle se trouve l'instruction de bloc n'a aucune pertinence pour l'empilement, sauf que si le bloc est exécuté directement, C= adresse d'instruction de bloc.
COTO
1
Ce bot est incroyable! Il combine tous les meilleurs concepts en un. Il se protège jusqu'à ce qu'il trouve un ennemi, puis le gèle à nouveau et en télécharge une copie sur la cible avant de le libérer dans la direction opposée. Lors de simulations, j'ai vu une de ses copies réparer un original endommagé. HOU LA LA! Excellent travail, COTO!
Wasmoo
6

Attaque ou autre

Voyant que les robots défensifs comme Byzantine se portaient si bien, j'ai décidé de fabriquer également un robot défensif.

Cela a deux séries de modèles, selon que l'ennemi est présent ou non.

  • Si l'ennemi n'est pas présent, il bloque ses lignes pendant 3 tours puis se déplace.
  • Si l'ennemi est présent, il alterne entre la copie de son drapeau et le code de copie qui le poussera à copier ce drapeau (un réplicateur faible), il copie son drapeau.
  • À la fin de la boucle, il passe dans une direction aléatoire et continue
  • La plupart des aspects de son code sont dupliqués

Plus de tests ont montré quelques concepts importants:

  • "Turn random" a nettement mieux performé que "Turn right" (+2700 par rapport à une alternative)
  • L'incrément de bloc A+7montré est plus efficace que tout autre incrément (+200 par rapport au plus proche)
  • "L'attaque directe" s'est avérée meilleure que le "réplicateur faible" (+900 par rapport à l'autre)
  • Défense de "3-1-2-1" meilleure que les autres combinaisons (+200 sur la prochaine meilleure)
  • Les codes d'attaque, de blocage et de boucle dupliqués améliorent son score (+300 sur les non-dupliqués)
  • L'incrément de bloc dupliqué n'améliore pas son score (+400 sur dupliqué)

Observer graphiquement la simulation via l'interface utilisateur Java a beaucoup aidé. Merci! Vous trouverez ci-dessous le code nouveau et amélioré. Je ne pense pas pouvoir faire plus.

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
la source
Ce bot a vraiment été génial. Et vous êtes les bienvenus pour l'interface graphique.
Nathan Merrill
Je l'ai mis à jour pour inclure une deuxième boucle, ce qui a considérablement amélioré ses performances. J'ai aussi remarqué que le blocage en Java est basé sur celui Cqui l'a bloqué. Parce que ce bot a un bloc tournant basé sur C, il accumulera plusieurs blocs sur chacune de ses commandes. Cela rend ce bot plus défensif.
Wasmoo
D'après ce que je comprends, un seul bloc par instruction d'origine peut être établi. Par conséquent, votre code ci-dessus ne peut établir qu'un seul bloc pour une instruction (et il faudrait 24 * 17 tours complets pour établir un seul bloc pour chaque instruction). Si ma compréhension est fausse, le langage "Blocage d'une variable à plusieurs reprises bloquera plusieurs fois tant que la deuxième instruction de blocage se trouve sur une ligne de code différente de la première." dans le PO doit être modifié, car cette affirmation est (franchement) fausse si le code de Wasmoo est capable d’établir plusieurs blocs pour n’importe quelle instruction.
COTO le
@COTO: Le simulateur Java ajoute un bloc par Ifligne à une liste, en saisissant la Cvariable qui l'a appelée. Donc, avec les 1 Block et 9 If qui exécutent l'instruction Block, le bot peut obtenir jusqu'à 10 Blocs pour chaque ligne (prenant au moins 24 * 10 * 10 tours). Le PO n'a peut-être pas correctement transmis la simulation.
Wasmoo
J'ai de nouveau mis à jour le code pour refléter l'amélioration des itérations tout en conservant le concept de base. Je pensais que ce serait mieux que d'inonder le forum à chaque itération, par exemple passer de la réplication faible à l'attaque directe, et de la duplication à la duplication. Si vous souhaitez que je republie mon original, je peux le faire.
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!

Va se déplacer jusqu'à ce qu'il trouve un robot.
Va mettre ce robot dans la même direction que lui-même.
Copiera ensuite son code dans le robot.
Cela devrait faire une rangée de "Row Bot" Robots. :)

MegaTom
la source
Il y a deux problèmes (faciles à résoudre). Premièrement, les Ifdéclarations doivent être capitalisées. Deuxièmement, il ne devrait pas y avoir d'espaces de part et d'autre de la =, comme D=*D.
PhiNotPi
C'est une idée géniale.
Sparr
Sans drapeau, vous ne gagnerez pas.
Paël Ebermann
3
@ Les bots PaŭloEbermann sont remplis avec des drapeaux jusqu'à 24 lignes, de sorte que ce bot a 12 drapeaux implicites à la fin.
Sparr
5

Super congélation

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

Ce bot continue d'essayer de geler le bot devant lui jusqu'à ce que cela fonctionne, puis écrit un tas de drapeaux sur des lignes aléatoires, et après 8 tours, il tourne et passe à un autre adversaire.

Sparr
la source
5

byzantin

Un bot hautement défensif qui institue de multiples blocs sur ses drapeaux et les instructions les plus sensibles, y compris des méta-blocs (c'est-à-dire des blocs sur des instructions de bloc critiques).

De plus, il se déplace de façon imprévisible et installe des drapeaux dans de nombreux endroits sur des adversaires du mieux possible.

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

Je ne sais pas comment cela va fonctionner, car je ne peux pas simuler. Mais nous allons tenter le coup. ;)

Avertissement

J'ai écrit ceci avant d'être bien informé par PhiNotPi que la logique conditionnelle est gratuite. Cependant, j'ai décidé de le laisser car on ne peut jamais avoir trop de robots.

COTO
la source
ce bot est en train de gagner!
peine
4

Cadmyllion

"Je viens d'entrer dans un bot dans la bataille royale", dis-je. "Il se déplace tous les quelques tours pour empêcher les attaques de bots plus lents."

"Que voulez-vous dire par bots lents?" Demande PhiNotPi.

"Les robots bloqués évaluent de longues chaînes de logique conditionnelle", répond-je.

"Les instructions 'if' qui redirigent vers d'autres instructions, y compris d'autres instructions 'if' - sont toutes exécutées au même tour," déclare PhiNotPi.

"Douces règles massacrées du code d'assemblage!" Je pleure. "Qui a eu cette idée?"

... et c'est ainsi l'histoire de la naissance de Cadmyllion.

Cadmyllion: le bot qui exploite avec bonheur la capacité surréaliste d'évaluer une infinité d'expressions conditionnelles dans une seule instruction ... en rendant pratiquement tout ce qu'il fait est conditionnel.

Code

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
la source
4

Meta Insidious

Ce bot se fige et convertit ensuite les adversaires en versions moins efficaces d' Insidious de Sparr , qui à leur tour transformera les adversaires en bots qui spamment des drapeaux pour moi. C'est probablement le bot le plus complexe que j'ai écrit et je m'attends donc à ce qu'il fasse très mal, il n'y avait pas d'espace pour le blocage et un seul drapeau installé dans le code. Transformer un bot en un clone insidieux prend également trop de temps.

Le plus gros défi consistait à écrire le code pour les clones insidieux de manière à ce qu'il fonctionne quelle que soit sa position dans le bot. Le gel est supprimé lorsque je colle l’avant-dernier code exactement à l’endroit où se trouve le gel, cela déclenche l’opposition juste à temps.

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
suracteur
la source
C'est une idée intelligente. Cependant, je ne vois aucune commande de déplacement. Cela signifie-t-il que ni votre bot ni votre bot de spam ne bougeront?
Wasmoo
Les clones d'Insidious peuvent se déplacer en fonction de ce que contient le code d'origine du bots. En raison de l'espace limité, il a fallu supprimer assez de fonctionnalités pour rendre cela possible, même avec 24 lignes. C'était plus un exercice mental qu'autre chose en réalité.
Overactor
3

Réparer et protéger

Ce bot répare son propre code, tout en protégeant les lignes récemment réparées.

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

Explication:

La valeur initiale de Ais 0et les lignes sont numérotées de 0 à 23. Si l' Ifinstruction est exécutée et qu'elle est fausse, il tente d'exécuter à nouveau la même ligne. Le contrôleur ne permet pas à un bot d'exécuter deux fois la même ligne, le tour est terminé et Cincrémenté 1.

La ligne suivante Copy #A #A+8est effectivement exécutée quelle que soit la valeur de l' Ifinstruction. La différence est qu'il est exécuté deux fois si vrai et une fois si faux. Si la ligne #A+8est bloquée (ce qui se produit éventuellement), le faire deux fois avec une copie réelle, le faire une fois, le débloquera seulement. Ensuite, la ligne nouvellement copiée est bloquée pour la conserver.

PhiNotPi
la source
J'essaie de comprendre tous les gars, mais je suis coincé. Quelle est la valeur initiale de A? N'est-ce pas 0? Si c'est le cas, votre première ligne compare la ligne 0 à la ligne 16, mais comme je l'ai compris dans l'exemple du bot OP, la première ligne est la ligne 1, n'est-ce pas? De plus, toujours dans votre première ligne, #Cfait référence à cette ligne même, cela signifie-t-il que si la Ifdéclaration renvoie false, vous êtes bloqué dans une boucle sans fin?
Plannapus
@plannapus j'ai ajouté quelques explications.
PhiNotPi
3

Neutralisant

Ce bot force sa victime à réécrire tout son programme, lui donnant une valeur de 0 point. Une fois que le virus est en place, il continue. Ceci est une approche de la terre brûlée à la victoire.

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 comparaison *#*C==#7ne semble pas s'adapter correctement au décalage de l'adversaire, mais le bot finit par passer à autre chose.

Wasmoo
la source
Copy C+1 Cest tout ce qui est nécessaire pour sauter une seule ligne.
Nathan Merrill
2
"Ignore la ligne suivante" signifie que votre bot va passer 16 tours à exécuter les instructions de drapeau avant de continuer. Vous voudrez peut-être Copy 23 Cy aller à la place, pour revenir à la première ligne.
Sparr
"Ignorer la ligne suivante" ne se produira que si "GOTO A" a été écrasé. Il existe d'autres moyens de rendre ce bot plus offensif et défensif, tels que répéter «A», dupliquer le code et bloquer «GOTO A». Cependant, si ce bot est touché, il est pratiquement mort.
Wasmoo
3

Insidieux

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

Inspiré par @Cruncher, ce bot infecte les autres robots avec un petit bloc de code, remplissant l'autre bot avec les drapeaux de ce bot. Ces bots sont alors des canards assis pour une attaque ultérieure, mais ils seront surtout remplis de mes drapeaux quand ils seront réinfectés par quelqu'un d'autre.

Edit: merci à @PhiNotPi pour son aide au golf, @overactor pour ses conseils en matière d'efficacité

Sparr
la source
Félicitations pour frapper 2k!
bjb568
3

Heureux comme une palourde

Ceci est un exercice de blocage. Il a fonctionné remarquablement bien jusqu'à ce que $Copyvienne autour.

La palourde a 22 commandes de bloc. Parce que Achaque boucle est décalée, ils référenceront des lignes différentes à chaque fois dans la boucle. Cela permet à chaque commande d'empiler des blocs sur une ligne sur deux, avec un maximum de 22 blocs par ligne. Ainsi, pour casser la palourde entièrement blindée, il faudrait écrire 22 fois sur une ligne.

Par exemple, #10 sera protégé chaque fois à travers la boucle par les lignes suivantes:

  • Boucle 0, A = 0 #10 protégé par la ligne 7 ( 7+0+3= 10)
  • Boucle 1, A = 7 #10 protégé par la ligne 0 (0+7+3 = 10)
  • Boucle 2, A = 14 #10protégé par la ligne 17 (17+14+3 = 34 = 10)
  • Boucle 3, A = 21 #10protégé par la ligne 10 ( 10+21+3= 34 = 10)

Ainsi, après que la ligne 10 de la boucle 3 #10ait été bloquée 4 fois , il a fallu 4 écrit #10pour casser les blocs, avec une 5e pour écraser la ligne.

Notez que les blocs sont définis par leur Cvaleur et ne s'empileront pas si la ligne protégée a déjà été bloquée par la même Cvaleur. Ainsi, après l’établissement de 22 blocs pour chaque ligne, les blocs ne seront plus empilés.

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
la source
3

Contrôle de la pensée

Je suppose qu'il n'est jamais trop tard?

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 vient de mon idée qu'il faudrait beaucoup de temps pour copier tout mon programme sur l'adversaire, au cours duquel mon bot est vulnérable aux attaques venant d'autres directions. Alors, pourquoi ne pas obliger l'adversaire à copier mon programme pendant que je recherche des ennemis?

Une fois qu'il a trouvé un ennemi, MindControl le bloque immédiatement pour empêcher toute évasion. Ensuite, il télécharge le téléchargeur sur l'adversaire et laisse la victime télécharger le programme de MindControl lui-même. Le téléchargeur exploite le fait que peu de robots utilisent Bet vont en boucle jusqu'à ce qu'il télécharge les 24 lignes. Quand le téléchargeur réécrit#19 de Copy 16 Cà Copy 23 C, cela signifie que la victime a téléchargé toutes les lignes et continue à se réinitialiser.

Les premières versions de mon bot n'incluent pas les blocs. Et il était si vulnérable que presque tout changement est invalidant. J'ai donc décidé d'ajouter des blocs basés sur $ Copy de Wasmoo (basé sur Lockheed de COTO). L'inconvénient que j'ai trouvé est qu'il est difficile pour l'original de corriger les erreurs dans les copies. Mais ceci est loin d’être invalidant et le score a augmenté de manière significative, j’ai donc gardé les Blocks.

MISES À JOUR

J'ai amélioré le téléchargeur pour continuer à essayer de télécharger jusqu'à ce qu'une réécriture réussisse pour contourner les blocs. Cela signifie qu'il faut encore un tour pour télécharger le téléchargeur, mais mon score a doublé après ce changement! Ne peut pas discuter avec des chiffres.

Une autre mise à jour. Comme vous l'avez peut-être remarqué, MindControl décide d'attaquer une cible en comparant une ligne aléatoire entre elle et sa cible. S'ils concordent, MindControl considère simplement que la cible est déjà infectée et la laisse tranquille. (Remarque: j'avais l'habitude d'utiliser une ligne statique à des fins de comparaison, mais cela donne beaucoup de faux positifs et de faux négatifs) Il s'avère que cela donne beaucoup de faux négatifs. J'ai donc décidé d'exploiter ==et de faire quelques changements insignifiants comme C+23à 23+C. Le programme est fonctionnellement identique mais différent aux yeux de ==. Maintenant que MindControl n’a plus de ligne identique à une ligne d’un autre bot, il touchera 100% des bot non modifiés. Encore une fois, le score a augmenté de manière significative.

Amélioration du téléchargeur à nouveau. Il fonctionne maintenant sur une boucle plus courte. (qui semble avoir une grande corrélation avec mon score)

Downloader amélioré encore une fois. Utilise le code du bot original pour un téléchargement plus rapide. Également ajouté 2 blocs aléatoires qui semblent améliorer le score

TwiNight
la source
Ce n'est jamais trop tard!
Nathan Merrill
J'envisage de
Ou BunkerBuster après avoir vu le téléchargeur exploser à travers HappyAsAClam, le bunker
TwiNight le
J'avais eu l'idée d'essayer cette idée de télécharger un téléchargeur en premier, mais je ne pouvais pas l'obtenir aussi petit que vous. Bon travail! J'aime aussi votre utilisation de D comme delta block itinérant; il enregistre une commande et accélère votre conception. Je suis étonné qu'un bot sans commande 'Move' fonctionne si bien. Les simulations montrent que les robots ont tendance à s'agglutiner, mais je ne savais pas que ce serait une stratégie gagnante. Et je suis d'accord, il y a quelque chose de particulièrement satisfaisant à casser la palourde.
Wasmoo
@Wasmoo De toute évidence, la conception du téléchargeur nécessite que le bot reste immobile et crée une masse de bots. J'aime penser à cela comme à des racines d'un arbre qui tendent et assimilent d'autres bots pour se développer. Mais je suppose que l'agilité est la raison pour laquelle $ Copy et Lockheed m'ont battu.
TwiNight le
2

Attaquant

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
la source
2

Movebot

Move
Copy 23 C
Flag

Comme Flagbot, mais déplacez-vous tout en acceptant des cadeaux de code assortis à tous nos drapeaux.

Sparr
la source
2

Robot reproducteur

Ce bot tente de geler son adversaire, puis de copier l'intégralité de son code dans ce bot avant de redémarrer l'autre. Cela devrait également fonctionner (surtout) si l'adversaire utilise le blocage, bien que cela ralentisse encore le processus.

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
suracteur
la source
Aucune place dans l'état
Nathan Merrill
@NathanMerrill gotcha
overactor
2

Mage

Magus est une simple tentative de virus auto-propagateur. Il tente de se copier dans les programmes d'autres robots. (Modifié pour supprimer les nombres négatifs, corriger la condition, couper les lignes.)

Block #A
Copy #A *#A
Copy A+1 A
If A #0 #4
Copy 0 *C
Flag
Move
Copy 0 C
Isaac
la source
Les valeurs négatives ne sont pas autorisées. Veuillez utiliser 23 pour B
Nathan Merrill
S'il vous plaît utilisez 23, pas 25.
Nathan Merrill
À moins que je ne comprenne mal, cela ne ferait pas bloquer ou copier les lignes 23 ou 24 (remarque: il a légèrement changé depuis la première révision, A est incrémenté de 1, et non de B)
Isaac
+0 = 24 +1 = 25, -1 = 23. Si vous voulez que ce soit -1, il devrait être 23.
Nathan Merrill
C’était comme ça avant, parce que je pensais que vous ne pouviez comparer qu’avec 0 (la partie manquée '=' en quelque sorte, je blâme le skimming), mais cela a maintenant changé, alors A commence à 1 et se termine à 25. Imaginez simplement la ligne 3 comme 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

Ce bot répare son propre code tout en se déplaçant et en attaquant.

Sparr
la source
1

Bloqueur

Copy A+1 A
Block #A
Copy C+22 C
Nathan Merrill
la source
1

Imitateur

If D #4 #3
Move
Copy 23 C
Copy *#*C #1
Copy #23 *#E
Nathan Merrill
la source
1

Congélateur rapide

Essaie de copier les drapeaux dans la ligne qui sera exécuté à côté de son adversaire, se déplace s'il n'y a pas d'ennemi à attaquer.

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
suracteur
la source
Les deux premières lignes sont invalides. Ils ont besoin des numéros 13 et 14
Nathan Merrill Le
1

Bloquer, geler, attaquer

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

Bloque les 24 lignes, puis boucle 24 fois en mouvement ou en attaque, puis se répète. Une attaque consiste à tenter de geler l'adversaire, puis à copier quatre drapeaux à des emplacements aléatoires, puis à les tourner.

Sparr
la source
1

Masquer, bloquer, attaquer

Ce bot est basé sur Block Freeze Attack. J'ai modifié l'emplacement de certaines Ifinstructions pour les rendre plus compactes, ce qui m'a permis de planter plus de drapeaux. Je l’ai aussi fait fuir au début d’un jeu pour gagner du temps pour le bloquer.

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
la source
1

Virus errant

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

Ce bot se promène jusqu'à ce qu'il trouve un ennemi, puis le bloque, remplace tout son code par le sien, le débloque puis recommence.

Sparr
la source
1

Le rhume

Il vous infecte presque immédiatement et vous allez le répandre. Basé sur le parasite de PhiNotPi, le test à froid classique vérifie presque immédiatement s’il peut copier son drapeau sur le vôtre. Bloque une valeur aléatoire s'il ne le peut pas. Se déplace un peu s'il n'y a pas d'adversaire.

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
suracteur
la source
1

Grippe

Ceci est étroitement basé sur le rhume (qui était basé sur mon parasite) avec une vitesse légèrement accrue.

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
la source
I look forward to seeing the sort of difference this will make. The #5 on line 5 will provoke an infinite loop though, and those #7's are also unlikely to be what you intended.
overactor
@overactor Thanks, those were errors created by adding in an extra line.
PhiNotPi
Do I ever know the pain.
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

This bot tries to randomly locate flags in enemy bots and replace them with friendly flags, turning away after detecting success. Inspired by Cancer bot.

Sparr
la source