BrainF *** edBotsForBattling - Un tournoi Brainf ***


88

Tous les robots de l'arène de combat ont soudainement été pris au piège et personne ne peut expliquer pourquoi. Mais peu importe, tant qu'ils sont encore capables de se battre - même si Brainfuck est la seule langue qu'ils comprennent maintenant.


Cela fait un moment depuis la dernière soumission alors je vais enfin annoncer le gagnant de BrainFuckedBotsForBattling: Félicitations à LymiaAluysia pour sa victoire avec NyurokiMagicalFantasy!


Tableau de bord

|       Owner        |          Bot            Score |
|--------------------|-------------------------------|
| LymiaAluysia       | NyurokiMagicalFantasy -  600  |
| Sylwester          | LethalLokeV2.1        -  585  |
| weston             | MickeyV4              -  584  |
| Sp3000             | YandereBot            -  538  |
| Comintern          | CounterPunch          -  512  |
| Sylwester          | BurlyBalderV3         -  507  |
| LymiaAluysia       | NestDarwin            -  493  |
| IstvanChung        | Bigger                -  493  |
| Manu               | DecoyMaster           -  489  |
| archaephyrryx      | Wut                   -  478  |
| DLosc              | LightfootPlodder      -  475  |
| archaephyrryx      | 99BottlesOfBats       -  461  |
| Sylwester          | TerribleThorV2        -  458  |
| MikaLammi          | WallE2.0              -  443  |
| Mikescher          | MultiVAC              -  441  |
| archaephyrryx      | Twitcher              -  439  |
| Timtech            | MetalDetector         -  438  |
| AndoDaan           | BeatYouMate           -  433  |
| csarchon           | TheWallmaster         -  427  |
| Sparr              | SeeSawRush            -  412  |
| archaephyrryx      | Stitcher              -  406  |
| PhiNotPi           | RandomOscillator      -  403  |
| ccarton            | AnybodyThere          -  398  |
| Comintern          | 2BotsOneCup           -  392  |
| kaine              | SternBot              -  387  |
| PhiNotPi           | EvoBot2               -  385  |
| PhiNotPi           | EvoBot1               -  381  |
| Brilliand          | TimedAttack           -  373  |
| Sylwester          | ReluctantRanV2        -  373  |
| AndoDaan           | PrimesAndWonders      -  359  |
| Nax                | TruthBot              -  357  |
| DLosc              | Plodder               -  356  |
| weston             | FastTrapClearBot      -  345  |
| MikaLammi          | PolarBearMkII         -  340  |
| Sp3000             | ParanoidBot           -  336  |
| Moop               | Alternator            -  319  |
| TestBot            | FastClearBot          -  302  |
| icedvariables      | PyBot                 -  293  |
| TestBot            | DecoyBot              -  293  |
| kaine              | BestOffense           -  291  |
| Geobits            | Backtracker           -  289  |
| bornSwift          | ScribeBot             -  280  |
| IngoBuerk          | Geronimo              -  268  |
| flawr              | CropCircleBot         -  239  |
| plannapus          | CleanUpOnAisleSix     -  233  |
| frederick          | ConBot                -  230  |
| frederick          | 128Bot                -  222  |
| AndoDaan           | EndTitled             -  219  |
| PhiNotPi           | CloakingDeviceBot     -  215  |
| AndoDaan           | GetOffMate            -  206  |
| DLosc              | ScaredyBot            -  205  |
| isaacg             | CleverAndDetermined   -  202  |
| PhiNotPi           | CantTouchThis         -  202  |
| Moop               | StubbornBot           -  174  |
| Cruncher           | StallBot              -  168  |
| IngoBuerk          | Gambler               -  157  |
| BetaDecay          | RussianRoulette       -  129  |
| flawr              | DoNothingBot          -  123  |
| SebastianLamerichs | Dumbot                -  115  |
| mmphilips          | PacifistBot           -  112  |
| SeanD              | DontUnderstand        -  92   |
| proudHaskeller     | PatientBot            -  83   |
| frederick          | Dumberbot             -  70   |
| flawr              | MetaJSRandomBot       -  68   |
| Darkgamma          | TheRetard             -  61   |
| BetaDecay          | Roomba                -  61   |
| BetaDecay          | PrussianRoulette      -  31   |
| frederick          | Dumbestbot            -  0    |

Résultats finaux du 09.10.2014

EDIT6 : Journaux supprimés en raison de leur taille et de leur temps d'exécution extrêmes. Vous pouvez les générer vous-même en décommentant les lignes RunThisTournament.py.

EDIT5 : Gestion des abréviations implémentée dans le contrôleur, plus de temps d'exécution énorme. Cela a pour effet secondaire que les nombres et les parenthèses ne sont plus traités comme des commentaires. Vous pouvez toujours les utiliser si vous souhaitez fournir une version annotée, mais il serait très utile qu'il existe également une version non commentée de votre code . Je n'ai donc pas besoin de supprimer les commentaires manuellement. Merci!

EDIT4 : Changement du titre, car le tournoi a été retiré des questions brûlantes du réseau. Merci à @Geobits pour l'avoir signalé!

EDIT3 : Les commentaires supprimés dans les programmes bf, dus à un résultat inattendu, devraient être corrigés maintenant. Si quelqu'un a un problème avec la suppression de ses commentaires, veuillez le signaler.

EDIT2 : Puisqu'il a provoqué une exécution arcanique sur mon ordinateur très lent, j'ai réduit la limite de délai d'attente de 100 000 cycles à 10 000 cycles. Ce n’est pas que quiconque ait tourné le résultat d’un jeu en cours au-delà de ce point de toute façon.

EDIT1 : Correction d'un bug dans le script de conversion empêchant l'interprète d'ignorer les nombres dans les programmes commentés.


La description

Il s’agit d’un tournoi Brainfuck inspiré par BF Joust . Deux robots (programmes Brainfuck) se battent dans une arène représentée par une bande mémoire. Chaque cellule peut contenir des valeurs comprises entre -127 et 128 et être renvoyées à leurs limites (donc 128 + 1 = -127).

Les instructions valides sont similaires à Brainfuck ordinaire, ce qui signifie:

+ : Increment cell at your pointer's location by 1
- : Decrement cell at your pointer's location by 1
> : Move your memory pointer by 1 cell towards the enemy flag
< : Move your memory pointer by 1 cell away from the enemy flag
[ : Jump behind the matching ']'-bracket if the cell at your pointer's location equals 0
] : Jump behind the matching '['-bracket if the cell at your pointer's location is not 0
. : Do nothing

L’arène a une taille de 10 à 30 cellules qui est choisie de manière pseudo-aléatoire à chaque bataille. Aux deux extrémités se trouve un "drapeau" qui a une valeur initiale de 128, alors que toutes les autres cellules sont mises à zéro. Le but de votre bot est de mettre le drapeau de l'ennemi à zéro pendant 2 cycles consécutifs avant qu'il ne zéros votre drapeau.

Chaque bot commence à son propre drapeau, qui est la cellule [0] de son propre point de vue. L'adversaire est situé de l'autre côté de la bande.

[ 128 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 128 ]
   ^                                             ^
my bot                                       other bot

Les deux robots exécutent leur action simultanément, ceci est considéré comme un cycle. Le jeu se termine après 10000 cycles ou dès que l’une des conditions gagnantes est atteinte. Si l'un des programmes arrive à son terme, il cesse tout simplement de faire son travail jusqu'à la fin du jeu, mais peut toujours gagner.


Conditions gagnantes

Votre bot gagne dans l'une des conditions suivantes:

  • Le drapeau de votre ennemi est mis à zéro avant le vôtre
  • Votre ennemi déplace son pointeur hors de la bande (s'exécute >sur votre drapeau ou <sur le sien)
  • La valeur de votre drapeau est plus éloignée de 0 que la valeur du drapeau de votre adversaire après 10000 cycles

Règles

Votre message doit contenir un nom pour votre bot et son code.

  • Vous pouvez utiliser la syntaxe d'abréviation suivante pour rendre votre code plus lisible:
    • Par exemple, (+)*4est identique à ++++, ceci est valable pour toute instruction, à l' exception des crochets non appariés entre parenthèses, car la logique de la boucle entre en conflit avec la logique de l'abréviation. S'il vous plaît utiliser [-[-[-au lieu de([-)*3
  • Tout autre caractère qu'un +-><[].commentaire est donc ignoré, à l'exception ()*des abréviations.

Les bots qui ne suivent pas les règles seront exclus du tournoi.

  • Seul le brainfuck de base est autorisé, aucune autre variante prenant en charge des procédures ou des opérations arithmétiques
  • Le code source de votre bot ne doit pas contenir de crochets incomparables

Vous pouvez vous informer sur les stratégies de base, mais n'utilisez pas le code de quelqu'un d'autre pour votre propre bot.


Notation

Le score d'un bot est déterminé par le nombre de victoires contre tous les autres robots. Une rencontre entre deux robots consiste en 10 correspondances avec différentes longueurs de bande mémoire, ce qui donne un score maximum de 10 points par rencontre. Un match nul ne donne aucun point pour ce match.


Programme de contrôle

Vous pouvez trouver le programme de contrôle sur github, ainsi que les journaux complets des batailles. Le classement sera affiché ici une fois généré.

N'hésitez pas à cloner le référentiel et essayez vous-même votre bot contre les autres. Utilisez python Arena.py yourbot.bf otherbot.bfpour exécuter une correspondance. Vous pouvez modifier les conditions avec les indicateurs de ligne de commande -met -t. Si votre terminal ne prend pas en charge les séquences d'échappement ANSI, utilisez l' --no-colorindicateur pour désactiver la sortie en couleur.


Exemple de robots

FastClearBot.bf

(>)*9       Since the tape length is at least 10, the first 9 cells can be easily ignored
([          Find a non-zero cell
+++         Increment at first, since it could be a decoy
[-]         Set the cell to zero
]>          Move on to the next cell
)*21        Repeat this 21 times

DecoyBot.bf

>(+)*10     Set up a large defense in front of your flag
>(-)*10     Set up another one with different polarity
(>+>-)*3    Create some small decoys
(>[-]       Move on and set the next cell to zero
.           Wait one round, in case it is the enemy's flag
)*21        Repeat this 21 times

Le DecoyBot remportera chaque match avec une longueur de bande supérieure à dix, étant donné que le FastClearBot peut éviter les petits leurres, mais pas les plus grands. La seule situation dans laquelle le FastClearBot peut gagner contre DecoyBot, c'est quand il est assez rapide pour atteindre le drapeau de l'ennemi avant que son adversaire ait construit de grands leurres.


5
Original, j'aime bien. Je crains simplement que cela ne permette pas une profondeur stratégique suffisante, mais ce n'est peut-être que moi.
mardi

11
Ce serait encore plus amusant avec Befunge .
IchBinKeinBaum

6
J'ai trouvé une page Web de BF Jousting qui permet d'exécuter et de visualiser des matchs de joutes.
PhiNotPi

4
Merci d'avoir hébergé ce KOTH, Cipher. Cela doit faire beaucoup de travail avec autant de soumissions.
AndoDaan

3
Je préférerais remercier tous ceux qui participent encore ^^
Cipher le

Réponses:


18

Nyuroki Fantasy Magique

Je pense qu'il est temps de devenir sérieux ~ J'ai fini mon compilateur pour un peu de HLL pour faciliter l'écriture de programmes BF Joust. Ce fut ma première tentative sérieuse de faire quelque chose avec elle. Le concept du bot est assez simple. Il installe quelques leurres de différentes polarités, puis devient fou avec une grande manœuvre dégagée avec un décalage inversé dégagé au centre.

Oh, au fait, le résultat attendu est d'environ 577 points contre la colline du dernier tour. C'est un taux de victoire de 93%. <3

Compilé | Code source

Nyuroki Magical Fantasy by Lymia Aluysia
Released under the terms of MIT license

>>>>>>>>++<--<+<--<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+<-------------------------------------------------------------<---------------
----------------------------------------------<++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++<(-)*19(>)*8(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-
[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[
+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-
[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[
-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3
+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[
-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>
[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[
-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*
82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(
-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[
+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+
[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[
+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-
[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[
+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-
[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*
41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[
(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[
-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-
[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[
-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.]
.]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[
-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+
[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[
+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+
[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16
+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+
[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[
-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+
[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[
-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-
[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+
[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-
[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[
-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-
[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82
[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)
*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[
+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(+)*16+[+[+[+
[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[+[+[+[+[+[+[
+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--(>[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[-[-[-[-[-[(
+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+[+[+[+[+[+[
+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]-->[-[-[-[(+)*3+[+[+[(-)*6-[-[-[-[-[
-[-[-[-[-[(+)*16+[+[+[+[+[+[+[+[(-)*24-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[(+)*41+
[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[(+)*82[[+.].]--]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]--)*2]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]--)*3]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]--)*4]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*5]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*6]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*7]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*8]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*9]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]--)*10]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]--)*11]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)
*12]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*13]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*14]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*15]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*16]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]]]]]]]]]]]--)*17]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]]]]]]]]]]]--)*18]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
]]]]]]--)*19]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*
20]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]--)*21

Edit : J'ai tiré quelques victoires supplémentaires de Nyuroki.

Edit 2 : Hey, regarde, je l'ai encore fait!

Edit 3 : Après avoir lutté pendant un moment avec un bug d'analyse syntaxique stupide dans Arena.py, j'ai enfin eu une autre amélioration dans ~ C'est ce que je veux dire par "le temps de devenir sérieux", vous savez. <3


On dirait que Loke a besoin de quelques ajustements :-) Aimez votre langage. Le bogue dans Arena.py était-il que vous aviez des espaces entre )et *ou entre *et nombre?
Sylwester

@ Sylwester Bien pire. Les boucles vont où ils ne devraient pas aller: github.com/redevined/brainfuck/pull/6
Lymia Aluysia

Félicitations avec # 1. Il sera difficile d'égaler le taux de victoire de 92,5%.
Sylwester

Bien fait, mais n'est-ce pas un abus de sténographie? Les boucles imbriquées sont effectivement 21 factorielles = 5 * 10 ^ 19. En d'autres termes, il est impossible d'extraire la base d'un brainfuck.
weston le

1
@weston Oui. Et la plupart des programmes sur la colline la plus développée de BF Joust ( codu.org/eso/bfjoust/in_egobot - jetez un coup d'œil à smartlock, par exemple) sont encore pires. Ce n’est pas particulièrement grave, car c’est un peu la sténographie. Cela rend viables des stratégies qui ne seraient pas viables autrement, en raison de leur longueur. :)
Lymia Aluysia

43

Cloaking Device Bot

Ce bot essaie essentiellement de cacher sa base, ce qui permet aux autres robots de passer au-delà de la bande.

(-)*127(-+--+-++)*12500

4
Très intelligent, a dû ajuster mon bot pour tenir compte de cela.
Moop

2
C’est l’un des plus intelligents d’ici, à mon avis.
Almo

+ f pour le premier cloaker. Je n'avais pas remarqué celui-ci avant de faire Ràn mais c'est une idée similaire, une application différente.
Sylwester

19

Burly Balder v3

Burly Balder est une course lente et moyenne. Il fait deux grands leurres avant de passer en mode urgent. En mode pressé, la boucle utilise seulement 4 étapes pour chaque cellule zéro et pour les cellules non nulles, elle a une analyse de cas pour [-18,18] avant de réduire aveuglément avec 107 avant d'effacer avec [-.]. Il efface un drapeau inchangé en 242 étapes, 114 de plus qu'un incertain -*128 et 14 de moins qu'un [-]clair naïf . Lorsqu'une cellule est libérée, il continue de laisser une traînée de -2 leurres. Il a un cas spécial uniquement pour l'index 9 pour enregistrer quelques étapes pour les jeux de taille 10 et il quitte la cellule avec un leurre.

>((-)*18>)*2                                  Make two minus seventeen decoys
(->)*6                                        Move to cell nine

[                                             special case for ten cell game 
   +[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[       if not minus one to minus eighteen 
   (-)*18                                     decrease by eighteen
   -[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[       if not plus one to plus eighteen
       (-)*107                                decrease by hundred and seven
       [-.]                                   slow clear
   ]]]]]]]]]]]]]]]]]]                         end plus conditionals
   ]]]]]]]]]]]]]]]]]]                         end minus conditionals
]                                             end special case
+
([>                                           while true go right
  [                                           start clear cell 
   +[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+[       if not minus one to minus eighteen 
   (-)*18                                     decrease by eighteen
   -[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[-[       if not plus one to plus eighteen
       (-)*107                                decrease by hundred and seven
       [-.]                                   slow clear
   ]]]]]]]]]]]]]]]]]]                         end plus conditionals
   ]]]]]]]]]]]]]]]]]]                         end minus conditionals
  ]                                           end clear cell
  --                                          set to minus two 
 ]                                            while true end
 -                                           decrease and loop
)*5                                          In case of clash or initial column minus seven is zero

Anecdote: Balder est un dieu nordique et fils d'Odin. Il est surtout connu pour l’ histoire de sa mort : il craignait pour sa sécurité, alors les autres dieux ont essayé de prévoir et de se protéger de toute menace. Il a finalement été tué par Loki car, alors qu'ils le protégeaient contre des épées et des flèches, ils avaient oublié de le protéger contre le gui.


2
Vos leurres me tuent. Bien joué.
AndoDaan

1
@ AndoDaan Merci. Votre BeatYouMateétait intelligent. Je crains que les leurres sur la plupart des robots ne deviennent encore plus gros au prochain tour jusqu'à ce qu'il y ait une pénalité. Ensuite, nous aurons peut-être d'autres stratégies plus cool qui émergent :)
Sylwester

2
Le problème avec l’augmentation de la taille du leurre est qu’il opte pour des performances de bandes plus courtes contre des robots d’attaque rapides. Avec 10 tours aléatoires, il y a plus de chances que le point favorable change en fonction de la rapidité avec laquelle les autres entrées attaquent.
Komintern

2
Oui, vous êtes toujours le seul à battre.
AndoDaan

4
@AndoDaan Avec autant de dieux nordiques qui me soutiennent, la taille aléatoire de l'aréna semble être en ma faveur :-)
Sylwester

13

EvoBot 1

C'est un bot simple créé via un algorithme génétique. J'ai commencé avec un modèle et mon programme a lentement ajusté les chiffres pour créer un meilleur warrior-bot. Le code ci-dessous a été modifié pour améliorer la lisibilité.

>+>---(>)*6(>[+++[-]])*30

J'ai utilisé les autres inscriptions au concours pour mesurer la condition physique des différents candidats.

Comme il s’agissait de ma première tentative d’evobot, j’ai commencé avec un modèle simple:

>(+)*n>(-)*n(>)*n(>[(+)*n[-]])*30  #template

Je prédis que ce bot recevra un score allant de 50 à 60 ans.

Je travaille actuellement sur un modèle de leurre inversé.

EvoBot 2

Ceci est un bot créé par le même algorithme génétique, mais avec le modèle suivant:

>>>>(-)*n<(+)*n<(-)*n<(+)*n(>)*8(>[+++[-]])*30  #template

Ce bot utilise la stratégie de leurre inverse pour définir 4 leurres de hauteur variable. Le bot résultant est:

>>>>(-)*4<(+)*6<(-)*7<(+)*8(>)*8(>[+++[-]])*30

Je m'attends à ce que ce nouveau robot réussisse mieux que les précédents, gagnant probablement un score dans les années 70 (probablement beaucoup plus élevé que cela car il y a beaucoup de nouvelles entrées).


2
+1 pour les algorithmes génétiques. J'ai une grande confiance en eux. J'espère que vos robots vont bien.
AndoDaan

12

Alternateur

Cela suppose que la plupart des gens mettent à zéro une cellule en y ajoutant ou en lui soustrayant, de sorte qu'en moyenne, chaque cellule prend 128 tours à zéro.

(>+>-)*4>+(>[-][.])*21

Version annotée

(>+>-)*4       Move eight squares alternating polarity    
>+             Move one more
(
    >          Move to the next square
    [-]        Zero it
    [.]        Wait while it is zero
)*21           Repeat

Bon sang, vos dernières modifications augmentent le taux de victoire pour Alternator contre Geronimo de ~ 60% à ~ 90%. Agréable.
Ingo Bürk

Ouais, je me déplaçais 18 fois quand je l'ai fait (> +> -) * 9, donc ça tomberait de la bande. Erreur stupide.
Moop

Même protéger Geronimo en ajoutant / soustrayant en alternance la cellule à zéro ne modifie en rien mon taux de gain. L’alternateur pourrait être le gagnant ici. Il utilise peu de cylindres pour installer un piège assez difficile à craquer.
Ingo Bürk

Hé, corrigez-moi si je me trompe, mais ce bot ne disparaît-il pas automatiquement du conseil si le conseil est long de 10? Il se déplace de 10 cases avant d'essayer de mettre rien à zéro.
Réintégrer Monica

11

Donc, quelqu'un d'autre ici utilise un algorithme génétique pour essayer de créer des programmes ici. Eh bien ... il y a longtemps, j'ai écrit un BF Joust evolver pour une colline en cours dans un canal IRC. J'ai décidé de donner un tour pour ce concours aussi ~

Et… contrairement à l'autre personne ayant un évolutif, mon évolutif peut en fait modifier davantage le programme plus que de compter des fois. :)

NestDarwin (génération 309)

C’est le meilleur résultat que mon évolution ait obtenu jusqu’à présent. Je ne suis pas sûr de l'utilité de la structure imbriquée dans ce cas, mais, de telles structures étaient ce que le système d'évolution est censé pouvoir faire. La performance attendue sur la colline du 27.08.2014 est de 474 points. (Calculé en lançant la bataille sur les 21 longueurs de bande et en multipliant par 10/21. Notez que cela n'est pas normalisé car cette colline a un programme supplémentaire.)

(-)*5(>[(-)*4----[.+]]--((-)*5(>[(-)*4----[.+]]--((-)*5(>[(-)*4----[.+]]--((-)*5(>[(-)*4----[.+]]--)*10000)*10000)*10000)*10000)*10000)*10000)*10000

EDIT : Modification de la liste des programmes que je veux entrer dans cette colline. A évolué durant la nuit. :)


EDIT 2 : Je suis allé analyser manuellement la sortie de evolver. Malgré une apparence très différente, NestDarwin est fondamentalement une version optimisée de TinyDarwin ... Réduite manuellement (avec une fonctionnalité identique) et analysée:

(-)*5                     Break stuff that assumes flag size.
(>[(-)*8[.+]](-)*7)*3     Make a few larger decoys next to our flag. 
                          The clear loop is basically dead code here.
                          Few things are going to approach so fast, so.
(>[(-)*8[.+]](-)*2)*10000 And go on an rampage with an offset clear!
                          I presume the slow clear is to beat tripwires.

Ainsi, un programme presque identique serait comme suit ... qui est fondamentalement une version super optimisée de TinyDarwin.

(-)*5(>.(-)*7)*3(>[(-)*8[.+]](-)*2)*10000

TinyDarwin était comme suit. Pas très différent, hun? Je vais juste le retirer de la colline. Je pensais que c'était distinct, mais ... eh bien, j'avais tort.

((-)*5>[(-)*4.[+.]].)*10000

Il est devenu évident que la colline actuelle n'est pas assez forte pour lui permettre d'évoluer des choses beaucoup plus complexes. :(


1
Félicitations à la première place. Est-ce que le programme d'algo génétique est capable d'utiliser votre version actuelle comme modèle et de continuer avec les nouvelles versions pour l'améliorer encore?
Sylwester

Excellent travail avec la première place. Je suis tellement heureux qu'un algorithme génétique (enfin, son apparition) l'a fait là-haut!
AndoDaan

Maintenant, si nous pouvions prendre les résultats de tous les jeux, évoluer davantage, ajouter un peu d'apprentissage automatique ... alors nous, humains pitoyables
n'aurons

@ Sylwester En quelque sorte? Ma représentation interne utilise un système d'activation de gènes (mal pensé) qui est censé permettre à la superstructure d'évoluer (et en pratique, pas vraiment). Je ne peux pas remettre le programme final et récupérer la représentation interne, mais je peux mettre les instructions dans un seul gène et le laisser continuer à évoluer (même si cela peut aider).
Lymia Aluysia

@ Sp3000 Malheureusement, mon algorithme peut à peine progresser sur la colline #esoteric bien développée. Ce serait bien si je pouvais faire une telle chose, mais, hélas, mes compétences en algorithmes génétiques ne suffisent tout simplement pas. Je publierai probablement mon évolutif un jour où j'aurai nettoyé tous mes horribles bidouilles.
Lymia Aluysia

10

Ours polaire mk ii

Il existe deux types d' ours polaires : ceux qui se font piéger et ceux qui attrapent les autres.

Essaie de deviner la polarité de l'adversaire puis utilise cette information pour verrouiller l'adversaire dans une boucle infinie. Fonctionne bien contre les stratégies de nettoyage simples et un peu au hasard contre les autres. Les pièges peuvent être facilement évités, je pourrais donc ajouter des stratégies de sauvegarde plus tard.

>++>- create polar bear traps
[[]]<
[][
[[]]<
(+)*290 (>)*9  (+)*120 (.+)*16 (<)*9
(+)*112 (>)*10 (+)*120 (.+)*16 (<)*10
(+)*112 (>)*11 (+)*120 (.+)*16 (<)*11
(+)*112 (>)*12 (+)*120 (.+)*16 (<)*12
(+)*111 (>)*13 (+)*120 (.+)*16 (<)*13
(+)*111 (>)*14 (+)*120 (.+)*16 (<)*14
(+)*111 (>)*15 (+)*120 (.+)*16 (<)*15
(+)*110 (>)*16 (+)*120 (.+)*16 (<)*16
(+)*110 (>)*17 (+)*120 (.+)*16 (<)*17
(+)*110 (>)*18 (+)*120 (.+)*16 (<)*18
(+)*109 (>)*19 (+)*120 (.+)*16 (<)*19
(+)*109 (>)*20 (+)*120 (.+)*16 (<)*20
(+)*109 (>)*21 (+)*120 (.+)*16 (<)*21
(+)*108 (>)*22 (+)*120 (.+)*16 (<)*22
(+)*108 (>)*23 (+)*120 (.+)*16 (<)*23
(+)*108 (>)*24 (+)*120 (.+)*16 (<)*24
(+)*107 (>)*25 (+)*120 (.+)*16 (<)*25
(+)*107 (>)*26 (+)*120 (.+)*16 (<)*26
(+)*107 (>)*27 (+)*120 (.+)*16 (<)*27
(+)*106 (>)*28 (+)*120 (.+)*16 (<)*28
(+)*106 (>)*29 (+)*120 (.+)*16 (<)*29
(+)*106 (>)*29 [-]
]<
(-)*290 (>)*9  (+)*120 (.+)*16 (<)*9
(-)*112 (>)*10 (+)*120 (.+)*16 (<)*10
(-)*112 (>)*11 (+)*120 (.+)*16 (<)*11
(-)*112 (>)*12 (+)*120 (.+)*16 (<)*12
(-)*111 (>)*13 (+)*120 (.+)*16 (<)*13
(-)*111 (>)*14 (+)*120 (.+)*16 (<)*14
(-)*111 (>)*15 (+)*120 (.+)*16 (<)*15
(-)*110 (>)*16 (+)*120 (.+)*16 (<)*16
(-)*110 (>)*17 (+)*120 (.+)*16 (<)*17
(-)*110 (>)*18 (+)*120 (.+)*16 (<)*18
(-)*109 (>)*19 (+)*120 (.+)*16 (<)*19
(-)*109 (>)*20 (+)*120 (.+)*16 (<)*20
(-)*109 (>)*21 (+)*120 (.+)*16 (<)*21
(-)*108 (>)*22 (+)*120 (.+)*16 (<)*22
(-)*108 (>)*23 (+)*120 (.+)*16 (<)*23
(-)*108 (>)*24 (+)*120 (.+)*16 (<)*24
(-)*107 (>)*25 (+)*120 (.+)*16 (<)*25
(-)*107 (>)*26 (+)*120 (.+)*16 (<)*26
(-)*107 (>)*27 (+)*120 (.+)*16 (<)*27
(-)*106 (>)*28 (+)*120 (.+)*16 (<)*28
(-)*106 (>)*29 (+)*120 (.+)*16 (<)*29
(-)*106 (>)*29 [-]

Vous pouvez réduire de moitié la taille du code avec (]< (+)*290 (>)*9 ... [-])*2?
Sylwester

@ Sylwester Je ne peux pas parce que l'autre moitié utilise +et l'autre utilise -.
Mika Lammi

Polar Bear ne fait pas très bien avec les compensations compensées ... génial idée cependant
Sp3000

@ Sp3000 Êtes-vous sûr? J'ai essayé avec plusieurs décalages et polarités (comme [(+)*3[-]], [(-)*6[+]]) et cela fonctionne très bien (au moins pour les assez petits décalages).
Mika Lammi

Oh, je sais ce qui ne va pas: / J'essayais des programmes tels >>>>>>>>>((-)*4[+][--.]>)*21que le double contrôle de la cellule et le (+/-)*290fait que la deuxième boucle se déclenche. Ce n'est pas la faute de Clear Clear.
Sp3000

10

Bot pacifiste

Mon bot croit que la violence n’est jamais la solution et essaiera d’éviter le combat à tout prix.

(.)*8       Since it takes at least 9 turns for a bot to come to mine, remain idle for 8
>           Skedaddle over one spot
([(>)*8     If a bot has approached, RUN
[(<)*8      If you accidentally ran into a bot, run the other way this time
]].         If it's safe here, chill out
)*6249      keep running until the end of battle, or until tired

8
J'ai pris la liberté de supprimer les "." Dans vos commentaires car ils seraient considérés comme du code Brainfuck et rendraient votre bot un peu plus lent que nécessaire. Si les points sont délibérés, n'hésitez pas à me corriger!
Chiffre

Oh oui, les. Étaient plutôt stupides de ma part, merci de les supprimer: p
mmphilips

9

Il y a quelqu'un?

Regarde périodiquement en arrière pour déterminer quand l'ennemi a commencé à éliminer ses leurres, puis se précipite vers l'avant.

Cela semble bien se passer, mais je ne suis pas sûr que ce soit à cause de la stratégie ou tout simplement parce que j'ajoute 10 par cellule avant la suppression.

Edit: Correction d'un problème de logique. Première fois en écrivant un programme brainfuck. Il est à la hauteur de son nom.

>>>+<(+)*5<(-)*5>>             Initial defense
[                              While he hasn't passed us yet
  (>[([(+)*10[-]]>)*29])*4     Jump ahead four, checking for enemy
  +                            Front marker
  <<<<                         Check behind
  [                            If he hasn't passed us yet
    >>>
    (+)*5<(-)*5                Set decoys in reverse
    <<[-]                  
  ]
  >>>>                         Check ahead
]                              
([-[(+)*10[-]]]>)*29           Clear to the end

+1: C'est le premier bot que j'ai vu qui leurre des chaînes (autres que +/- 1) au-delà des 9 premières cellules. Sur de plus longues bandes, c'est un tueur. Rénovation de Lightfoot Plodder un peu plus maintenant ...
DLosc

9

WALL-E 2.0

Se précipite à l'emplacement 9 et en ajoute 128, gagnant rapidement dans l'arène de taille 10 si l'adversaire n'a pas changé la valeur initiale du drapeau. Sur les grandes arènes, cela fonctionne comme un grand leurre. Après cela, il remplit l'espace entre l'emplacement 9 et son propre drapeau avec de grands leurres. Une fois les leurres placés, il recherche les emplacements non vides et tente de les effacer rapidement.

La version 2.0 construit des leurres plus grands et a une certaine tolérance à l'égard de la modification de la valeur d'indicateur initiale. Il peut également basculer vers une stratégie de sauvegarde si les choses commencent à paraître compliquées.

(>)*9
(+)*128 <
< [ (<)*7 ((-+-)*256)*15 ] > [ (<)*8 ((+-+)*256)*15 ]
(-)*47 < (+)*63 < (-)*72 < (+)*69 <
(-)*84 < (+)*66 < (-)*76 < (+)*66 <
++++ (>)*9 +.+.+.----.-.-. (>[-[++[(+)*124.+.+.+.+.+.+.+.+.>]]])*21

L’efficacité de ce bot repose sur deux faits:

  1. La plupart des robots ne changent pas la valeur initiale de leur drapeau.
  2. Construire de grands leurres est plus rapide que de les nettoyer.

Ces murs me tuent
Sp3000

9

Lethal Loke V2.1 (avec gui)

C’est bien sûr un bot mortel et il tue non seulement la belle Burly Balder à gui, mais gagne presque à chaque fois contre les autres bots. C'est une course rapide et moyenne combinée. Mon test me donne un score de 567

Fichier BFJ compilé pour le combat , source du générateur Racket BFJ:

#lang racket
;; bare minimum bfj support
(define (bf . args)
  (apply string-append 
         (map (lambda (x) 
                (if (number? x)
                    (number->string x)
                    x))
              args)))

(define (dup x num)  
  (let loop ((n num) (lst '()))
    (cond ((< n 0) (error "Negative n"))
          ((zero? n) (apply bf lst))
          (else (loop (sub1 n) (cons x lst))))))


;; Useful procedures
(define (wiggle amount default-zero n)
  (let rec ((n n))
    (if (zero? n)
        ""
        (bf "["
            (dup "-[" amount)
            (bf "(+)*" amount)
            (dup "+[" amount)
            default-zero
            ">"
            (rec (sub1 n))
            (dup "]" (* amount 2))
            "]"))))

(define (goto from to)
  (let* ((dst (- to from))
         (op (if (> dst 0) ">" "<"))
         (abs (if (> dst 0) dst (- dst))))
    (if (= from to) 
        ""
        (bf "(" op ")*" abs))))

(define max-position 30)
(define initial-decoy  "(-)*17")
(define small-decoy "(+)*10")
(define large-decoy "(-)*32")
(define flag-position 7)
(define decoy-phase-end-position 14)
(define wiggle-amount 8)
(define plodd-clear "..(+)*120(+.)*27>")
(define plodd-inner-clear (bf "(+)*" 
                              (- 78 wiggle-amount) 
                              "..(+)*42(+.)*27"))
;; Main body of Loke V2
(define (generate-loke2)
  (bf ">" 
      initial-decoy
      ">->+>->+>->"
      (let gen-rec ((n flag-position) (p #t))
        (if (> n decoy-phase-end-position)
            (bf (medium-slow n))
            (bf "[" 
                (medium-slow n)
                "]" 
                (if p small-decoy large-decoy)
                ">"
                (gen-rec (+ n 1) (not p)))))))

;; Retreat goes back to home
;; leaving a trail of flags
;; from flag position
(define (medium-slow last-index)
  (bf (goto last-index 2)
      (let medium-rec ((n 2) (p #f))
        (if (= n flag-position)
                (fast-rush n last-index)
            (bf (if p "-" "+")
                "[" (fast-rush n (max 9 last-index)) "]" 
                (if p small-decoy large-decoy)
                ">"
                (medium-rec (+ n 1) (not p)))))))

(define (fast-rush cur-position last-known)
  (bf (goto cur-position last-known)      
      "([" plodd-clear 
      "("
      (wiggle wiggle-amount
              plodd-inner-clear 
              (- max-position last-known 1))
      ">)*" (- max-position last-known)
      "]>)*" (- max-position last-known)))

(display (generate-loke2))

Anecdote : Loki (Loki) est un dieu de la mythologie nordique qui aime jouer avec tout le monde et le duper. Il change de forme (chez les animaux et les personnes) et va généralement de son côté. Dans les récits, il voyage souvent avec les autres dieux, les assiste, fait de petites astuces et fait bouger les choses. Outre le meurtre de Balder, il a engendré Hel (déesse de l'enfer / Helvete), la bête Fenrir et le serpent Midgard qui a lancé Ragnarok (armageddon nordique).

Comment ça fonctionne

Au début, il crée un leurre volumineux (-17), puis +-trace un motif jusqu’à l’indice 7. Il numérise en avant de 13 à 13, laissant une traînée de leurres (+ 10, -32) +, mais il détecte une série, il avorte. et lancez un mode précipité moyen * 1. Si aucune cellule n'est définie, il lancera également le mode lent * 3 Rush.

* 1 En mode accéléré, il a détecté une activité adverse dans l'un des index 7-13 et commence à partir de l'index 2. Certains adversaires laissent un zéro et d'autres une valeur différente. Il dispose désormais d'un moyen de détecter l'activité de l'adversaire avant de leurrer indice 2-6 (-32, + 10) +. Si la cellule n'est pas une valeur attendue (-1, 1) ou s'il a fini de créer tous les leurres, il passe en mode rapide * 2.

* 2 Il s'attend à ce que le mode de pointe rapide le détecte afin que les leurres ne fonctionnent pas. Nous espérons que ceux que nous avons définis arrêtent l’adversaire et se concentrent sur les leurres adversaires. Il commence à se précipiter au point le plus éloigné que nous connaissons d'après l'analyse précédente [9,14] ou l'index 9 si nous avons été créés plus tôt que cela. Il a un cas spécial pour le premier leurre où nous venons d’ajouter 120 et 27 car il ne veut pas ramener la valeur en dessous de zéro car c’est un piège, mais pour chaque leurre après avoir été dégagés à [-8,8] avant d’augmenter de 120 et 27 étapes pénibles avant de passer à la cellule suivante.

Le mode Rush lent a été supprimé car il n'affectait pas le score de la colline actuelle et rendait mon bot un peu plus petit (mais pas beaucoup).


3
Maintenant, nous commençons à voir la folie. Je l'aime.
Sp3000

@ Sp3000 YandereBotv2 était la raison pour laquelle j'avais besoin de penser en plus de simplement augmenter les valeurs d'attaque et de swing. Son centile de victoire contre le Hurd était supérieur à celui de tous les bots de la dernière ronde. Vous n’avez donc pas eu de chance avec la taille des arènes.
Sylwester

Ahaha peut-être - je pense que j'ai besoin d'un contre-plan contre les tailles de leurre toujours croissantes: / J'aime vraiment la façon dont vous avez différents modes
Sp3000

soupir . Je vais devoir améliorer mon HLL pour BF Joust pour que mon evolver puisse avoir encore une chance. Félicitations pour # 1 ~
Lymia Aluysia

@LymiaAluysia Merci. J'étais plus surpris de Balder. Je compte sur de nouvelles versions de NestDarwin, YandereBot et Mickey :-)
Sylwester

8

Geronimo

Est encore plus offensant que le bot BestOffense de kaine, car il ne crée aucune défense. La stratégie est la suivante: d’autres essaieront d’être intelligents, mais cela prend des cycles. Alors passons à la partie sur laquelle nous savons que l'ennemi est présent et effaçons tout ce que nous trouvons.

(>)*9(>[-])*21

Semble gagner le plus de matchs contre les exemples de bots du PO et le bot de Kaine.


7

SternBot

Un vrai robot à moitié sérieux maintenant que tout est commencé. Aborder la nature simulaire de certains de ces bots.

(>->+>)*3(>[+]>[-])*21

1
SternBot me donne des problèmes de parité :(
Sp3000

7

DoNothingBot

La meilleure défense (...) est l'ignorance.

.

Ça ne fait rien

EDIT: Wow, j'ai été étonné de voir qu'il faisait un meilleur travail que plus de 20% des bots au moins =) (Cela signifie-t-il qu'il utilise une stratégie supérieure ou ....?)


2
Certains des autres robots se suicident dans de petites arènes. par exemple. Le joueur va directement à la 20ème cellule et pour les matches avec 10-19, il perdra, même contreDoNothingBot
Sylwester

2
Juste par curiosité, j’ai passé cela à travers mon testeur (joue toutes les longueurs de bande) contre les autres entrées. Voyez le mur de la honte ... +1
Comintern

Haha, merci pour le partage - je m'attendais à ce qu'il y ait un ou deux moutons noirs mais je ne m'attendais pas à ce qu'il "défasse" tant de bots =)
flawr

7

CounterPunch - Édité

Combinaison équilibrée de la construction d'une défense solide et de l'attaque.

(+)*6>(-)*12(>)*7(<(-)*12<(+)*12)*3(>)*7(([-([(-)*6[+.]])*5])*4>)*21

Annoté:

(+)*6                             Switch polarity of the flag
>(-)*12                           Build a quick decoy in front of the flag
(>)*7(<(-)*12<(+)*12)*3           Hop out and start building decoys backward
(>)*7                             Tally ho!
(([-([(-)*6[+.]])*5])*4>)*21      Clear toward the opposite end

Se défend comme @ Backtracker de Geobit , mais se défend contre les attaquants rapides en mettant un leurre rapide devant le drapeau en premier.

L'attaque est un nettoyage imbriqué avec une polarité opposée permettant d'effacer rapidement les leurres aux valeurs réduites. Dans le pire des cas, un leurre de 64 (soit la polarité).

Edit 1: Améliore l’efficacité des attaques contre les leurres (erreur de logique dans la commutation de polarité).

Edit 2: Le test indique que la pause fonctionne légèrement mieux dans la boucle la plus interne.


6

Backtracker

Une stratégie de leurre inverse. Commencez par déposer les leurres à l'arrière, pour que personne ne saute le reste pendant que je les construis.

Si le tableau est inférieur à 20 ou plus, cela ne fonctionnera pas contre les robots d'attaque rapide, car nous nous croiserons juste avant que je ne commence à leurrer.

(>)*9((-)*4<+<-<(+)*4<)*2(>)*8(>[-])*21

(>)*9                   Jump ahead 9
((-)*4<+<-<(+)*4<)*2    Lay down alternating polarity/size decoys for 8 spots behind
(>)*8                   Jump back forward
(>[-])*21               Clear until flag

Note: Je ne fais pas de BF, mais c'est comme ça que ça me fait envie. Si non, s'il vous plaît laissez-moi maintenant.


6

Je ne peux pas toucher ça

Il s'agit d'un programme axé sur la défense qui tente de déterminer comment l'adversaire nettoie les cellules et crée un leurre de taille appropriée.

>---    create 1st decoy
>+      decoy for timing
>+      decoy for waiting
[]<     tripwire activated!
[<-->]  increase size of 1st decoy while opponent clears 2nd decoy
(>)*8   attack!
[+(<)*9(+)*20(>)*9]    slowly clear, while going back to stop enemy progress
>[+(<)*10(+)*22(>)*10]
>[+(<)*11(+)*24(>)*11]
>[+(<)*12(+)*26(>)*12]
>[+(<)*13(+)*28(>)*13]
>[+(<)*14(+)*30(>)*14]
>[+(<)*15(+)*32(>)*15]
>[+(<)*16(+)*34(>)*16]
>[+(<)*17(+)*36(>)*17]
>[+(<)*18(+)*38(>)*18]
>[+(<)*19(+)*40(>)*19]
>[+(<)*20(+)*42(>)*20]
>[+(<)*21(+)*44(>)*21]
>[+(<)*22(+)*46(>)*22]
>[+(<)*23(+)*48(>)*23]
>[+(<)*24(+)*50(>)*24]
>[+(<)*25(+)*52(>)*25]
>[+(<)*26(+)*54(>)*26]
>[+(<)*27(+)*56(>)*27]
>[+(<)*28(+)*58(>)*28]

Je travaille actuellement sur une version qui peut gagner contre les deux polarités.


6

ImpatientTripwire (aka YandereBot)

Essaie d'être un déclencheur de manière à pouvoir poser des leurres (principalement) de la polarité correspondante, mais abandonne si vous prenez trop de temps et supposez que vous êtes à la parité opposée. A un tripwire inversé pour les petites planches.

(+)*5                                     Toggles the base
>-                                        Sets up reverse tripwire
>>++>-->                                  Sets up basic decoys    
(+)*20                                    Makes a massive antioffset tripwire
(([)*150                                  Waits for a while
    <<<<                                  Goes to check on the other tripwire
    +[
      <                                   Bot found you and is furious
      ((+)*128 (>)*9 (+.)*55 (<)*9)*5     Tries to tie you up
      ((+)*128 (>)*10 (+.)*54 (<)*10)*5   And torture you
      ((+)*128 (>)*11 (+.)*53 (<)*11)*5   As it destroys the world
      ((+)*128 (>)*12 (+.)*52 (<)*12)*5
      ((+)*128 (>)*13 (+.)*51 (<)*13)*6
      ((+)*128 (>)*14 (+.)*50 (<)*14)*6
      ((+)*128 (>)*15 (+.)*49 (<)*15)*6
      ((+)*128 (>)*16 (+.)*48 (<)*16)*6
      ((+)*128 (>)*17 (+.)*47 (<)*17)*6
      ((+)*128 (>)*18 (+.)*46 (<)*18)*6
      ((+)*128 (>)*19 (+.)*45 (<)*19)*6
      ((+)*128 (>)*20 (+.)*44 (<)*20)*6
      ((+)*128 (>)*21 (+.)*43 (<)*21)*6
      ((+)*128 (>)*22 (+.)*42 (<)*22)*7
      ((+)*128 (>)*23 (+.)*41 (<)*23)*7
      ((+)*128 (>)*24 (+.)*40 (<)*24)*7
      ((+)*128 (>)*25 (+.)*39 (<)*25)*7
      ((+)*128 (>)*26 (+.)*38 (<)*26)*7
      ((+)*128 (>)*27 (+.)*37 (<)*27)*7
      ((+)*128 (>)*28 (+.)*36 (<)*28)*8
      ((+)*128 (>)*29 (+.)*35 (<)*29)*8      
    ]-
    >>>>)*2                                 Waits again
      <(+)*20                               Bot got stood up, is sad
      <(+)*20                               Sets up some decoys
      <(+)*20                               Grabs a knife
      <(-)*20                               Licks the blade
      <(-)*5                                Locks the house
      >>>>>>>>                              Goes to hunt you down
     (
       >                                    Start searching
       [
         +[+[+[                             Search from minus three
         ---
         -[-[-[                             To plus three
         (-)*17                             If that's no good, do an offset
         [+]                                Clear by adding
         [-.--]                             Just in case
         ]]]]]]                             I would duplicate the program to skip these like at
       ]                                    the bottom but the file would get too large
       [--.---]                             Also just in case
       -                                    Leave a small trail
     )*22
(
  ]                                         Skip the bracket closing
  <(-)*20                                   Bot found you and is happy
  <(-)*20                                   Has just the perfect presents for you
  <(-)*20                                   You like decoys right?
  <(+)*20                                   Here's a plus one in case you are sneaky
  <(-)*5
  >>>>>>>>                                  Time to hunt you down

  (>[+[+[+[----[-[-[(-)*17[+][-.--]]]]]]]][--.---]-)*22
)*300

Version actuelle: 1.3 - édité pour faire mieux sur des tableaux plus petits, au détriment de perdre des jeux en raison des ennemis se faufiler au cours de la vérification du fil de trépied

Anciennes versions: 1.2.1

(J'ai besoin d'un meilleur algorithme clair: /)


1
OMG 411k complètement développé et dépouillé: -O Le code de Chiper ne tient pas compte de cela.
Sylwester

Je viens de changer quelques commentaires pour que cela fonctionne maintenant avec le nouveau code de Cipher
Sp3000

depuis la dernière modification, les crochets non appariés entre parenthèses sont étranges, car la logique de la boucle se heurte à la logique des abréviations. puis - je changer des constructions comme ([)*300revenir à [[[ and so on?
Chiffre

@Cipher Ouais, allez-y - bien que la version de pastebin devrait être exactement ça
Sp3000

1
3ème est un bel endroit pour entrer. Bien joué.
AndoDaan

5

Lightfoot Plodder - ÉDITÉ

Basé sur le Plodder , ce monstre rapide est capable d’avancer rapidement dans des zéros consécutifs jusqu’à atteindre quelque chose de différent de zéro (point auquel il commence à marcher comme prévu).

Maintenant amélioré avec un algorithme de skimming plus robuste, qui permet également une avance rapide via de petits leurres et des leurres plus volumineux.

Edit # 2 : Il est maintenant possible de revenir en mode écrémage s’il trouve davantage de poches de zéros.

>(-)*4
>(-)*7
>(-)*4
>(+)*7
>(-)*17
>(+)*3
> -
>(-)*10
>(+)*16[-]<-
([
[>>
 [+
  [--
   [+++
    [<+>(+)*14[-]]
   ]
  ]
 ]<-
]>>
[(+)*126(+.)*4>]
<]+)*10

Bon changement de taille "pratique" là-bas :)
Lily Chung

@ IstvanChung Très pratique. ;) Tout le reste m'aurait trop ralenti, perdant des points au profit de plusieurs autres robots. Si vous avez rendu Bigger plus grand, je ne pense pas que j'essaierais de suivre le rythme.
DLosc

Eh bien, j'ai légèrement modifié la taille pour voir comment cela fonctionne. Je pense que Bigger pourrait peut-être obtenir une taille encore plus grande, mais n’a pas le temps de le tester à fond. Bonne chance!
Lily Chung

J'adore la contre-mesure contre les robots Cloacking et le fait que cela ressemble en réalité à la programmation BF :)
Sylwester

5

Rán v2 réticent

La stratégie est facile. Essayez de faire croire à l’adversaire que son drapeau est un leurre et qu’il passe devant le tableau et qu'il est lâche (une sorte de tripwire / vibrateur). Après 10 tours complets, elle abandonne et tente de déterminer si l'adversaire est à son drapeau et si ce n'est pas le cas, elle fabriquera -17 leurres jusqu'à ce qu'elle atteigne une cellule. La méthode de nettoyage qu'elle utilise est un cas spécial pour [-12,12] et commence à marcher comme un Lok.

>>-<<                                  set a flag
(.)*11                                 wait for sixteenth step
((-)*256)*10                           reduce by ten rounds
                                       We give up check flags
> [(>)*7                               detected fast rush mode
    (-[>[
        -[-[-[-[-[-[-[-[-[-[-[-[       from plus one to twelve
        (+)*12                         reduce by twelwe
        +[+[+[+[+[+[+[+[+[+[+[+[       from minus one to twelve
          (+)*66..(+)*41(+.)*17>       increase and plod
        ]]]]]]]]]]]]]]]]]]]]]]]]]-])*3 
  ](-)*31
>+[(>)*6                               detected fast rush mode
    (-[>[
        -[-[-[-[-[-[-[-[-[-[-[-[       from plus one to twelve
        (+)*12                         reduce by twelwe
        +[+[+[+[+[+[+[+[+[+[+[+[       from minus one to twelve
          (+)*66..(+)*41(+.)*17>       increase and plod
        ]]]]]]]]]]]]]]]]]]]]]]]]]-])*3 
  ](-)*21
[>[                                    propably a trapper so we move slow
    ..+..-(+)*119(+.)*17               plodd the first cell so we dont go to zero on low positive
    ([>[
        -[-[-[-[-[-[-[-[-[-[-[-[       from plus one to twelve
        (+)*12                         reduce by twelwe
        +[+[+[+[+[+[+[+[+[+[+[+[       from minus one to twelve
          (+)*66..(+)*41(+.)*17>       increase and plod
        ]]]]]]]]]]]]]]]]]]]]]]]]]-]-)*3 
  ](-)*17
]

Anecdote: Rán est une déesse de la mer Mythologie nordique qui emmène les marins avant leur mort en mer.


5

Mickey V4

Pour V4, j'ai utilisé la même méthode que V3, par rapport aux bots mis à jour mais avec plus de populations concurrentes (30 et non 10).

Développé contre tous les 60 robots, y compris BurlyBalderV3et LethalLoke(mais en excluant 2botsonecup qui est incomparable par ma stricte implémentation).

J'ai découvert des robots extrêmement différents et des taux de réussite si je commençais avec différentes graines aléatoires. J'ai donc décidé de séparer ces différents points de départ en populations et de les laisser occasionnellement effectuer une pollinisation croisée.

En 1400 générations, 30 populations en évolution simultanée ont créé ce programme:

++>------>->---<<<------------->------>->
---->------------->>--->------<----------
------<------<-<<--<------------->-------
-<-->------>------->----------->---------
----->-------->------->----------------[>
[--[-[+]]]>[--[+]]-]-------[>[--[-[+]]]>[
--[+]]-]<--<------>------->--------------
--[>[--[-[+]]]>[--[+]]-]<--<-------------
--------->------>->-<-----

Je calcule le taux de gain de ce bot à 90,0% par rapport à la récolte actuelle. (Longueurs de bande 1135/125/0 gagnées / perdues / tirées).

Info V3

Taux de gain calculé de 89,2% (1124/62/74 longueurs de bande gagnées / perdues / tirées).

Info V2

Le programme de génération dispose maintenant d’une analyse permettant de déterminer quelle partie de la fin du programme est inutilisée et de la réduire avant de générer les générations suivantes. Cela signifie que des mutations aléatoires se produisent uniquement dans les parties utilisées du programme et que l'évolution est plus rapide.

72% contre la récolte en cours à l'époque. (892/204/143 longueurs de bande gagnées / perdues / tirées).

V1 info

31500 générations, seulement 12 robots ont fait face. 65% (165/80/7 longueurs de bande gagnées / perdues / tirées). J'utilise les 21 longueurs de bande.

Les robots potentiels sont classés par:

  • la plupart gagne alors;
  • la plupart des tirages alors;
  • temps le plus rapide tiré ensuite;
  • meilleur temps gagné

Trivia

  • Mickey est nommé d'après mon chat et;
  • Pour paraphraser TS Elliot: The Naming of Cats is a difficult matter, It isn't just one of your brainfuck bots
  • Mon algorithme génétique et java bf vm est sur github .
  • Le vm est capable d'exécuter un tournoi complet en moins de 4 secondes sur un seul noyau d'un i7 (attention - les résultats ne sont pas toujours identiques au moteur de tournois).

Ne serait-il pas préférable d'utiliser les 60 robots?
Sylwester

@ Sylwester Peut-être, je ne l'ai surtout pas fait parce que c'est si lent. A pris deux heures pour le faire. Aussi, bien que le nombre de robots auxquels il a dû faire face ait évolué plus lentement. Je pensais que si ça battait les meilleurs, ça irait bien. Je n'ai pas été en mesure de lancer le tournoi pour confirmer, des problèmes de python. Alors j'ai pensé le poster et voir ...
West le

@weston Peut-être pourrions-nous vous aider avec vos problèmes de python?
Chiffre

@Cipher merci, j'ai ouvert un numéro sur github github.com/redevined/brainfuck/issues/2
west le

@ Sylwester J'utilise la plupart des robots maintenant, car mon générateur est beaucoup plus rapide et multithread.
weston le

4

Joueur

Ceci est étroitement lié à mon bot Geronimo. Mais là où Geronimo joue un jeu sûr, le joueur tente d’être plus rapide en faisant ce qu’il fait le mieux: le jeu: il passe à la 20ème cellule et commence à zéro à partir de là.

Cela signifie qu'il pourrait facilement perdre juste parce que l'arène n'est pas si grande. Mais si c'est le cas, ce sont peut-être les quelques cycles qui comptent.

(>)*19(>[-])*11

Anecdote: J'envisageais vraiment d'entrer dans un groupe de bots qui ressemblent tous à un (>)*X(>[-])*Yemplacement X in 9..29et Y = 30 - X. Mais je pense que saisir vingt robots serait un peu trop :) ou même quarante si j’avais deux versions, une avec zéro-s [+]et une avec le fait [-].


Un nombre comme 13 ou 14 ne vous donnerait-il pas plus de chances de gagner des pourcentages que 20?
Moop

Oui peut-être. Je veux juste pour le milieu. Fait intéressant, si je vais juste à gauche au lieu de droite, mes chances de gagner diminuent de beaucoup. Aurais-je prévu le contraire?
Ingo Bürk

Comme chaque combat bot correspond alors contre tout autre bot, même 40 de ceux ne lèverait pas vos chances que beaucoup - et j'ai eu un moment difficile de copier et coller: D
Cipher

4

Dumbot

Un bot remarquablement stupide qui ne fait que gâcher l'environnement et espère que tous les bots contre lesquels il se bat vont disparaître.

(+)*50(>-)*7(([.])*50(+)*50>)*7([-])*256

(Je ne suis pas sûr si cela fonctionne même - cela ne commet pas d'erreur cependant!)

Annoté (avec ce que je pense qu'il fait):

(+)*50      Increase home cell by 50
(>-)*7      For next 7 cells, decrement once
(           Open loop
([.])*50    If cell is non-zero, do nothing. If cell is zero... Still do nothing? I'unno.
(+)*50      Now let's increment it fifty times for some reason.
>)*7        And let's do the above two instructions ten times more, in the next 7 cells
([-])*256    If the cell we're on is non-zero, decrement it continuously and hope it's the enemy.

(Je serai étonné si cela remporte une seule bataille)


1
votre deuxième ligne mettra à zéro la cellule par addition, puis en soustraira une sept fois de suite.
fier haskeller

1
@ Proudhaskeller Vous avez raison ... C'est ce que je reçois pour avoir essayé de faire du Brainfuck avec peu de sommeil. Nous venons de simplifier les choses au lieu de nous demander comment le faire correctement.
Sellyme

4

CropCircleBot

[>>[+][-]-<[-][+]+][>[+][-]<[-][+]++]

Ce bot utilise des algorithmes avancés qui ont été transmis par des extraterrestres à travers des crop circles qu’ils ont placés sur Terre. Cela changera l’humanité, engendrera d’énormes progrès technologiques et résoudra même de nombreux problèmes environnementaux.


Vous savez que vous ne devriez jamais utiliser] [, non?
CalculatriceFeline

Je ne pas, pouvez-vous expliquer pourquoi?
Flawr

Lorsque vous quittez une boucle, la cellule en cours est 0. Ensuite, vous ignorez la boucle suivante car la cellule au niveau du pointeur est toujours 0.
CalculatorFeline

Oh, j'ai toujours pensé que le contrôle a lieu à la fin de la boucle?
Flawr

Cela se produit également au début. Dans certaines implémentations, [ne fait rien, mais c'est un langage complètement différent (newbiefuck sur le wiki esolang)
CalculatorFeline

4

BeatYouMate

Et parce que tout le monde devrait publier un bot qui battra le premier bot qu’il publie, voici un robot leurre de 5+:

(>------>+++++++)*4>([(+)*6[-]]>)*21

4

CleverEtDéterminé

>+>-(>+++[-])*21

Définit quelques petits pièges, puis court de l'autre côté et tente de tout effacer, au-dessus ou au-dessous de zéro. Échoue ----.


+++Avant [-]est en effet intelligent pour éviter les pièges simples!
Ingo Bürk

Mis à part une exception due à une incomparable (, puis-je le traiter comme un commentaire?
Chiffre

@ Cipher Je vais résoudre ce problème, désolé.
isaacg

4

MetaJSRandomBot

+[[>-[->+]>>[-]>-<<[>][+]<]+<]->

L'idée derrière ce bot est de rendre quelque chose de totalement aléatoire qui reste un code js valide sans trop d'inutilité. J'ai écrit le code suivant ( lien JSFiddle ) pour le générer. Permet de voir à quel point il fait =)

var nchars = 30;
var nbrack = 10;
var alphab = "+ - < >".split(' ');
var s = [];
for(var i=0;i<nchars;i++){
    s.push(alphab[(Math.random()*alphab.length)|0]);
}
var ind1,ind2;
for(var i=0;i<nbrack;i++){
    ind1 = (s.length*Math.random())|0;
    s.splice(ind1,0,'[');
    ind2 = ((s.length-ind1-1)*Math.random())|0 + ind1;
    s.splice(ind2,0,']');
}
s = s.join('')
for(var i=0;i<Math.max(nchars,nbrack);i++){//remove useless stuff
    s=s.replace('[]','');
    s=s.replace('+-','+');
    s=s.replace('-+','-');
    s=s.replace('<>','');
    s=s.replace('><','');
}
alert(s);

4

Roulette Prussienne

Russian Roulette a fait un pari avec son ami prussien et c'est maintenant à son tour de jouer.

>(+)*5(-.[>.[>(-)*10]]>>)*1000

Vous avez 2 incréments de pointeur et seulement 1 incrément dans votre boucle principale - cela vous permettra de sauter de votre propre bout de la bande.
Komintern

2
Cela va tout simplement se jeter.
fier haskeller

Au début, vous avez un plus suivi d'un moins. 2 cycles perdus.
weston

4

Plus gros

La course aux armements commence !!

Les deux construisent et détruisent des murs de hauteur 16 18, plus grands que la plupart des concurrents. A également un peu de logique pour battre le cloaker, les défenseurs du drapeau, les anti-alternateurs, et les bots qui assument un drapeau intact

+>->+>+>-(>(-)*18>(+)*18)*2(>([(+)*18[-][-[+]]])*2)*21

Version annotée

Off by one
==========
Adjust own flag a little for fun
-

Decoy stage
===========
Build decoys

>->+>+>-        Add four quick walls to deter rushers
                Also throw off bots depending on the alternation
(>(-)*18
 >(+)*18)*2     Build four large decoys

Clear stage
===========
(               Repeat the following forever:
  >             Move forward
  ([            Skip if the space is zeroed already
      (+)*18    Bust negative decoys smaller than 18
      [-]       Clear
      [-[+]]    Check that the wall is actually cleared; if it isn't,
                clear in the opposite direction to defeat bots that try
                to sense our clear direction and defend the flag
  ])*2          Repeat the "non-zero" check to guard against the cloaker
)*21

3

PatientBot

Un bot en partie sérieux. ce bot va tenter de gagner par la limite de 100 000 cycles. il ira au drapeau ennemi en mettant quelques pièges sur le chemin, le diminuera un peu, reviendra et défendra le drapeau.

>++>->->+>+>->->+(>+[-[-[(<)*9--[<--](+)*10000]]])*20

il supposera que tout ce qui est plus grand que 1 ou plus petit que -1 est le drapeau, et quand il en rencontrera un, il retournera. il défend simplement en augmentant constamment. cela suppose que la plupart des programmes utiliseront soit [] pour vérifier si le drapeau est devenu 0, et donc (+) * 100000 sera beaucoup plus rapide

Edit: impossible de faire fonctionner l'interpréteur BF Joust. j'abandonne. Peut-être devriez-vous me dire comment améliorer mon code.

Edit: maintenant le bot crée la tache juste avant le drapeau 2, et après qu’il ait décrémenté le drapeau un peu, il cherche un 2. Ceci est censé annuler le scénario dans lequel le bot trouverait une cellule 0 différente de celle qui précède le drapeau.


Votre bot semble se tuer sur une cassette (assez rare, je l’avoue) de longueur 10 car il ya 10 '>' au début. En dehors de cela, ce [<]n’est pas une bonne idée, car cela se répète jusqu’à ce que la cellule placée sous votre pointeur soit égale à zéro , ce qui correspond à l’une des cellules situées devant votre drapeau ou simplement à un suicide si votre pointeur atteint le drapeau (depuis votre drapeau). est heureusement pas zéro ).
Chiffre

@Cipher Remarquez que le bot ne met pas un piège à la place juste devant le drapeau - mon idée était de marquer cet endroit pour que le bot construise sa défense là-bas. Y a-t-il un meilleur moyen? En bfjoust, parfois, l'ennemi efface les pièges puis le bot s'arrête avant qu'il ne le devrait.
fier haskeller
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.