Souci avec generation aléatoire d'un entier

**donkeyquote** · 20/01/2008, 12h53

Bonjour à tous,

Je suis en train de faire une petite appli qui fait la simulation d'une guerre entre 2 peuples.
Chaque guerrier vise un énemi du peuple contraire de façon aléatoire... et c'est là qui se pose mon pb.

Pour le premier attaque la generation aléatoire de l'énémie se passe bien, mais pour la replique de l'attaque le numéro qui est généré aléatoirement se repète dans la boucle de l'attaque, c'est à dire, on n'attaque qu'au même élément... alors que le mêmebre attaqué devrait se faire de façon aléatoire...

Je vous montre le code qui sera plus parlant ...

ICI rand() MARCHE BIEN... dans la méthode void Human::attack(Player * iAttackedPlayer)

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
#include "Human.h"
#include <time.h>
#include "Archer.h"
#include "Catapulte.h"
#include <iostream>
 
// Constructors/Destructors
Human::Human(int iNumberOfHumanArchers, int iNumberOfHumanCatapultes) :
 _numberOfHumanArchers(iNumberOfHumanArchers),
 _numberOfHumanCatapultes(iNumberOfHumanCatapultes)
{
for (int i =0; i<iNumberOfHumanArchers; i++)
	destructibleElementsHandler().push_back(new Archer());
 
for (int i =0; i<iNumberOfHumanCatapultes; i++)
	destructibleElementsHandler().push_back(new Catapulte(10,20));
 
}
 
Human::~Human()
{
}
 
 
void Human::attack(Player * iAttackedPlayer) 
{
std::vector<DestructibleElement*>::iterator iter;
 
int elementAttacked = 0, count2 = 0;
 
std::cout<<"Number of elements Human"<<destructibleElementsHandler().size() <<std::endl;
 
// Setting which one from the army will attack to the elementAttacked
	for (iter=destructibleElementsHandler().begin(); iter!=destructibleElementsHandler().end(); iter++)
	{	std::cout<<"Number of offender"<<count2++ <<std::endl;
		srand (time(NULL));
		// Setting the element to attack
		elementAttacked = rand() % (iAttackedPlayer->destructibleElementsHandler().size()-1);
		std::cout<<"Size list of Computer"<<iAttackedPlayer->destructibleElementsHandler().size() <<std::endl;	
		// Launching the attack
		(*iter)->attack(iAttackedPlayer->destructibleElementsHandler()[elementAttacked]);
 
		std::cout<<"££££££££££££££"<<rand() <<std::endl;
		std::cout<<"Element attacked from list of Computer"<<elementAttacked <<std::endl;
		char c;
		std::cin>>c;		
	}
 
}
 
void Human::recruitement()
{
 
double  aRatioArchers=0, aRatioCatapultes = 0;
 
for (int i = 0 ; i< (int) (destructibleElementsHandler().size()*aRatioArchers) ; i++)
	destructibleElementsHandler().push_back(new Archer());
 
for (int i = 0 ; i< (int) (destructibleElementsHandler().size()*aRatioCatapultes); i++)
	destructibleElementsHandler().push_back(new Catapulte());
}
 
 
void Human::bury()
{
  std::vector<DestructibleElement*>::iterator iter;
 
for (iter=destructibleElementsHandler().begin(); iter!=destructibleElementsHandler().end(); iter++)  
	if ((*iter)->getPointsOfLife()<0)
	{
		destructibleElementsHandler().erase(iter);
		std::cout<<"Burying "<< *iter << " " <<std::endl;
	}
}
 
void Human::statistics(int iYear)
{
	std::cout<<"Number of elements for Human Year "<< iYear << " " << destructibleElementsHandler().size()<<std::endl;
 
	char c;
 
	std::cin>>c;
 
}

ICI rand() NE MARCHE PAS. TOUJOURS LE MEME NUMERO ALEATOIRE. Méthode void Computer::attack(Player * iAttackedPlayer)

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
#include <ctime>
#include "Computer.h"
#include "Catapulte.h"
#include "Archer.h"
#include "Gate.h"
#include "Wall.h"
#include "Tower.h"
#include "Game.h"
#include <iostream>
 
// Constructors/Destructors
  Computer::Computer(int iNumberOfComputerArchers, 
	   	     int iNumberOfComputerCatapultes, 
	   	     int iNumberOfComputerGates, 
	   	     int iNumberOfComputerWalls,
	   	     int iNumberOfComputerTowers) :
	 _numberOfComputerArchers(iNumberOfComputerArchers),
 	 _numberOfComputerCatapultes(iNumberOfComputerCatapultes),
	 _numberOfComputerGates(iNumberOfComputerGates),
	 _numberOfComputerWalls(iNumberOfComputerWalls),
	 _numberOfComputerTowers(iNumberOfComputerTowers)
{
for (int i =0; i<iNumberOfComputerCatapultes; i++)
	destructibleElementsHandler().push_back(new Catapulte());
 
for (int i =0; i<iNumberOfComputerArchers; i++)
	destructibleElementsHandler().push_back(new Archer());
 
for (int i =0; i<iNumberOfComputerGates; i++)
	destructibleElementsHandler().push_back(new Gate());
 
for (int i =0; i<iNumberOfComputerWalls; i++)
	destructibleElementsHandler().push_back(new Wall());
 
for (int i =0; i<iNumberOfComputerTowers; i++)
	destructibleElementsHandler().push_back(new Tower());
 
}
 
Computer::~Computer()
{
}
 
 
void Computer::attack(Player * iAttackedPlayer) 
{
std::vector<DestructibleElement*>::iterator iter;
 
int elementAttacked = 0;
// Setting the element to attack
 
// Setting which one from the army will attack to the elementAttacked
//In the case of the city, only 25% of the army can defend
int count = 0, aSizeArmy = destructibleElementsHandler().size();
 
for (iter=destructibleElementsHandler().begin(); iter!=destructibleElementsHandler().end(); iter++, count++)
{
 
 
	if (aSizeArmy*0.25>count)
	{	
		srand (time(NULL));
		elementAttacked = rand() % iAttackedPlayer->destructibleElementsHandler().size();
    		(*iter)->attack(iAttackedPlayer->destructibleElementsHandler()[elementAttacked]);
		std::cout<<"Size Human list ########"<<iAttackedPlayer->destructibleElementsHandler().size() <<std::endl;
		std::cout<<"Element attacked from list ########"<<elementAttacked <<std::endl;
		std::cout<<"Rand ########"<<rand() <<std::endl;	
		std::cout<<"Counter ########"<<count <<std::endl;
	}
 
	else
		break;	
}
 
 
}
 
void Computer::recruitement()
{
 
double  aRatioArchers=0, aRatioCatapultes = 0;
 
for (int i = 0 ; i< (int) (destructibleElementsHandler().size()*aRatioArchers) ; i++)
	destructibleElementsHandler().push_back(new Archer());
 
for (int i = 0 ; i< (int) (destructibleElementsHandler().size()*aRatioCatapultes); i++)
	destructibleElementsHandler().push_back(new Catapulte());
}
 
 
void Computer::bury()
{
  std::vector<DestructibleElement*>::iterator iter;
 
for (iter=destructibleElementsHandler().begin(); iter!=destructibleElementsHandler().end(); iter++)  
	if ((*iter)->getPointsOfLife()<0)
	{
		destructibleElementsHandler().erase(iter);
		std::cout<<"Burying "<< *iter << " " <<std::endl;
	}
}
 
 
void Computer::statistics(int iYear)
{
	std::cout<<"Number of elements for Computer Year "<< iYear << " " << destructibleElementsHandler().size()<<std::endl;
 
	char c;
 
	std::cin>>c;
}

L'appel des méthodes...

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
 
void Game::run()
{
	std::vector<Player*>::iterator iter, aux;
 
//considering each attack takes place in a day
int jj=1;
for (int i=0; i<365; i++)
//FIXME
	//consider thread implementations in order to obtain a fair attack
	for (iter=_ListPlayers.begin(); iter != _ListPlayers.end(); iter++)
	{
		(*iter)->bury();
		std::cout<<"@@@@@pase "<<jj++<<std::endl;
		std::cout<<"$$$$$$$$size of players"<<_ListPlayers.size()<<std::endl;
		for (aux =_ListPlayers.begin(); aux != _ListPlayers.end(); aux++ )
			if ((*aux) != (*iter))
				{
				std::cout<<"Offender ->"<<*iter<<" Offended ->"<<*aux<<std::endl;
				doAttack(*iter, *aux);
				}
 
		//display the statistics for each Player
		(*iter)->statistics(i);
 
		(*iter)->recruitement();
	}
}

Quelqu'un pourrais me dire pourquoi ?

Merci de votre aide !!

**Sylvain Togni** · 20/01/2008, 13h36

La fonction srand() doit être appelée UNE fois au début du programme, elle sert à initialiser le générateur.

**donkeyquote** · 20/01/2008, 13h55

Hmmm....

Surement tu as raison en disant qu'il faut l'appeler une seule fois dans le programme...

Je l'ai mise (une seule fois dans tout le code) dans Game::run() et cela n'a pas marche, en suite je l'ai mise (une seule fois dans tout le code) sur main.cpp et même problème....

D'autres suggestions ?

**NiamorH** · 20/01/2008, 14h10

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
  srand (time(NULL));
  // Setting the element to attack
  elementAttacked = rand()

Pas besoin d'autre suggestion, il a raison : comme le code est écrit, le comportement que tu décris est normal.

Refais des tests avec srand initialisé dans le main et soit sûr qu'il ne le soit pas ailleurs. Sinon c'est qu'il y a en plus une autre erreur ailleurs. Mais srand ne doit être initialisé qu'une fois, c'est une certitude.

[EDIT] De plus :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

elementAttacked = rand() % (iAttackedPlayer->destructibleElementsHandler().size()-1)

Attention ! Tu risque de faire des modulos par 0, voire -1. Je ne pense pas que le modulo soit un bon choix ici.

**donkeyquote** · 20/01/2008, 18h18

NiamorH,
Je n'ai aucun doute que vous avez raison et qu'il faut juste initialiser une seule fois dans le main avec srand().
Je l'ai fait, mais pas de résultats satifaisant.

Je pense que tu as raison et qu'il y a une autre erreur quelque part mais je n'ai pas réussi a trouver.
Je mets tous les fichiers en pièce jointe au cas où quelqu'un veux me donner un coup de main avec cette histoire.

(Désole si le code est un peu sale à cause des traces...)

Sinon, merci pour l'histoire du module... je vais corriger. De toutes façons une exception "gameOver" sera prévue dès que le problème sera resoulu dans le cas où la liste est vide.