-
Notifications
You must be signed in to change notification settings - Fork 0
/
Palabra.cc
183 lines (149 loc) · 4.7 KB
/
Palabra.cc
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
/*
* -------------------------------
* Juego del Ahorcado en C++ -----
* Autor: Rubén Rodríguez --------
* Fecha: 14-4-19 ----------------
* -------------------------------
*/
/*
* Fichero de implementacion del modulo Palabra
*/
#include "Palabra.h"
/*
* Pre: <<secuencia>> es una secuencia de caracteres que representa una
* palabra de la lengua española y <<nLetras>> es el total de letras
* de la cadena <<secuencia>>
* Post: Ha creado una palabra asignado a <<cadena>> la secuencia de caracteres
* <<secuencia>> y a <<numLetras>> el valor de <<nLetras>>
*/
void crearPalabra(char secuencia[], int nLetras, Palabra& p){
strcpy(p.cadena, secuencia);
p.numLetras = nLetras;
for (int i = 0; i < MAX_LETRAS - 7; i++){
p.marcadas[i] = false;
}
}
/*
* Pre: ---
* Post: Ha copiado en <<palabra>> la secuencia de caracteres
* almacenados en <<cadena>>
*/
void obtenerPalabra(char palabra[], Palabra& p){
strcpy(palabra, p.cadena);
}
/*
* Pre: ---
* Post: Ha devuelto el total de letras de la palabra
*/
int obtenerLetras(Palabra& p){
return p.numLetras;
}
/*
* Pre: ---
* Post: Ha devuelto la i-esima letra de la palabra <<p>>
*/
char devolverLetra(Palabra& p, const int i){
return p.cadena[i];
}
/*
* Pre: ---
* Post: Ha mostrado por cada letra de la palabra <<p>> un guion
* bajo de acuerdo al siguiente formato
*
* Ejemplo:
* diligentemente: _ _ _ _ _ _ _ _ _ _ _ _ _ _
* ababol: _ _ _ _ _ _
* ganzua: _ _ _ _ _ _
*/
void mostrarHuecosPalabra(Palabra& p){
// Total de letras de la palabra <<p>>
gotoxy(50, 15);
int numLetras = obtenerLetras(p);
// Bucle de recorrido de la palabra
for (int i = 0; i < numLetras; i++){
cout << "_ ";
}
cout << endl << endl;
}
/*
* Pre: <<p>> es una secuencia de caracteres que describe la
* estructura de una palabra
* Post: Ha devuelto <<true>> si y solo si la letra <<l>> esta dentro
* de la palabra <<p>> y ha reemplazada en la posicion correspondiente
* el caracter "_" por el valor de la letra <<l>>
*/
void existeLetra(Palabra& p, const char l, int& letrasVolteadas, bool& encontrado, bool& letraYaDicha){
// Total de letras de la palabra <<p>>
int numLetras = obtenerLetras(p);
// Control de existencia de letra
encontrado = false;
// Total de veces que ha aparecido la letra <<l>>
int numVeces = 0;
// letra leida
char c;
// Ver si es o no letra repetida
if (!p.marcadas[l - 'a']){
// Bucle de recorrido
for (int i = 0; i < numLetras; i++){
// Se compara si la letra i-ésima es igual a <<l>> y no se ha buscado antes
c = devolverLetra(p, i);
if (c == l){
// Muestreo de la letra en la poscion correcta
gotoxy(50 + 2 * i, 15);
cout << l << " ";
// Se ha hallado una nueva letra y se voltea
letrasVolteadas++;
// Incremento del numero de veces que se ha hallado la letra
numVeces++;
// La letra existe en la palabra
if (numVeces >= 1){
encontrado = true;
}
}
}
// Marco la letra dicha
p.marcadas[l - 'a'] = true;
}
else {
// La letra se ha repetido
letraYaDicha = true;
}
}
/*
* Pre: <<ficheroPalabrasBinario>> es un fichero binario que almacena una secuencia de
* de palabras, <<numLineas>> es el numero de lineas del fichero
* Post: Ha seleccionado una fila aleatoria del fichero <<ficheroPalabrasBinario>> y ha guardado en
* <<p>> la palabra correspondiente a esa linea
*/
void seleccionarPalabra(const char ficheroPalabrasBinario[], const int numLineas, Palabra& p){
// Flujo de lectura del fichero binario
ifstream f;
// Apertura del fichero de palabras
f.open(ficheroPalabrasBinario, ios::binary);
if (f.is_open()){
// Seleccion aleatoria de una linea del fichero
int lineaAleatoria = rand() % numLineas + 1;
// Calculo de la posicion en bytes de la palabra en esa fila aleatoria
int direccion = sizeof(Palabra) * (lineaAleatoria - 1);
// Desplazamiento del cursor a la posicion
f.seekg(direccion);
// Lectura de la palabra en esa fila
f.read(reinterpret_cast<char *>(&p), sizeof(Palabra));
// Cierre del flujo de lectura del fichero
f.close();
}
else {
// Error en el fichero binario de palabras
cerr << " El fichero " << ficheroPalabrasBinario << " no esta disponible " << endl;
}
}
/*
* Pre: ---
* Post Ha mostrado por pantalla la palabra oculta
*/
void mostrarPalabra(Palabra& p){
int numLetras = obtenerLetras(p);
for (int i = 0; i < numLetras; i++){
cout << devolverLetra(p, i);
}
}