jeu motus en c

Version imprimable

20/02/2013, 16h08
sa7lia1990

jeu motus en c

salut tout le monde,
j'ai un mini-projet concernant le jeux motus.mon problème consiste à choisir le mot caché d'un fichier c'est à dire de lire un mot de fichier parmi une liste de mots.est ce que vous pouvez m'aider pour cette fonction?
merci d'avance :)
21/02/2013, 06h50
moins1

Ça dépend un peu comment ton fichier est fait. Je présume que tu veux avoir un choix de mot aléatoire. Dans ce cas tu vas devoir connaître le nombre de mots contenus dans le fichier ensuite aller le lire.

Plus précisément: après avoir initialisé les nombres aléatoires avec srand(), tu comptes les mots ensuite tu sors un nombre aléatoire avec rand() et tu vas lire le mot dans le fichier.

Avec 2 fonctions peut être

int CompterMot(void);
void LireMot(char s[], int nombreMot);

8-)
21/02/2013, 08h05
Bktero

Comme dit par moins1 (attention avec un tel pseudo quand même :mouarf: ), cela dépend de la structure de ton fichier. Une solution bête et simple est de mettre un mot par ligne, et de compter le nombre de ligne (avec fgets()) pour connaitre le nombre de mots. Tu tires un nombre aléatoire et va relire la bonne ligne. Il faut donc rajouter une fonction pour choisir ce nombre aléatoire.

c'est bon j'ai trouvé la solution la voila:

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
# include <time.h>
#include <stdio.h>
 
int main()
{
    int i,j,t;
    char mot[20][7];
    FILE *fichier;
    srand(time(NULL));
    t=rand()%20+1;
 
    fichier = fopen("6.txt", "r");
    for(i=0;i<20;i++)
    for (j=0;j<7;j++)
    {
        fscanf(fichier,"%c",&mot[i][j]);
    }
    for(j=0;j<7;j++)
    {
        printf("%c",mot[t][j]);
    }
 
    return 0;
 
}

avec le fichier 6.txt est enregistré ou le code etait enregistré

24/02/2013, 10h39
moins1

C'est une solution mais ton fichier ne va pas avoir que 20 ou 30 mots dans un jeu du motus. Tu ne vas pas faire un tableau de 600x7 ou 2300x7 si ton fichier grossis. D'où la proposition de compter les lignes ensuite de sortir un nombre aléatoire et aller lire ce mot. Cela rend aussi le programme indépendant du nombre de mots contenues dans le fichier.

Par ailleurs une fois le mots localisé, en utilisant fgets() pour le lire, t'aurais un mot sous forme de chaîne (avec le '\0') ce qui pourrait te faciliter la tâche.

:)
25/02/2013, 09h38
ternel

Une idée serait d'avoir le nombre de mot sur la première ligne du fichier.

ainsi, tu lis cette première ligne, tu alloues ton tableau, et tu lis.
27/02/2013, 17h28
AceSir

Salut :)

Une autre idée (encore :P) serait de coder une fonction qui lit une chaine de caractère dans un fichier, quelque soit sa taille.
Ainsi, il suffit d'appliquer l'idée de Bktero, puis de lire le mot grâce à cette fonction et le tour est joué :)

Le problème c'est que cette solution coûte cher. Mais si on mélange avec l'idée de leternel, ça permet de trouver bien plus rapidement le nombre aléatoire.

Mo-mo-mo-mo-motus ! (Pardon, c'était trop tentant :D)

Salut,

Je ne suis pas sur d'avoir compris ce que tu voulais faire ( on dirait que je suis le seul :aie:). Tu veux choisir aléatoirement un mot dans un fichier qui en contient un certain nombre pour ensuite le faire deviner ?

Si ton fichier est organisé en ligne comme suggéré précedemment :
fichier.txt
mot_1
mot_2
....
mot_n-1
mot_n.

Je ferais comme ceci :

Code:

1
2
3
4
5
 
 fichier = ouvrir(dictionnaire.txt)
 nbr_ligne = compter_ligne_fichier(fichier)
 ligne_aleatoire = (aleatoire() % nbr_ligne ) +1
 mot = extraire_ligne_fichier(ligne_aleatoire)

Voilà le code que je fais si cela peut t'aider à t'inspirer tout du moins :

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
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <errno.h>
 
typedef struct
{
    FILE *f;
    char *p;
    char *s;
    unsigned long long int l;
}t_file;
 
char *allocate_1D_c( unsigned long long int n )
{
    unsigned long long int i;
    char *p = NULL;
    if ((p = (char *)malloc(n*sizeof(char))))
        for ( i=0 ; i<n ; i++ )
            p[i]='\0';
 
    else printf("allocate.h::allocate_1D_c -> %s\n", strerror(errno));
 
    return p;
}
 
void deallocate_1D_c( char *p )
{
    if (p)
        free(p), p=NULL;
 
    else printf("deallocate.h::deallocate_1D_c -> %s\n",strerror(errno));
}
 
void file_close(FILE *f)
{
    if( !f )
        printf("file.h::file_close -> %s\n", strerror(errno));
 
    else fclose(f);
}
 
FILE *file_open(const char *p, const char *r)
{
    FILE *f = NULL;
    if ( !(f=fopen(p,r)) )
        printf("file.h::file_open -> %s\n", strerror(errno));
 
    return f;
}
 
void file_destroy( t_file *f )
{
    if (f)
    {
        if (f->p)
            deallocate_1D_c(f->p);
 
        if (f->s)
            deallocate_1D_c(f->s);
 
        free(f);
    }
    else printf("file.h::file_destroy -> %s\n", strerror(errno));
}
 
unsigned long long int str_length(const char *S)
{
    unsigned long long int c = 0;
    while( *S != '\0')
        c++, S++;
 
    return c;
}
 
unsigned long long int file_length( const char *p )
{
    char c;
    unsigned long long int l = 0;
    FILE *f = file_open(p,"r");
    while( fscanf(f,"%c",&c) != EOF )
        l++;
 
    file_close(f);
    return l;
}
 
unsigned long long int str_count_occurrence(char *s, char c)
{
    unsigned long long int o = 0;
    while( *s != '\0')
    {
        if ( *s == c )
            o++;
 
        s++;
    }
    return o;
}
 
char *str_copy(const char *S)
{
 
    unsigned long long int s_lengh = str_length(S);
    char *s = allocate_1D_c(s_lengh+1);
    s[s_lengh]='\0';
    unsigned long long int i;
    for ( i=0 ; i<s_lengh ; i++ )
        s[i]=S[i];
 
    return s;
}
 
char *file_to_string_1( const char *p )
{
    char c;
    unsigned long long int i = 0;
    char *s = allocate_1D_c( (file_length(p)+1)*sizeof(char) );
    FILE *f = file_open(p,"r");
    while( fscanf(f,"%c",&c) != EOF )
    {
        s[i] = c;
        i++;
    }
    s[i]='\0';
    file_close(f);
    return s;
}
 
t_file *file_create(char *s)
{
	unsigned int alloc_state = 0;
	t_file *f = NULL;
	if ( (f = (t_file*)malloc(sizeof *f)) )
	{
		if ( (f->p = str_copy(s)) )
		{
			if ( (f->s = file_to_string_1(s)) )
			{
				f->l = file_length(s);
				alloc_state = 1;
 
				if(!alloc_state)
					free(f->s), f->s=NULL;
			}
 
			if(!alloc_state)
				free(f->p), f->p=NULL;
		}
 
		if(!alloc_state)
			free(f), f=NULL;
	}
	return f;
}
 
 
 
unsigned long long int line_search_index( t_file *f, unsigned long long int line )
{
    unsigned long long int i, line_count, line_index;
    line_count=0;
    line_index=0;
    for (i=0 ; i<f->l ; i++ )
    {
        if ( f->s[i] == '\n' )
            line_count++;
 
        if ( line_count == line - 1 )
            i=f->l;
 
        line_index++;
    }
    return line_index;
}
 
char *extract_line( t_file *f, unsigned long long int line )
{
    unsigned long long int length=1;
    unsigned long long int line_index = line_search_index(f, line);
    unsigned long long int i= line_index;
    char *s = allocate_1D_c(1);
    char *t_realloc=NULL;
    while ( f->s[i] != '\n' )
    {
        length++;
        if ( (t_realloc=realloc(s, (length)*sizeof(char))) )
        {
            s=t_realloc;
            s[i-line_index]=f->s[i];
        }
 
        else
        {
             printf("\nextract_line :: erreur reallocation");
             s=NULL;
        }
        i++;
    }
    s[length-1]='\0';
    return s;
}
 
unsigned long long int number_random(unsigned long long int x)
{
    return (rand()%x +1);
}
 
int main()
{
    t_file *file = file_create("dictionnaire.txt");
    unsigned long long int line_count = str_count_occurrence(file->s,'\n');
 
    srand(time(NULL));
    unsigned long long int line_to_extract = number_random(line_count);
 
    char *word = extract_line( file, line_to_extract );
 
    printf("\n word %s",word);
 
    file_destroy(file);
    deallocate_1D_c(word);
 
    return 0;
}

03/03/2013, 13h10
sa7lia1990

occurrence d'un caractère

la comparaison entre le mot choisit aléatoirement et le mot proposé par le joueur est comme suit :
*mot bien placé coloré en rouge
*mot mal placé coloré en jaune.
j'ai trouvé un problème au niveau de coloration de mot mal placé
03/03/2013, 15h03
LittleWhite

Trouver un problème n'est pas assez précis pour que nous puissons aider. Veuillez donc donner des précisions.
06/03/2013, 03h23
darkwall_37

J'ai fournie un code qui te permet d'extraire un mot aléatoirement de ton dictionnaire de mot, c'est quoi le rapport avec les couleurs avec l’énoncé de base ? Est ce que tu as résolu le problème initial ?

Cordialement