Bienvenue dans Code Bots 2!

Vous avez appris votre leçon depuis les derniers codes bots. Vous avez essayé de trouver plus de façons d'adapter plus d'actions en moins de lignes, et maintenant vous l'avez enfin. Vous allez créer un code Bot piloté par les événements.

Votre bot doit comprendre 24 lignes. Chaque ligne suit l'un des deux formats:

Condition:Action

ou

Action

Votre bot a également suffisamment de stockage pour stocker 5 entiers nommés Apar le biais E. Un entier peut stocker des valeurs de 0 à 23.

Chaque tour, vous exécuterez la ligne C, sauf si l' une des conditions est vraie. Si c'est le cas, alors Ccontiendra alors le numéro de ligne du conditionnel qui est vrai, puis cette ligne sera exécutée. A la fin de chaque tour, Csera incrémenté.

Il y a les conditions disponibles:

1. Startn'est vrai qu'au premier tour. Vous devez avoir ceci dans votre code exactement une fois
2. BotAt(N) est vrai s'il y a un bot à l'emplacement défini par N
3. Equals(A,B) est vrai si A est égal à B. Ils peuvent être de types différents, si c'est le cas, ils ne seront pas égaux.
4. Modified(A)est vrai si a Aété copié lors du dernier tour. Adoit être un nom de variable, une ligne ou une condition
5. Any(C1,C2,...) est vrai si l'une des conditions est vraie
6. None(C1,C2,...) est vrai si aucune des conditions n'est vraie
7. All(C1,C2,...) est vrai si toutes les conditions sont remplies
8. Not(C)est vrai si C est faux. Cdoit être une condition.

Les variables peuvent être dans l'un des formats suivants. Les 9 premiers sont numériques et peuvent être utilisés chaque fois que N est utilisé dans cette page.

1. A, B, C, D,E
2. Un nombre de 0 à 23
3. This renverra le numéro de ligne sur lequel il se trouve actuellement
4. Add(N1,N2,...) renverra la somme de toutes les valeurs
5. Sub(N1,N2) renverra N1 moins N2
6. Mult(N1,N2,...) renverra le produit de toutes les valeurs
7. Div(N1,N2) renverra N1 divisé par N2
8. Mod(N1,N2) renverra N1 mod N2
9. OVar(N) acceptera un nom de variable et renverra la variable de l'adversaire
10. Line(N) renverra la Nième ligne dans votre code
11. Type(N) renverra le Nième type de ligne dans votre code (les types sont les noms des actions)
12. Cond(N) retournera l'état sur la Nième ligne
13. CondType(N) renverra le type de condition sur la Nième ligne (les types sont les noms des conditions)
14. OLine(N) renverra la Nième ligne dans le code de votre adversaire
15. OType(N) renverra le Nième type de ligne dans le code de votre adversaire
16. OCond(N) retournera la condition sur la Nième ligne
17. OCondType(N) renverra le type de condition sur la Nième ligne

Aet Bsont pour votre usage personnel, Cest utilisé pour déterminer la ligne à exécuter dans votre code et Dest utilisé comme une direction. Chaque valeur de fait Dréférence à une paire de carrés et de directions différente. Eproduit une valeur aléatoire à chaque fois. Det Esera initialisé à une valeur aléatoire, sinon 0.

La direction utilisée sera [North,East,South,West][D%4]. Votre adversaire est le bot du carré immédiat dans cette direction.

4 actions s'offrent à vous:

1. Movevous fera avancer d'un carré dans la Ddirection e. S'il y a un bot là-bas, vous ne bougerez pas.
2. Copy(A,B)copiera la variable Adans B. Bne peut pas être une valeur numérique, à l'exception d'un nom de variable. Aet Bne peut pas être de types différents. La copie d'une ligne ne copie pas la condition.
3. Flagne fait rien. Le bot avec le plus de drapeaux dans votre code obtiendra un point. Le bot avec le plus de points gagne.
4. If(C,L1,L2)exécutera la ligne L1si Cest vrai, sinon exécute L2. Cest une condition L1et L2doit être des lignes.

La grande image

50 exemplaires de chaque bot seront placés dans le monde. Votre objectif est de placer votre drapeau dans autant de robots que possible. Pour chaque bot qui a plus de votre type de drapeau que tout autre type de drapeau, vous obtenez un point.

Les bots seront placés comme suit:

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

Il y aura 10 matchs et les points seront calculés en moyenne pour tous les matchs, déterminant ainsi le vainqueur.

Notes annexes

Si plusieurs conditions s'appliquent, alors celle qui suit le plus immédiatement Startsera exécutée

Les bots seront serrés mais vous ne commencerez pas à voisiner un autre bot. (Ce sera techniquement le même format que les derniers CodeBots)

Comme ce défi n'a pas été affiché dans le bac à sable (pour donner à personne un avantage), je me réserve le droit de modifier les petits détails pour des raisons d'équité ou des capacités supplémentaires. De plus, s'il y a un bug dans le runner CodeBots, je le changerai, même si un bot dépendait de ce bug pour son succès. J'essaie d'être aussi juste que possible.

Les Ifinstructions récursives ne seront pas exécutées

Si votre bot fait moins de 24 lignes, les lignes restantes seront remplies de Flag

N'oubliez pas que lorsque vous copiez le vôtre C, cela Cest incrémenté à la fin de votre tour.

L'interpréteur CodeBots peut être trouvé ici . Il comprend un fichier .jar pour une exécution facile. Ajoutez simplement votre bot au dossier des bots

Les scores

1. 893,9 Borg
2. 1.3 LazyLioness
3. 0.9 Défenseur
4. 0,5 Flagger
5. 0.4 CliqueBot
6. 0.4 Insidieux
7. 0.3 Attaquant
8. 0,3 Gard
9. 0.3 SingleTarget
10. 0.2 FreezeBot
11. 0,2 Sentinelle
12. 0.2 Driveby
13. 0.0 Anti-insidieux
14. 0.0 MoveBot
15. 0.0 CliqueBorg
16. 0.0 Calculatrice
17. 0.0 TestBot
18. 0,0 Imitateur

METTRE À JOUR

Les lignes de code sont désormais tournées lorsque vous affichez le code de votre adversaire. Cela signifie que la ligne 1 de votre adversaire peut être la ligne 14 (ou n'importe quelle ligne). Un bot aura un décalage fixe qui compensera ses lignes en Xmontant lorsqu'il sera vu par un adversaire . La Cvariable de l'adversaire sera également compensée du même Xmontant. Xne changera pas dans le même jeu, mais il changera d'un jeu à l'autre.

Borg

Convertit tous les autres robots en clones de lui-même. La résistance est futile.

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

Edit: petite correction pour réinitialiser A si l'adversaire bouge avant que j'en ai fini avec lui. Ça ne semble pas affecter le score mais ça me fait me sentir mieux.

Edit # 2: Ajout d'une vérification plus complète pour s'assurer que le processus de clonage s'est correctement terminé (ligne 3)

Édition n ° 3: mise à jour pour gérer les nouveaux décalages aléatoires. La difficulté ici était que les nouveaux clones auraient leur code situé à des décalages aléatoires, ce qui signifie qu'ils ne connaissent pas l'emplacement de leurs propres lignes. Cela signifie que toutes les références à mes propres lignes doivent être relatives (à This). Les numéros de ligne opposés peuvent toujours être absolus car ils sont de toute façon aléatoires.

Flagger

Viser la lune

Start:Flag

Et le reste est automatiquement rempli de drapeau.

Calculatrice

Ce bot ne comprend pas le but de ce défi, il a donc décidé de calculer quelques chiffres pour l'ennemi.

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

CliqueBot

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

Reconnaît les amis via leur Bvaleur, remplit les lignes de tous les autres avec des drapeaux. Va également un peu de temps pour préserver l'intégrité de l'un de ses propres drapeaux (cette partie est mignonne mais probablement pas très utile).

Edit: Sans surprise, il semble y avoir un bug ici quelque part, à en juger par le score.

Je soupçonne que les lignes sont indexées 0 et mon code est indexé 1. J'aurais vraiment dû vérifier cela plus tôt. Ajout d'un drapeau au début pour tout remonter.

Défenseur

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

MoveBot

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

Attaquant

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

Seule cible

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

Vous traquera et vous remplira de drapeaux!

Insidieux

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

Idée similaire au bot du même nom lors du concours précédent. Déplacez-vous jusqu'à ce que j'atteigne un autre bot, puis figez-le dans une boucle en écrasant son propre code avec mes drapeaux. Cette fois, les bots infectés écrasent des lignes aléatoires au lieu de lignes séquentielles, ce qui rend le processus d'infection un peu moins efficace mais beaucoup plus rapide.

Gard

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

Attaque n'importe quel robot à côté.

Freeze Bot

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

Vous piège dans une boucle Incriminant votre propre Avariable, puis vous remplit de drapeaux et passe à la prochaine victime.

Imitateur

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

Prédit ce que vous feriez, puis le fait.

Lionne paresseuse

À l'origine juste "Lionne", ma première soumission au concours a valu le titre de "paresseux" en ne faisant littéralement rien lors de son introduction dans le simulateur.

Sa léthargie est en fait due à un bug (ou peut-être à ma mauvaise compréhension du modèle d'événement) dans lequel les conditions dans les trois premières lignes (un simple contrôle de parité pour s'assurer que les drapeaux ne sont pas écrasés) évaluent occasionnellement, inexplicablement true, verrouillant leo dans une boucle lemniscate . Plusieurs autres conditions (en particulier celles qui dépendent de la BotAt()condition) évaluent également trueà des moments où aucun bot adjacent n'est présent. Enfin, Moveet les Copydirectives sont clairement ignorées lorsque le simulateur pas à pas dans. Étant donné que mes chaînes logiques conditionnelles sont quelque peu épiques, il y a beaucoup de place pour les bogues dans mon code et dans le simulateur. ;)

Dans tous les cas, je soumets Lazy Lioness comme cas de test pour le diagnostic d'erreur ou le débogage du simulateur, ce qui, espérons-le, conduira à l'émergence d'une lionne pas si paresseuse que je pourrai ensuite simuler et affiner comme ma première soumission de bonne foi aux Bots compétition v2.

Ça ne fait rien

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

sentinelle

amélioration Gard. Frappe les bots à proximité avec des drapeaux sur les 8 premières lignes. (c'est-à-dire tous les plus utilisés)

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

CliqueBorg

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

Essayer de combiner la technologie CliqueBot et Borg pour créer un bot qui reconnaît des copies de lui-même malgré le décalage de ligne. Il commence également son processus de copie sur la dernière ligne de code exécutée sur le bot opposé, plutôt que sur la ligne 0, ce qui est plus susceptible de le geler en place mais également plus susceptible de conduire à une copie corrompue (en fait, je ne suis pas ça marche même, je ne l'ai pas testé et c'est assez complexe).

Conduit par

Un dernier essai avant la date limite.

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