J´avais vu une fois sur un site il expliquer l´algorithme d´une ai d´un jeu de pong, il expliquer qu´il faut donner un facteur ou l´ordinateur arrete de suivre la balle pendant quelque secondes, j´essaye de trouver le site et jte lenvoi ( par contre c´est pas sure que jle trouve le site jlavais trouver sur google mais jmen souvien plus avec quel mot clef)

Ce que je veut est ecris dedans http://www.allegro.cc/manmanual/view_category.php?_id=5 mais ayant des lacune en anglais quelqune pourais m´aider svp

J´ai trouver un truc qui peut tinterresser jejej,
http://www.ifrance.com/arthurbro/devcpp.html
tu clique sur pong dans le menu jeu et ensuite sur comment programmer le jeu ( le jeu et fait sous allegro mais sa doit pas etre trop difficile d´adapter) et a la fin il texplique une partit pour faire une ia non parfaite

poukoi on a supprimer tous mes topics?
c´etait bien sur RPGmaker!
on m´en veut?

et aussi sur le lien que je vien de donner il explique que pour que le jeu va a la meme vitesse sur tout les ordi, il faut faire deux boucle principale, une logic qui gere les deplacement et qui sera executer selon le timer, et une boulce d´affichage qui sera executer selon la vitesse de l´ordi, mais je sais pas comment faire

il dise sa sur le site:

"

Si vous programmez des jeux, il vous est déjà sûrement arrivé de voir un jeu tourner à une vitesse parfaite sur votre ordinateur, mais trop lentement ou trop rapidement sur un autre. La solution est d´utiliser un timer.

Vous devez tout d´abord diviser votre code en 2 parties :

La boucle " logique" ( qui déplace les sprites, détecte les collisions...)
La boucle " graphique" ( qui affiche tout sur l´écran)
Pour que la vitesse d´un jeu soit constante quel que soit l´ordinateur, il faut que la boucle logique soit exécutée en priorité ( car c´est elle qui gère toutes les données), et ce un certain nombre de fois par secondes.
Quant à la boucle graphique, elle sera exécutée à chaque fois qu´on le pourra : c´est à dire souvent sur un ordinateur rapide, et moins souvent sur un ordinateur moins rapide.

Voilà à quoi doit ressembler votre code :

volatile int target_game_time = 0;

void increment_target_game_time()
{
target_game_time++;
}
END_OF_FUNCTION(increment_target_game_time);

int play_game()
{
int actual_game_time = 0, ok_to_draw = TRUE;

LOCK_VARIABLE(target_game_time);
LOCK_FUNCTION(increment_target_game_time);

install_int_ex(increment_target_game_time, BPS_TO_TIMER(50));

while(!done)
{
while(actual_game_time < target_game_time)
{
logic_loop();
actual_game_time++;
ok_to_draw = TRUE;
}

if(ok_to_draw)
{
graphics_loop();
ok_to_draw = FALSE;
}
}

remove_int(increment_target_game_time);
return 0;
}

Commentaires :

Les variables et fonctions relatives au timer doivent être verrouillées, d´où l´utilisation des macros LOCK_VARIABLE() et LOCK_FUNCTION().

La fonction ´install_int_ex()´ installe un timer de telle manière que le fonction ´increment_target_game_time()´ sera appelée 50 fois par seconde.

La variable ´target_game_time´ est un compteur, qui est incrémenté par ´increment_target_game_time()´. A tout moment, il indique combien de fois le programme devrait avoir exécuté la boucle logique ( "logic_loop()").

La variable ´actual_game_time´ est aussi un compteur, qui est incrémenté à chaque exécution de la boucle logique ( "logic_loop()"). Il permet donc de mesurer le nombre d´exécutions de cette boucle.
Comme vous pouvez le voir, tout se joue à travers les variables ´actual_game_time´ et ´target_game_time´ : la première " essaie" de rattraper la seconde. Si elle y parvient, la boucle graphique est exécutée.
La variable ´ok_to_draw´ sert uniquement à empêcher le programme d´exécuter la boucle graphique 2 fois de suite ( ou plus) : cela ne servirait à rien car rien n´aurait eu le temps de bouger sur l´écran.
"

je crois avoir compris, je vous dit sa demain soir ou apres demain, mais une explication suplementaire ne serais pas de refus

slt je voudrais savoir si quelqu´un connais un site ou je pourrais trouver des chipset de golden sun j´en trouve pas bcp

demain je tle diré ^^

ok

Merci Jeanyvesyves, pour les fonctions sur les puissances $1.9 je comprend je pence

golder sun att je crois ^^ att

nan j´ai révé sorry ^^

pour ce qui est de l´heure si vous voulez un truc super précis, mais qui ne donne que des différence de temps et non pas une heure réelle, il faut utiliser les fonction

QueryPerformanceFrequency et QueryPerformanceCounter dont la fréquence est aproximativement la même que celle de votre processeur.

Par contre il faut utiliser des long long. Leur support est natif sous VC++ ( il faut utiliser le type __int64) mais sous dev c++ je ne sais pas comment faire autre qu´en utilisant le type de windows LARGE_INTEGER qui n´est pas très pratique car il n´y a pas d´opération dessus.

Si quelqu´un sait comment utiliser des entier de 64 bits avec Dev C++ ça m´arrangerait bcp.
Car j´ai une lib que j´essaye d´écrire de manière à ce que je puisse la compiler sous dev c++ et sous vc++ mais depuis que j´ai besoin de large_integer c´est plus possible.
( je la releaserai pour vous bientot).

Il me semble que c´est
long long
car c´est sur une base de gcc

Sinon, en effet QueryPerformanceFrequency est tres précis.
timegettime de mmsystem.h l´est aussi également.
La truc a proscrire pour les calcul précis, c´est time.h

C´est quoi le " C/C++" ? ?

sisi , Dno700 , je crois que le long long est supporte aussi par dev-cpp
en tout cas , il ne produit pas d´erreur à la compilation . ..

ah par contre , il est que de 8 bit
( ou alors c´est des octets je sais pas , ca donne en quoi sizeof ? )

qd on passe des tableau ds les fonctions :
void fonc2(int t[][6])
{
t[2][1]=20;
}

void fonc3(int t[][3][2])
{
t[2][1][1]=30;
}
a un
tablo a une dimension , on met rien mais pour la 2eme 3eme dimension , on met un chiffre :
ce chiffre est til important ou ne sert til qua remplir la case []?
ceci " void fonc3(int t[][3][2]) " peut til avoir le meme resultat si on met
" void fonc3(int t[][2][3]) " ? ??

pour éviter de te mélanger comme ça arrivera toutes les 22 secondes avec ce genre de tableaux, tu devrais plutot penser à n´utiliser que des tableaux unidimensionnel ( avec offset pour les différentes composantes). Dans ton cas, le fait que ça puisse marcher dépend de la façon dont tu as initialiser tout ça...