[C++14] Génération de nombres pseudoaléatoires

Version imprimable

Bonjour, je suis en train de coder un petit jeu ~~car je me fais sérieusement chi*r~~ pour passer le temps et j'ai un petit problème avec celui-ci. Le problème vient du fait que j'ai voulu créer des nombres aléatoires différents à chaque lancement de mon programme, donc rien de plus simple qu'un petit std::time(nullptr) comme seed de générateur. Sauf que j'avais oublié une chose, c'est que std::time retourne un temps en secondes ce qui n'est pas très safe et aléatoire et pour une raison inconnue à cause de ceci mon programme plante ( peut-être que si la seed est la même pour deux générateurs il y a une exception non gérée ? ) donc j'ai voulu essayer de créer un seed avec ceci :

Code:

1
2
3
 
std::chrono::time_point<std::chrono::system_clock> temps = std::chrono::system_clock::now();
auto const seed = temps;

Mais cela ne fonctionne pas et ni ceci :

Code:

1
2
3
 
std::chrono::time_point<std::chrono::system_clock> temps = std::chrono::_V2::system_clock::now();
auto const seed = temps;

et encore moins celui là :

Code:

1
2
 
auto const seed = std::chrono::system_clock::now();

Bref j'ai essayé pas mal de choses mais les erreurs de conversions sont inébranlable ( même via du static_cast etc... )

Donc j'ai deux demandes :
1 - Es que quelqu'un connais un bon générateur ( fournit avec la stl ) non déterministe avec un code à me proposer pour la seed ( si seed il y a.. ) ?
2 - Es normal et pourquoi mon programme plante une fois sur 2 avec mes générateurs ?

Je vous remercie :)

Ps : Si un peu de code vous intéresse, le voici :

Spell.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
#ifndef Spell_included
#define Spell_included
 
#include <iostream>
#include <random>
#include <chrono>
 
class Spell
{
public:
 
    Spell();
    Spell( std::string const &name, unsigned short const &dmgMin, unsigned short const &dmgMax, unsigned short const &dmgCritMin, unsigned short const &dmgCritMax );
 
    std::string name() const;
    unsigned short dmg() const;
    unsigned short dmgCrit() const;
 
private:
 
    std::string const spell_name;
    unsigned short const spell_dmg_min;
    unsigned short const spell_dmg_max;
    unsigned short const spell_dmg_crit_min;
    unsigned short const spell_dmg_crit_max;
};
 
#endif // Spell_included

Spell.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
#include "Spell.hpp"
 
Spell::Spell() : spell_name{"???"}, spell_dmg_min{0}, spell_dmg_max{0}, spell_dmg_crit_min{0}, spell_dmg_crit_max{0}
{
 
}
 
Spell::Spell( std::string const &name, unsigned short const &dmgMin, unsigned short const &dmgMax, unsigned short const &dmgCritMin, unsigned short const &dmgCritMax ) : spell_name{name}, spell_dmg_min{dmgMin}, spell_dmg_max{dmgMax}, spell_dmg_crit_min{dmgCritMin}, spell_dmg_crit_max{dmgCritMax}
{
 
}
 
std::string Spell::name() const
{
    return spell_name;
}
 
unsigned short Spell::dmg() const
{
    auto const seed = std::time(nullptr);
    std::default_random_engine engin { seed };
    std::normal_distribution<float> distrib( spell_dmg_min, spell_dmg_max );
    return static_cast<unsigned short>(distrib(engin));
}
 
unsigned short Spell::dmgCrit() const
{
    auto const seed = std::time(nullptr);
    std::default_random_engine engin { seed };
    std::normal_distribution<float> distrib( spell_dmg_crit_min, spell_dmg_crit_max );
    return static_cast<unsigned short>(distrib(engin));
}

Monster.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
#ifndef Monster_included
#define Monster_included
 
#include <iostream>
#include <vector>
#include <tuple>
#include <random>
#include <chrono>
 
#include "Spell.hpp"
 
class Monster
{
public:
 
    Monster();
    Monster( std::string const &name, unsigned int const &level, unsigned short const &actions, unsigned int const &life, unsigned int const &xpToDrop, float const &force, std::vector<Spell> const &spells );
    ///constructeur copie
    std::string name() const;
    std::vector<std::tuple<std::string, unsigned int, bool>> attack() const;
    unsigned int getXp() const;
    unsigned int life() const;
    unsigned int maxLife() const;
    unsigned int level() const;
    bool isAlive() const;
 
private:
 
    std::string const monster_name;
    unsigned int monster_life_max;
    unsigned int monster_life;
    unsigned int const monster_drop_xp;
    unsigned int const monster_level;
    float monster_force;
    std::vector<Spell> monster_spells;
    unsigned short monster_actions;
    float monster_critical_chance;
 
};
 
#endif // Monster_included

Monster.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
#include "Monster.hpp"
 
Monster::Monster() : monster_name{"???"}, monster_life_max{0}, monster_life{0}, monster_drop_xp{0}, monster_level{0}, monster_force{0}, monster_actions{0}, monster_critical_chance{0}
{
    monster_spells.push_back(Spell());
}
 
Monster::Monster( std::string const &name, unsigned int const &level, unsigned short const &actions, unsigned int const &life, unsigned int const &xpToDrop, float const &force, std::vector<Spell> const &spells ) : monster_name{name}, monster_life_max{life}, monster_life{life}, monster_drop_xp{xpToDrop}, monster_level{level}, monster_force{force}, monster_spells{spells}, monster_actions{actions}
{
    monster_critical_chance = 90.0f;
}
 
std::string Monster::name() const
{
    return monster_name;
}
 
std::vector<std::tuple<std::string, unsigned int, bool>> Monster::attack() const
{
    std::vector<std::tuple<std::string, unsigned int, bool>> attacks;
 
    auto const seed = std::time(nullptr);
    std::default_random_engine engin { seed };
    std::normal_distribution<float> distrib( 0, static_cast<float>(monster_spells.size()) - 1);
    std::uniform_int_distribution<> crit(static_cast<int>(monster_critical_chance),100);
    unsigned int selector{0};
 
    for( size_t i{0}; i < monster_spells.size(); ++i )
    {
        selector = static_cast<unsigned int>(distrib(engin));
        if( crit(engin) == 100 )
            attacks.push_back(std::make_tuple(monster_spells[selector].name(), static_cast<unsigned int>(monster_spells[selector].dmgCrit() * monster_force), true ));
        else
            attacks.push_back(std::make_tuple(monster_spells[selector].name(), static_cast<unsigned int>(monster_spells[selector].dmg() * monster_force), false ));
    }
    return attacks;
}
 
unsigned int Monster::getXp() const
{
    return monster_drop_xp;
}
 
unsigned int Monster::life() const
{
    return monster_life;
}
 
unsigned int Monster::maxLife() const
{
    return monster_life_max;
}
 
unsigned int Monster::level() const
{
    return monster_level;
}
 
bool Monster::isAlive() const
{
    bool b{false};
    b = monster_life == 0 ? false : true;
    return b;
}

PPs : Veuillez m'excuser de la non propreté du code ( il n'est pas commenté aussi x) ) c'est encore un brouillon :p
- d'ailleurs il y à plusieurs fautes comme par exemple le i de la boucle for de attack() qui est useless et qui n'est d’ailleurs pas comparé avec la bonne chose.
- et je viens de remarqué que c'est une grosse connerie de créer mon générateur dans une fonction

19/07/2016, 22h29
JolyLoic

Je n'ai pas lu ton code, mais pour initialiser un générateur de nombres aléatoires, std::random_device est très bien
http://en.cppreference.com/w/cpp/num.../random_device

Hello

La solution de JolyLoic est la bonne.

En revanche, je pense que tu devrais t'intéresser à ton fameux problème de conversion, car ça risque de te servir pour d'autres parties de ton jeu. Dans la STL, now() est un time_point, un point isolé dans le temps. Cela ne se mesure pas ! Le fait que ce soit représenté en temps depuis EPOCH est un détail d'implémentation. En revanche, ce qui se mesure, c'est la distance entre deux time_point, et ceci est représenté par duration, qui lui peut se mesurer et donc être converti en entier.

Pour obtenir un entier comme tu as cherché à le faire il faut donc : prendre la date actuelle, mesurer sa distance à EPOCH, puis convertir cela en entier. Ce qui nous donne, par exemple:
Code:

1 2 3 4 5 6 7 8 9 10 #include <chrono> int main(void) { using namespace std::chrono; // Truc basique auto const integral_number = system_clock::now().time_since_epoch().count(); // Pour avoir plus de précision et choisir l'unité auto const integral_number_ms = duration_cast<milliseconds>(high_resolution_clock::now().time_since_epoch()).count(); return 0; }
Et enfin dernière remarque, il est rare d'avoir besoin de sécurité pour un générateur de jeu, il suffit que la seed change à chaque partie et qu'il soit assez bon pour être agréable au gameplay. Les générateurs sécurisés sont plus lourd à l'exécution sans forcément un réel apport au gameplay.

Je vous remercie pour vos réponses et donc je vais tester le code et ci cela ne plante pas le sujet sera résolu :p

Citation:

Envoyé par JolyLoic

Je n'ai pas lu ton code, mais pour initialiser un générateur de nombres aléatoires, std::random_device est très bien
http://en.cppreference.com/w/cpp/num.../random_device

Random device ne prend pas de seed et n'est pas du tout aléatoire vu qu'a chaque exécution c'est la même chose :p
Citation:
Envoyé par jblecanard
Hello

La solution de JolyLoic est la bonne.

En revanche, je pense que tu devrais t'intéresser à ton fameux problème de conversion, car ça risque de te servir pour d'autres parties de ton jeu. Dans la STL, now() est un time_point, un point isolé dans le temps. Cela ne se mesure pas ! Le fait que ce soit représenté en temps depuis EPOCH est un détail d'implémentation. En revanche, ce qui se mesure, c'est la distance entre deux time_point, et ceci est représenté par duration, qui lui peut se mesurer et donc être converti en entier.

Pour obtenir un entier comme tu as cherché à le faire il faut donc : prendre la date actuelle, mesurer sa distance à EPOCH, puis convertir cela en entier. Ce qui nous donne, par exemple:
Code:

1 2 3 4 5 6 7 8 9 10 #include <chrono> int main(void) { using namespace std::chrono; // Truc basique auto const integral_number = system_clock::now().time_since_epoch().count(); // Pour avoir plus de précision et choisir l'unité auto const integral_number_ms = duration_cast<milliseconds>(high_resolution_clock::now().time_since_epoch()).count(); return 0; }
Et enfin dernière remarque, il est rare d'avoir besoin de sécurité pour un générateur de jeu, il suffit que la seed change à chaque partie et qu'il soit assez bon pour être agréable au gameplay. Les générateurs sécurisés sont plus lourd à l'exécution sans forcément un réel apport au gameplay.
J'ai tester avec ton code là c'est pire ça plante tout le temps ^^"

20/07/2016, 18h31
jblecanard

Hello

"Ca plante tout le temps" n'est pas une information très précise, et ça ne veut pas dire que le générateur y soit pour quelque chose. Ca plante comment ? Où ? Pourquoi ? Utilises un débugger et si tu es sous Linux ou Mac OS, exécutes un coup avec Valgrind pour voir...

J'ai regardé ton code, et tu n'utilises pas le générateur correctement. Un générateur aléatoire est une machine à état. Lorsque tu appelles ta fonction membre attack(), tu crées un générateur à chaque fois. Il ne faut pas : il faut créer un générateur une seule fois que tu réutilises. La seed n'est censée être utilisée qu'au démarrage du jeu, pas à chaque appel d'une génération aléatoire...
20/07/2016, 19h41
Disixlis

Oui je sais bien c'est pourquoi dans mon premier message j'ai dit que ce n'était qu'une grosse connerie donc à la place j'ai créer une fonction dnas mon main mais c'est deg, et c'est bel et bien à cause des générateur car j'ai tester avec des valeurs fixe et là plus aucun problèmes. Donc bon je sais pas trop quoi faire pour le coup
21/07/2016, 10h23
dragonjoker59

Juste comme ça, tu peux afficher les valeurs retournées par les distributions, lorsque tu les utilises pour accéder à un élément dans un tableau?
21/07/2016, 11h00
Bousk

Vu que tu rand des float, et cast en (unsigned) int/float dans tous les sens, pour sortir un index de tableau, comment être étonné que ça plante quelque part ?
21/07/2016, 13h14
Disixlis

Citation:

Envoyé par Bousk

Vu que tu rand des float, et cast en (unsigned) int/float dans tous les sens, pour sortir un index de tableau, comment être étonné que ça plante quelque part ?

Non ça ne peut pas planter car ça ne dépassera jamais la valeur max de l'index, par contre tu viens de me faire penser que tout ce qui est compris entre 0,000001 et 1 sera transformé en 1 donc il y a très peu de chance pour tomber sur le premier sort, donc oui je vois pas pourquoi je n'ai pas utilisé de générateur int :/ ? étant donné que c'est un brouillon c'était sûr qu'il y aurait des fautes de temps à autre, donc je vais tout corriger au maximum et je reviens vers vous, par contre quelqu'un à une meilleure idée d'où je devrai mettre mon générateur aléatoire ? car dans une fonction c'est bien beau même à chaque appel trop rapide je risque d'avoir les mêmes valeurs :p et même si j'ai une autre solution d'où mettre ceci, j'aimerais juste savoir où vous, vous l'auriez mis ? ( je ne sais pas si on peux passer un générateur en paramètre je vais regarder aussi ça mais ça à pas l'air très propre non plus )
21/07/2016, 14h01
dragonjoker59

Tu sais à quel endroit ça plante, avec un générateur aléatoire?
21/07/2016, 18h25
Disixlis

J'ai trouver l'erreur ! dans mon main j'avais simplement créer un aléatoire pour généré des monstre et j'avais oublié de faire - 1 à la taille de mon vecteur ! du coup maintenant cela ne plante plus ! Je vous remercie à tous pour votre aide ^^