Coucou tout le monde. Pour mon FPS que je suis en train de développer, il me faut absolument des bots. Des persos (md2) qui bougent, se déplacent tout seul, et qui foncent tapper sur le joueur dès qu'ils le voient. Voilà, assez simple à expliquer en toute rigueur, mais alors pour faire un truc dans le genre... -_-

En gros, je galère. Je vais vous dire ou j'en suis dans mes recherches mais si vous pouvez m'éviter de pédaler dans la semoule ca pourrait etre classe ^^ (ca se trouve, il existe du code déjà fait à utiliser pour faire des bots...).

Ce que je souhaite faire, c'est utiliser un ICameraSceneNode (pour utiliser des trucs cools comme par exemple getSceneNodeFromCameraBB(camera) et lui attacher un IAnimatedSceneNode (pour le mesh). Après, je pourrais m'arranger pour coder un déplacement, qui se ferait à chaque loop (donc je ferais gaffe que ca n'aille pas trop vite), m'arranger pour qu'il y ait un statut (du genre "en train de faire une ronde en marchant par la" ou "en train de poursuivre le joueur" ou encore "en train de taper sur le joueur"), et... voila. Mais j'y arrive pas TT.

Donc voila, au secours, si vous aviez une quelconque idée comment me tirer d'affaire...


merci ! ^^

Tu veux employer une caméra pour chaque bot de façon à détecter le joueur ?

C'est une très mauvaise idée.

Tu as juste à tester la distance entre le bot et le joueur à chaque frame, si ils sont proches, le bot passe en mode "en train de poursuivre le joueur", et voilà.

C'est assez sommaire, mais c'est facile à mettre en place.

Tu as juste à tester la distance entre le bot et le joueur à chaque frame, si ils sont proches, le bot passe en mode "en train de poursuivre le joueur", et voilà.

J'ai encore jamais fait d'IA, mais ca me semble être une bonne idée de départ. Après je penses qu'il faut l'affiner. Quelques idées qui me viennent :

- initialiser l'ennemi dans un état "n'a pas encore détecté le joueur"
- à chaque pas de boucle :
  - si l'état est "n'a pas encore détecté le joueur" :
     - tester la distance entre le joueur et l'ennemi
         - si la distance est petite, on vérifie qu'il n'y a pas de murs entre eux (ben oui, il voit sans doute pas a travers les murs )
            - si on arrive la, l'ennemi passe dans l'état "poursuit le joueur"
  - si l'état est "poursuit le joueur" :
     - si l'ennemi peut tirer sur le joueur (pas de murs, distance raisonnable...), il tire (logique... )
     - sinon, il faut qu'il se déplace pour être plus prêt du joueur
...

Pour le déplacement de l'ennemi, le mieux est sans doute de créer un réseau en placant des points de passages possibles un peu partout sur ta map, puis d'utiliser l'algorithme A* pour trouver un bon chemin (pleins d'infos sur cet algo sur le web, tu peux utiliser micropather pour ca).

Voila, j'espère que ca va t'aider a démarrer, mais y a encore beaucoup de boulot  à faire...

Le truc c'est que si je base la réaction du bot en testant la distance bot-player, le gobelin qui sera de dos remarquera ma presence a la meme distance que s'il est de face et qu'il me "voit" arriver. Et pour les déplacements, faut que je me retappe toute la programmation qui a servie a ICameraSceneNodeFPS (avancer, tourner, strafe etc etc), et c'est pour ca que je voulais réutiliser ca... (avec un setActiveCamera(camera_du_joueur) pour pas de confusions avec les cameras bots).

En fait, il s'agit de déplacer un gobelin qui n'est pas armé ( -> en fait, s'il nous voit, il nous saute dessus et nous tappe sur la figure).

Donc je pensais à un etat "cherche" ou "ne se doute de rien" (ca dépend de mon humeur ^^), ou il peut marcher par-ci par-là, et puis s'il nous voit (genre à 50m en terrain dégagé) ou quand on approche a plus de 2m sans qu'il nous voit (on fait quand meme du bruit en marchant...) il nous attaque, c'est-a-dire qu'il cours vers nous, ou qu'il nous cherche s'il nous voit plus (et au contact, il tappe).

Le coup de l'algo A* m'a l'air interessant (quoique compliqué et peut être remplaçable par une autre méthode), je vais y jeter un oeil. Mais en fait, pour déplacer les IAnimatedSceneNode (vu que je fais plus de camera), les déplacer à chaque loop d'un pixel avec un ->setPosition(truc) en utilisant une 3dline entre le joueur et le bot (et encore, ca je sais pas faire pour l'instant), c'est pas un peu bourrain au niveau de la programmation ?

Moi ce qui m'arrangerait, ce serait un code téléchargeable pour les bots ^^ mais je dois surement rever pour vouloir trouver ca...

Dernière modification par aenahel (06-07-2007 20:29:20)

Hehe effectivement là tu rêves, si tu veux de l'ia tu te la programmes c'est comme ça que ça marche .
Sinon une IA peut également prendre en compte le FOV (Field Of View en fr ça donne Champ de vision) du personnage, ça te permet de faire un test sur la distance et le champ de vision pour déclencher un évenement de ton IA.
@+

alala les IA c'est quelque chose qui peut etre très très compliqué ^^
mais en général ca marche comme ca :
- Au début ton ennemi est super con, il avance tout droit.
- Ensuite tu lui donne des points à rechercher, par exemple pour une ronde ou bien toi. pour cela le mieux est un pathfinding s'il te vois ou s'il retourne dans son chemin de ronde qui lui est prédéfinis.
- Pour trouver les points, il faut ce que l'on appel une line of sight, en gros ca permet de determiner si un ennemi vois l'adversaire. si on utilise un simple calcul de distance alors l'ennemi nous trouvera dans son dos ET aussi à travers les murs O_o.
Je ne sais pas comment faire le LOF en C++, moi j'utilise un petit masque qui va vers le joeuur en ligne droite et qui est détruit si il touche un mur, si il touche le joueur alors il peut le voir. j'utilise un cone également pour représenter la vision de l'ennemi et en plus du masque, le joueur dois etre dans le cone (du coup il vois pas derrière), evidement c'est une très mauvaise solution et il dois bien sur y avoir de meilleurs moyens de le faire en C++.
- La distance peut etre utilisé pour les oreilles de l'ennemi. L'ennemi peut entendre le joueur arriver en courant mais peut etre pas en marchant
- Ensuite tu peut découper ta map avec emplacement plus ou moins couvert et ordonner à l'ennemi de s'y abriter s'il te vois pour te tirer desssu (mais bon là apparement ce n'est pas ton cas)

Enfin bref pour finir, oublie pas la Line of sight google te permettra surement d'en trouver des algos qui te convienent

Il me faudrait un truc similaire.
Si tu as une réponse concluante ce serait simpa de me prévenir.
De mon coté je cherche une solution sur papier que je reprogrammes comme je peux.

Merci d'avance.

Gp2mv3

Voila j'ai la solution sur papier mais en prog il faudra longtemps.

Gp2mv3

J'ai presque fini ma lib de pathfinding A* je la posterai d'içi 1 - 2 semaines grand maximum le temps de fignoler quelques trucs. Donc si ça t'intéresse...

@ Perceval : je connaissais pas micropather, mais en fait ca se rapproche pas mal de se que je fais. A part que ça supporte apparemment pas les graphes 3D

salut,

De retour de vacance il a une tonne de new topic , je commence par celui la car l'ia c'est une passion.
Donc deja comme tous l'on plus ou moins dit l'idée de camera est tres mauvaise car elle consomera enormement de ressource et cela juste pour eviter de programmer une fonction "move" et "trun" ( qui sont tres simple a faire en 2D comme ici pour le FPS qui est groso-modo du 2D ) c'est domage.
Pour la "vision" c'est tres simple il y a une merveille mathematique qui la chose la plus utilise en multi-dimension c'est .... LE PRODUIT SCALAIRE , et oui tres pratique pas groumand , bref genial , Pourquoi ?

un premier vecteur : position perso-position perso
un second vecteur  : où regarde le bot ( tete ou corps selon si il bouge la tete ou pas )

produit scalaire des deux = norme de l'un * norme de l'autre * COS( angle entre  les vecteurs )
( notation =  <.|.> ou (.|.) )
( dotProduct  pour irrlicht, a voir ds la doc )

donc en gros si tu travaille ac des vecteurs normlisés sa te donne une valeur entre -1 et 1 ou :

1=en face
0=Pi rad
-1=derrier

donc au finale ca donne le cone de l'aigle (Eagle4 parle de LOF ) avec un simple teste du style if( (v1|v2)<0.5 ) ...
qui se traduit par si le joueur est des le champ de vision du bot qui est un cone a PI/4 rad d'angle .


Si ta map est simple tu fais un gros cadrillage pour les testes des murs sinon tu fait ca avec un systeme de collision
Pour les deplacements le plus simple comme tous l'on dit aussi c'est un pathfinding  ( A*, Dijkstra en n*log(n) donc faible consomation CPU ).
ton ia est fini ( la plus basique qui soit mais qui marche et peut faire une base evolutive  )
Pour l'aspect modulable de  l'ia ( tu parle de dl une ia ) fait le en script ( LUA par exemple ) tu y perds en performence mais si c'est bien codé cela reste raisonnable.

Voila j'espere que ca t'aidera un peut

Génial !
Je pensais pas que ce test était aussi simple et rapide que çà. Un grand merci pour cette précision

Pour les collisions, tu peux après avoir détecté le joueur lancer un rayon du bot jusqu'au joueur et tester si il est en collision avec la map.

Si oui, le joueur n'est pas visible et est de l'autre côté d'un mur ou planqué derrière une caisse.

Bon bah je crois que je vais arreter de me casserr la tete alors et passer à cette solution.

Merci en tout cas.

Gp2mv3