Bonjour, désoler pour le dérangement
je suis en train de créer jeu 2D isométrique sur SDL en c avec generation des
énigmes
mais je suis bloqué comment faire pour affficher des images aléatoire sur SDL en
c ..
Bonjour, désoler pour le dérangement
je suis en train de créer jeu 2D isométrique sur SDL en c avec generation des
énigmes
mais je suis bloqué comment faire pour affficher des images aléatoire sur SDL en
c ..
Bonjour, désoler pour le dérangement
je suis en train de créer jeu 2D isométrique sur SDL en c avec generation des
énigmes
mais je suis bloqué comment faire pour affficher des images aléatoire sur SDL en
c ..
Bonjour,
Le 31/03/2018 23:29, eyaarmy a écrit :Bonjour, désoler pour le dérangement
Tu ne déranges pas, mais à l'avenir tu pourrais essayer de choisir un
titre plus explicite, et aussi de mieux expliquer ton besoin parce que
là tu en dis vraiment le minimum.je suis en train de créer jeu 2D isométrique sur SDL en c avec generation des
énigmes
mais je suis bloqué comment faire pour affficher des images aléatoire sur SDL en
c ..
Je vais supposer que tu sais déjà afficher une image avec SDL, et que
ton besoin est juste de choisir quelle image afficher, entre la numéro 0
et la numéro N-1, où N est le nombre d'images.
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Bonjour,
Le 31/03/2018 23:29, eyaarmy a écrit :
Bonjour, désoler pour le dérangement
Tu ne déranges pas, mais à l'avenir tu pourrais essayer de choisir un
titre plus explicite, et aussi de mieux expliquer ton besoin parce que
là tu en dis vraiment le minimum.
je suis en train de créer jeu 2D isométrique sur SDL en c avec generation des
énigmes
mais je suis bloqué comment faire pour affficher des images aléatoire sur SDL en
c ..
Je vais supposer que tu sais déjà afficher une image avec SDL, et que
ton besoin est juste de choisir quelle image afficher, entre la numéro 0
et la numéro N-1, où N est le nombre d'images.
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Bonjour,
Le 31/03/2018 23:29, eyaarmy a écrit :Bonjour, désoler pour le dérangement
Tu ne déranges pas, mais à l'avenir tu pourrais essayer de choisir un
titre plus explicite, et aussi de mieux expliquer ton besoin parce que
là tu en dis vraiment le minimum.je suis en train de créer jeu 2D isométrique sur SDL en c avec generation des
énigmes
mais je suis bloqué comment faire pour affficher des images aléatoire sur SDL en
c ..
Je vais supposer que tu sais déjà afficher une image avec SDL, et que
ton besoin est juste de choisir quelle image afficher, entre la numéro 0
et la numéro N-1, où N est le nombre d'images.
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Bonjour,
Le 01/04/2018 à 03:28, Pascal J. Bourguignon a écrit dans le message
:Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Et comme ça ?
int num_image;
assert(N > 0);
int limit = RAND_MAX - RAND_MAX % N;
int random_num;
do
random_num = random()
while (random_num >= limit);
num_image = random_num % N;
Bonjour,
Le 01/04/2018 à 03:28, Pascal J. Bourguignon a écrit dans le message
<m2o9j367gw.fsf@despina.home> :
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Et comme ça ?
int num_image;
assert(N > 0);
int limit = RAND_MAX - RAND_MAX % N;
int random_num;
do
random_num = random()
while (random_num >= limit);
num_image = random_num % N;
Bonjour,
Le 01/04/2018 à 03:28, Pascal J. Bourguignon a écrit dans le message
:Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Cordialement,
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Et comme ça ?
int num_image;
assert(N > 0);
int limit = RAND_MAX - RAND_MAX % N;
int random_num;
do
random_num = random()
while (random_num >= limit);
num_image = random_num % N;
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
Si c'est bien ça, tu peux utiliser la fonction random() -- en prenant
soin d'inclure <stdlib.h> -- par exemple comme ceci :
int num_image;
num_image = random() % N;
Attention, ce n'est pas aussi simple!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Même en supposant une distribution equiprobable, (on peut l'assumer,
car la période du pseudo-générateur est trés grande), le fait de partir
de 2^31-1 pour calculer le modulo va forcément introduire une
inhomogénéïté.
Par exemple, si on travaillait avec N, et 2^4-1, alors les nombres de
0 à 4 seraient deux fois plus probables qu'entre 5 et 9!
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
random() est spécifié pour générer des nombres pseudo aléatoires entre 0
et (2^31)-1, mais rien n'est dit sur la distribution.
Et comme ça ?
int num_image;
assert(N > 0);
int limit = RAND_MAX - RAND_MAX % N;
int random_num;
do
random_num = random()
while (random_num >= limit);
num_image = random_num % N;
Et comme ça ?
int num_image;
assert(N > 0);
int limit = RAND_MAX - RAND_MAX % N;
int random_num;
do
random_num = random()
while (random_num >= limit);
num_image = random_num % N;
Et comme ça ?
int num_image;
assert(N > 0);
int limit = RAND_MAX - RAND_MAX % N;
int random_num;
do
random_num = random()
while (random_num >= limit);
num_image = random_num % N;
Typiquement, regarde les generateurs pseudo-aleatoires congruents.
Tu verras qu'il ne faut jamais faire % N, mais passer en flottant
et diviser par RAND_MAX, multiplier par N et arrondir...
[int(i/16*9) for i in range(17)]
Apres, si tu veux des bons nombres aleatoires, soit tu as arc4random_uniform,
soit tu te choppes une implementation de ce dernier.
Si vraiment tu peux faire sans, confere numerical recipes et Mersenne
Twister.
En tout cas, c'est impossible de faire confiance a un bete rand()/random()
"portable" si tu veux un pseudo-aleatoire de qualite decente...
Typiquement, regarde les generateurs pseudo-aleatoires congruents.
Tu verras qu'il ne faut jamais faire % N, mais passer en flottant
et diviser par RAND_MAX, multiplier par N et arrondir...
[int(i/16*9) for i in range(17)]
Apres, si tu veux des bons nombres aleatoires, soit tu as arc4random_uniform,
soit tu te choppes une implementation de ce dernier.
Si vraiment tu peux faire sans, confere numerical recipes et Mersenne
Twister.
En tout cas, c'est impossible de faire confiance a un bete rand()/random()
"portable" si tu veux un pseudo-aleatoire de qualite decente...
Typiquement, regarde les generateurs pseudo-aleatoires congruents.
Tu verras qu'il ne faut jamais faire % N, mais passer en flottant
et diviser par RAND_MAX, multiplier par N et arrondir...
[int(i/16*9) for i in range(17)]
Apres, si tu veux des bons nombres aleatoires, soit tu as arc4random_uniform,
soit tu te choppes une implementation de ce dernier.
Si vraiment tu peux faire sans, confere numerical recipes et Mersenne
Twister.
En tout cas, c'est impossible de faire confiance a un bete rand()/random()
"portable" si tu veux un pseudo-aleatoire de qualite decente...
Bonjour,
Le 01/04/2018 à 22:49, Marc Espie a écrit dans le message
<p9rgkl$119v$ :Typiquement, regarde les generateurs pseudo-aleatoires congruents.
Tu verras qu'il ne faut jamais faire % N, mais passer en flottant
et diviser par RAND_MAX, multiplier par N et arrondir...
Là, j'avoue que je ne comprends pas pourquoi ce serait mieux que % N ;
bien au contraire, si je reprends l'exemple avec RAND_MAX et N et
que je joue un peu avec Python (je multiplie par N-1 sinon on se
retrouve avec N alors que l'on veut un nombre dans l'intervalle
[0, N[) :
En tout cas, c'est impossible de faire confiance a un bete rand()/random()
"portable" si tu veux un pseudo-aleatoire de qualite decente...
Sans doute, mais là on parle d'afficher une photo au hasard dans un jeu,
il faut donc relativiser.
Bonjour,
Le 01/04/2018 à 22:49, Marc Espie a écrit dans le message
<p9rgkl$119v$1@saria.nerim.net> :
Typiquement, regarde les generateurs pseudo-aleatoires congruents.
Tu verras qu'il ne faut jamais faire % N, mais passer en flottant
et diviser par RAND_MAX, multiplier par N et arrondir...
Là, j'avoue que je ne comprends pas pourquoi ce serait mieux que % N ;
bien au contraire, si je reprends l'exemple avec RAND_MAX et N et
que je joue un peu avec Python (je multiplie par N-1 sinon on se
retrouve avec N alors que l'on veut un nombre dans l'intervalle
[0, N[) :
En tout cas, c'est impossible de faire confiance a un bete rand()/random()
"portable" si tu veux un pseudo-aleatoire de qualite decente...
Sans doute, mais là on parle d'afficher une photo au hasard dans un jeu,
il faut donc relativiser.
Bonjour,
Le 01/04/2018 à 22:49, Marc Espie a écrit dans le message
<p9rgkl$119v$ :Typiquement, regarde les generateurs pseudo-aleatoires congruents.
Tu verras qu'il ne faut jamais faire % N, mais passer en flottant
et diviser par RAND_MAX, multiplier par N et arrondir...
Là, j'avoue que je ne comprends pas pourquoi ce serait mieux que % N ;
bien au contraire, si je reprends l'exemple avec RAND_MAX et N et
que je joue un peu avec Python (je multiplie par N-1 sinon on se
retrouve avec N alors que l'on veut un nombre dans l'intervalle
[0, N[) :
En tout cas, c'est impossible de faire confiance a un bete rand()/random()
"portable" si tu veux un pseudo-aleatoire de qualite decente...
Sans doute, mais là on parle d'afficher une photo au hasard dans un jeu,
il faut donc relativiser.