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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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