Après de nombreux tournois, mon bot (posté il y a maintenant plus de 6 mois) est désormais premier du classement, yeyyy 😀
Classement au 04/06/2013
[Post Initial]
Après AI Challenge « Ants » 2011, en manque de défi d’IA, j’ai effectué pas mal de recherche sur internet afin de trouver un concours qui me plairait.
Et je l’ai trouvé (enfin partiellement) FinalBot est un site concu il y a un peu plus d’un an, avec pour but d’hoster différents concours d’IA.
Lors du lancement, 2 jeux sont mis en place:
Un jeu de dark chess (les échecs avec du brouillard de guerre! Il fallait y penser!) et , de manière plus importante: un jeu de Hold’em Poker.
Top 2! (11/06/2012) Le premier est … loin oO
J’avais déjà eu l’envie de faire une IA sur ce thème du poker. Mais la mise en place du jeu peut être laborieuse et chronophage, ce qui m’avait un peu refroidi.
Bref, découverte du concours:
J’arrive après la guerre: le site et le concours ont été lancé durant l’été 2011 et une fois les récompenses données aux vainqueurs, le site a vu sa fréquentation décroître. Les bots développés sont toujours présents et 3 compétitions sont organisées automatiquement tous les jours (standard, headsup, bigpool). C’est CLR plateforme uniquement (C#/CPP/F#)
J’ai créé un bot début Août, random bot d’abord, afin de tester le site. Puis je m’y suis réellement mis. J’ai récupéré et testé un bon paquet de librairies « permettant » de calculer les probas dont j’avais besoin.
J’ai fini par choisir un package(C#) créé par Keith Rule (lien). Cet utilitaire ne fonctionne pas, comme je l’avais imaginé, sur des tables de données précalculées. Non, les probas sont re-calculés à la volée. C’est extrêmement bien optimisé (pour du C#), ce qui permet de calculer ces probas avec une bonne précision dans le temps imparti.
Mon bot est assez simpliste pour le moment. Il joue relativement safe et tente des bluffs dans un seul cas: s’il est le dernier à parler, que tout le monde à check et qu’il a des jetons. (dans ce cas là uniquement 30% du temps) Il n’analyse pas le comportement de chaque joueur en face (c’est le prochain pas)
Beaucoup de règles sont donc implémentées, avec de nombreux tresholds variables selon le nombre de joueurs toujours à la table, les valeurs de base étant setté via la bonne vieille méthode empirique et de bon sens. (donc très clairement améliorable!) Le Heads-Up (1v1) est géré de manière indépendante (car il faut être, de manière générale, bien plus agressif en 1V1 que dans une partie avec plusieurs adversaires)
Après des mises à jour successives, je me suis rendu compte que le rythme des tournois mis en place sur le site officiel était bien trop faible pour avoir une visibilité un tant soit peu précise sur les conséquences des « améliorations » apportées au bot. De même pour le client de test (permettant de faire des matchs offline, entre les bots fourni (raisebot-callbot etc) et les bots développés (dont on possède les dll bien sur!)) : Problème: ce client de test permet de faire … 1 match par 1 match. Pas de quoi avoir des stats précises :/
J’ai donc prit cet exe de test, browsé son code (via ILSpy) pour récupérer les méthodes utilisées pour ajouter les joueurs, lancer les matchs, récupéres les scores etc. Ensuite, création d’un nouvel exe winform sur visual studio. Intégration des dlls de l’exe de test, et je me suis fait mon tool à moi (très design, comme d’hab)
FinalBot Canon Launcher – Un design hors du commun
Grace à ce tool, j’ai désormais la possibilité de voir ce que mon bot vaut … véritablement: (données basées sur le % de première place) Ici un exemple avec 1000 parties:
Tiens tiens, la version 8 semble moins efficace que la 7…
Problème: je n’ai pas les DLLs des concurrents! (à venir, le premier du concours m’ayant « promis » sa DLL) A l’heure actuelle (je n’ai pas touché au bot depuis au moins 1 mois et demi) je suis 2ème du classement continu (La montée à pris du temps, dû au fait qu’il y a seulement 3 tournois/jour)
L’AI Challenge consiste à créer une intelligence artificielle: vous créerez un programme informatique (dans n’importe quel langage) qui contrôle une colonie de fourmis devant se battre contre d’autres colonies pour la domination totale!
Basic situation, the antHill on the top left corner, ants are white dots. Grey dots are food and blue is water (can’t go through)
Simple fight: 2 versus 1. The 2 orange ants will survive.
Complex map control by good players
Complex game control with several players
Ci dessous une partie des top players afin de visualiser le jeu:
NB: cliquez sur le bouton « plein écran » afin d’avoir un meilleur confort visuel et les touches +/- pour ajuster la vitesse de la partie.
Loading…
Les règles sont les suivantes :
Le joueur gagne des points (2) en rasant les fourmilières adverses. Il perd un point par fourmilière perdue.
A chaque fois que le joueur « ramasse » un bloc de nourriture, ce dernier disparait et une nouvelle fourmi est créée dans une des fourmilière de ce joueur.
Les parties sont jouées sur des cartes de 2 à 10 joueurs.
I’m going to describe briefly here how my C# bot works. It’s very far from being perfect, even far from being good but I made something working. And I finished it on time.
The code contains a couple of array -maps- containing different infos, updated in real time for some, and at the begining of every turn for others.
mapWater: Water map
mapVisible: number of my ants seeing a specific Tile
mapLastTurnSeen: Map of last turn value I’ve seen the specific Tile
It computes every routes in a certain range in order to protect my hills, attack enemy hills or collect food. Add them to a list and sort them afterwards
Food routes are less important than defendHills & attackHills ones. I picked a coef 3 in order to make this distinction. Thus a 3 cells AttackHill route is equivalent to a 9 food route.
After the filter applied, I give the « real » orders right away. (I won’t change them)
The defendHills make 2 of my closest ants go towards one enemy. No more.
One piece of food is target by only one of my ant (the closest, if not used for defending or attacking ofc)
Phase II: Attack close enemy ants
After that I make my free ants attacks close enemy. The idea is to « push » enemy and to diffuse my ants towards enemy hills.
Phase III : The Sentinel
After that I make, if I got enough ants, one of them stay close to my hill. This way I can see if an enemy is coming. This ant will not stay static because of the previous calls. If a food just appears, it will go collect it which will generate a new ant (which will probably take the « Gardian » position, if nothing else is needed) Same if an enemy ant approches, it will go fight it.
Phase IV: Explore the map
A good exploration state
Then and last, I call the ExploreMap function where Free ants will go explore the map.
I use a map monitoring the last tour I’ve seen every cell in order to make the ant goes somewhere « new ».
It goes towards 8 differents directions (E/N/S/W and combinaison like N-E)
I start one cell further the view range of the picked ant. If alls cells are already seen, I go one cell further. (Water tiles are not taken into account)
The 8 cells are then sorted by turn they have been seen. The ant will go toward the « oldest »
TECHNICAL DETAILS
1.Movement
Directions are made with an A* algorithm. I use the following one that I’ve modified just a little bit.
I have a list of timeout routes which helps me to not compute too long – complicated – routes again and again.
I wanted to do the same with computed routes (to not have to compute them again and again if needed, but they can change if I discover that an unseen tile is actually a water tile) I started to filter them every turn but it was really too time-consuming.
2. Fight:
Everytime I give an order, I test the « safety » of the area. My implementation is not really good, but it gives a basic idea of the security (not optimized though)
I sorted safety into 3 different categories (following some advice I found on the forum, Memetix® style)
SAFE: no worries it’s ok
KILL: I can expect to have a 1-1 trade with the enemy
DIE: It will be worse.
Some of the following conditions make my ants decide (or not) if they should go to a KILL area like :
If there’s a food between the enemy and I. If I have a lot of ants etc etc.
If it’s considered to be unwise to go, the ant will try a close direction, or to stay put or even to go back in order to avoid death.
PROBLEMS ENCOUNTERED
1. A* Algorithm
First of all, the A star algorithm.
I picked C# because it’s the language I use at work and I’m the most used to. However, existing Astar code are legion in c++ but real few in C#
I tested 2 very well graded on source code website. Istarted with what I thought was the best of them. Timeout used to occur if the path was 10-15 tiles long. I developed my bot during 2-3 weeks with this algo, making a lot of concessions because of the timeout problems. Then I found out it wasn’t normal at all and found a new one, which was described as « not perfect » because it’s not giving the shortest path.
It was the worst error I made, to not have discovered this one before. I kinda lost one week and a half.
2. Exploration
I started with monitoring how many ants were seeing every tile, trying to send them where tiles were « less » seen. It was working ok but I had some very bad « cycles » where ants used to jitter.
I switched to the last turn seen way, which gave me better results.
Before my final submission (like 12 hours before :s) I still had some bad behaviours: in some maze_map, ants used to stack at one point and jitter alltogether, like if it was awesome to finally have some security or friends or I don’t know. Anyway, I patched it quickly: ants which don’t have any orders at the end, if surrended by more than 7 ants in some small perimeter should go towards the closest enemy.
It’s dirty, it’s last minute modification, but I think it was worth it.
NB: After almost every group of modification I made during the last 2 days, I ran a couple of test games (~10) where I’m supposed to win against middle-skilled opponents. It happens that results were pretty bad so I could review the previous modifications.
CONCLUSION
I spent a lot of time on the exploration system. I wanted to go step by step and not rush the global feature bot too soon.
The first implementation I made was just monitoring enemy position, creating an array of « Unsafe » positions and … that’s it. It was obviously not good at all, my ants were just fearing every single enemy. I found the memetix post (link) and tried to implement it, but I guess I screwed up because I had to make some modifications and the result is far from my expectations. Time went fast and I couldn’t have a « proper » fighting system and the result is that I can’t really play map control like pro players do: having walls of ants facing each other.
Anyway, it was a really interesting contest. I’m glad I found it quite soon (I think I missed the 2 first weeks but I had 1month and a half to develop something) I’m also glad that « Fredo », a colleague of mine followed me on this event, so we could compare and improve our bots. I think the result would have been way worse (yeah, it’s possible I’m sure!) if I was alone on it.
Even if they won’t see that, I’d like to thanks the organizers for their amazing job. The game engine was awesome, the starter pack perfects, tools aswell. The finals (even if it’s still going on) are really interesting. The community was very friendly and best players gave tips and shared their source code at the end, which is very nice and very interesting.
Pour introduire ce post, je vais citer wikipedia (Oui, c’est le mal je sais, mais au moins je ne perdrais personne des la premiere ligne :))
« La cinématique inverse (souvent abrégée IK, de l’anglais inverse kinematics) est un procédé par lequel on peut déterminer les positions et rotations d’articulations d’un modèle afin d’obtenir une pose.
Le terme « cinématique inverse » renvoie au fait que l’étude cinématique se fait généralement à partir des paramètres des articulations, afin de déterminer l’évolution de la pose. »
Durant ce projet, l’un des buts était l’implémentation d’une fonction permettant de calculer la pseudo inverse d’une matrice non carrée. Apres quelques recherches, les algorithmes SVD (pour Singular Value Decomposition) et Greville sont apparus etre les plus a meme de remplir ce role. Je ne vais pour le moment pas rentrer trop en detail dans le reste du projet, mais je voulais surtout que ces deux algorithmes soient disponibles (j’avais pas mal cherché du code a ce moment la, sans réussite) Les 2 fonctions sont implémentées en C++ avec l’aide de la library GSL Library.
Dans l’archive, vous trouverez l’implementation des algorithmes Greville et SVD, ainsi qu’un simple code de test permettant de tester leurs performances respectives. Pour aller plus vite, voici un graph a propos de la vitesse d’execution des 2 algorithmes.
Le second projet du cours « Cryptographie et sécurité des réseaux », suivi a l’Université de Stavanger, Norvège était un cran plus complexe que le premier, particulierement durant la génération des clés: nous devons manipuler des nombres extremement grands. J’ai développé l’application en Java et utilisé la classe BigInteger pour gérer ces nombres énormes.
Le programme fonctionne comme cela:
1. D’abord vous devez générer votre clé publique et votre clé privée, puis sauvegarder la clé publique (le programme vous permet de la sauvegarder dans un fichier .pk)
TO FINISH
2. Then, type your message and sign it, then save it in a file ( .mes extension)
3. The last step (the most important) is the part where you check if the message loaded really comes from the official writter. So you have to load his public key, load the message and then press check.
Here is a screenshot of the application:
For information, I have implemented the digital signature algorithm with a 1024 bits long p and a 160 bits long q (for people who knows what the DSA algorithm is all about)
I use a hash function made by myself. You can find everything in the code at the end of this post.
And you can download the whole project (code + exec + report) here : > Download <
Premier projet personnel partie intégrante du cours « Cryptographie et sécurité des réseaux » que j’ai suivi a l’Université de Stavanger, en Norvège.
Le but était de développer un réseau de Feistel; nouys pouvions en choisir un existant ou en créer un de notre propre conception.
Après quelques essais, je me suis rendu compte que mes réseaux de Feistel n’étaient pas robuste et sécurisé, donc j’ai implémenté le DES (Data Encryption Standard), avec une petite modification: la clé n’a plus besoin d’etre 64bits long. Une fonction s’occupe de rendre la clé aussi longue que la taille du texte en clair.
Screenshot de l’application:
GUI of the Java application
Vous pouvez télécharger le projet (source + exec + rapport pdf) ici: > Télécharger <
Après AI Challenge « Ants » 2011, en manque de défi d’IA, j’ai effectué pas mal de recherche sur internet afin de trouver un concours qui me plairait.
