Pascal/Turbo Pascal - Batalla Naval. TP

   
Vista:

Batalla Naval. TP

Publicado por Bebinhio (1 intervención) el 26/08/2014 05:48:27
Hola amigos. Necesito una ayuda urgente. Tengo que hacer un TP para la Universidad sobre el juego de la Batalla Naval. TIene que ser una matriz de 10x10
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

Batalla Naval. TP

Publicado por David (144 intervenciones) el 26/08/2014 23:30:22
Te propongo la siguiente solución:

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
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
program Batalla_Naval;
uses crt;
Const
  LIMITE = 10;
type tablero = array[1..LIMITE, 1..LIMITE] of byte;
 
var tablero1, tablero2: tablero;
fila, columna, ganador: byte;
i, j, opcion: byte;
 
(*
leer_posicion
 
Lee una cadena de dos carácteres y guarda en dos variables las posiciones
que representa dicha cadena. Por ejemplo: a5 -> fila 5 columna 1
 
@ fila byte Una variable donde guardar la fila obtenida (por referencia)
@ columna byte Una variable donde guardar la columna (por referencia)
*)
procedure leer_posicion(var fila, columna:byte);
var valido: boolean;
posicion: string;
begin
repeat
readln(posicion); { Pido coordenada }
 
posicion := upcase(posicion); { Hago mayúscula la posición }
valido := false; { Inicializo valido en falso, es una bandera }
 
if (length(posicion) = 2) { Si la posicion son 2 caracteres... Por ej "A1" }
and (ord(posicion[1]) > 48) and (ord(posicion[1]) < 57) { Y el primer caracter es un numero del 1 al 8 }
and (ord(posicion[2]) > 64) and (ord(posicion[2]) < 73) then { Y el segundo una letra... }
begin
{ Genero la posición ascii del número, y le resto 48 }
{ Porque los números en la tabla ascii van del 49 al 58, por lo que si les resto 48 }
{ me queda un numero del 1 al 9 }
fila := ord(posicion[1])-48; { Guardo la fila en la variable indicada }
{ Las letras de la A a la H en la tabla ascii son los números del 65 al 72 }
{ Asà que les resto 64 para tener un número del 1 al 8 }
columna := ord(posicion[2])-64; { Guardo la columna en la variable indicada }
{ Como se cumplieron las condiciones, es una coordenada válida }
valido := true;
end
else
{ Con este if repito el proceso, sólo en caso de que la coordenada }
{ se haya ingresado al revés, por ejemplo 6A }
if (length(posicion) = 2)
and (ord(posicion[2]) > 48) and (ord(posicion[2]) < 57)
and (ord(posicion[1]) > 64) and (ord(posicion[1]) < 73) then
begin
fila := ord(posicion[2])-48;
columna := ord(posicion[1])-64;
valido := true;
end
else { En caso de que no se cumpla alguna condición, da un aviso y repite el ciclo }
write('Por favor, ingrese una posición válida: ');
until (valido = true); { Se repetirá el ingreso hasta que se ingrese una coordenada válida }
end;
 
(*
dibujar_tablero
 
Toma un array tablero y lo dibuja tiernamente  Antecede antes un tÃtulo.
Los puntos desconocidos (0, 1) se marcan con ·, los atacados (2) con o, los alcanzados (3) con x
Limpia la pantalla antes de dibujar.
 
@ titulo string Una cadena de texto con el tÃtulo del tablero
@ tablero tablero Un array tablero bidimensional
*)
procedure dibujar_tablero(titulo: string; tablero: tablero);
var i, j: byte;
begin
clrscr;
writeln(titulo); { Escribo el tÃtulo... }
writeln;
writeln(' -----------------'); { Esta es la parte de arriba del tablero }
for i:= 1 to LIMITE do begin { Por cada fila... }
write(' ', i, '| '); { Primero escribo el numero de fila y después una barrita }
for j := 1 to LIMITE do { Y ahora, por cada columna... }
case tablero[i, j] of
0: write('· '); { Si el tablero tiene un 0, dibujo un puntito }
1: write('· '); { Si tiene un 1 (tiene un barco), tambien dibujo un puntito }
2: write('o '); { Si es una posicion ya atacada (un 2) dibujo un circulo }
3: write('x '); { Si es un barco alcanzado (un 3) va una cruz }
end;
writeln('|'); { Dibujo la barrita al final del tablero (lado derecho) }
end;
writeln(' -----------------'); { Dibujo la parte de abajo del tablero }
writeln(' A B C D E F G H '); { Y las letras }
end;
 
(*
ingreso_barcos
 
Toma un array tablero y pide consecutivamente el ingreso de coordenadas
para ubicar los barcos. Los barcos ubicados se muestran con x.
 
@ titulo string Una cadena de texto con el tÃtulo del tablero
@ tablero tablero Un array tablero bidimensional (por referencia)
*)
procedure ingreso_barcos(titulo: string; var tablero: tablero);
var fila, columna: byte;
begin;
{ Se repite el ingreso para 4 barquitos }
for i := 1 to 4 do begin
dibujar_tablero(titulo, tablero); { Primero dibujo el tablero del jugador }
 
writeln; write('Escribe la posición del barco ', i, ': ');
leer_posicion(fila, columna); { Leo la coordenada ingresada y obtengo las posiciones en el tablero }
 
{ Si ya hay algo ahÃ, se repite el ingreso hasta tener un lugar vacio }
while tablero[fila, columna] = 3 do begin
write('Ya hay un barco ahÃ. Escriba otra posición: ');
leer_posicion(fila, columna);
end;
 
tablero[fila, columna] := 3; { Inserto un 3 (temporalmente) en la posición }
end;
 
dibujar_tablero(titulo, tablero); { Una vez ingresada la coordenada, muestro de nuevo el tablero actualizado }
writeln; writeln('Presiona <enter> para continuar...');
readln;
clrscr;
end;
 
(*
atacar
 
Cambia el estado de una posicion dada en el tablero dado.
Si esa posicion es 0 (no hay barco), la reemplaza por 2 (atacado).
Si la posicion es 1 (hay barco), la reemplaza por 3 (alcanzado).
Si es 2 o 3 (atacado o alcanzado) pide ingreso nuevamente.
 
@ fila byte Fila de la coordenada
@ columna byte Columna de la coordenada
@ tablero tablero Un array tablero bidimensional (por referencia)
*)
procedure atacar(fila, columna:byte; var tablero: tablero);
begin
{ Si la posicion que se quiere atacar es diferente de 0 o 1 }
{ (VacÃo o con barco, respectivamente) quiere decir que ya }
{ fue atacada, por lo que repite el ingreso de coordenada }
while tablero[fila, columna] > 1 do begin
write('Ya atacaste esa posición, elige otra: ');
leer_posicion(fila, columna);
end;
 
{ Si la posición es un 0, entonces no habÃa barco en esa posición }
{ Asà que cambio por un 2 (atacado) y muestro un mensaje alentador  }
if tablero[fila, columna] = 0 then begin
tablero[fila, columna] := 2;
dibujar_tablero('Fallaste! Muerto!', tablero);
end;
 
{ Si la posición era un 1, habÃa un barco }
{ Asà que cambio por 3 (alcanzado) y muestro mensajito }
if tablero[fila, columna] = 1 then begin
tablero[fila, columna] := 3;
dibujar_tablero('Le diste a un barco! Pura suerte', tablero);
end;
end;
 
(*
realizar_ataque
 
Lee una coordenada y llama a ataque() en la posicion dada del tablero dado.
 
@ titulo string Titulo para la acción
@ tablero tablero Un array tablero bidimensional (por referencia)
*)
procedure realizar_ataque(titulo:string; var tablero: tablero);
var fila, columna: byte;
begin;
dibujar_tablero(titulo, tablero); { Muestro el tablero, y pido coordenada para atacar }
writeln; write('Ingrese una posición para atacar: ');
leer_posicion(fila, columna); { Transformo la coordenada en posiciones del tablero }
atacar(fila, columna, tablero); { Llamo al procedimiento de arriba con las posiciones obtenidas }
writeln; writeln('Presiona <enter> para continuar...');
readln;
end;
 
(*
tablero_completo
 
Recorre un tablero contando la cantidad de alcanzados (3). Si cuenta 4
alcanzados, devuelve true, sino false.
 
@ tablero tablero Un array tablero bidimensional
*)
function tablero_completo(tablero: tablero): boolean;
var i, j, c: byte;
begin
{ Esto es fácil, un contador en dos ciclos anidados para recorrer la matriz }
{ Si no se entiende como funciona, recursen Elementos de Programación > }
c := 0;
for i := 1 to LIMITE do
for j := 1 to LIMITE do
if tablero[i, j] = 3 then c := c + 1;
 
{ Si se encontraron 4 posiciones con el número 3 (alcanzado), devuelve true }
if c = 4 then tablero_completo := true
else tablero_completo := false; { Sino false... }
end;
 
{ Arranca el súper juegoooo! Activision, Blizzard, Valve, EA, agarrense!  }
begin
{ Va todo dentro de un repeat, para poder jugar varias veces }
{ Aunque no creo que nadie lo juegue más de una vez porque es un embole  }
repeat
clrscr; { Muestro un menú re fachero }
writeln(' _ _ ');
writeln(' |~) _ _|_ _ || _ | | _ _ | · | ');
writeln(' |_)(_| | (_|||(_| | |(_|/(_|| · |_/');
writeln;
writeln(' 1 - Jugar');
writeln(' 0 - Salir');
writeln;
readln(opcion);
{ Si se ingresa una opción inválida, repite el ingreso hasta que sea válida }
while (opcion <> 1) and (opcion <> 0) do begin
writeln('Ingresa una opción válida o arderás en el infierno.');
readln(opcion);
end;
 
{ Si la opcion fue jugar... }
if opcion = 1 then begin
clrscr;
{ Explicaciones varias }
writeln('Comienza la etapa de posicionamiento.');
writeln('Indica la posición donde ubicar los barcos mediante su coordenada.');
writeln('Por ejemplo: "G3"');
writeln; writeln('Presiona <enter> para continuar...');
readln;
clrscr;
 
writeln('Turno del jugador 1');
writeln; writeln('Presiona <enter> para continuar...');
readln;
{ Llamo el procedimiento ingreso_barcos de más arriba }
{ Le paso "Jugador 1" como tÃtulo, y tablero1 es el array que se va a llenar }
ingreso_barcos('Jugador 1', tablero1);
 
writeln('Turno del jugador 2');
writeln; writeln('Presiona <enter> para continuar...');
readln;
{ Idem pal tablero del jugador 2 }
ingreso_barcos('Jugador 2', tablero2);
 
{ Explicaciones varias... }
writeln('Los barcos fueron ubicados.');
writeln('Ahora comienza la etapa de ataque.');
writeln('Indica la posición a atacar mediante su coordenada.');
writeln('Por ejemplo: "A1"');
writeln; writeln('Presiona <enter> para continuar...');
readln;
 
{ La función ingreso_barcos pone un 3 en la posición que van los barcos }
{ Ahora cambio esos "3" por "1" que es lo que corresponde para que no se vean }
for i := 1 to LIMITE do
for j := 1 to LIMITE do
begin
if tablero1[i, j] = 3 then tablero1[i, j] := 1;
if tablero2[i, j] = 3 then tablero2[i, j] := 1;
end;
 
{ Todo esto se va a repetir hasta que un jugador gane: }
repeat
clrscr;
writeln('Turno del jugador 1');
writeln; writeln('Presiona <enter> para continuar...');
readln;
 
{ Llamo la funcion realizar_ataque (que pedia las coordenadas y cambiaba las posiciones }
{ Por atacado o alcanzado segun corresponda) indicando que modifique el tablero2 }
realizar_ataque('Turno de ataque: jugador 1', tablero2);
{ Una vez hecho el ataque, verifica si ya hay 4 "alcanzados" en el tablero }
if tablero_completo(tablero2) = true then
begin { Si es asÃ, el jugador 1 ganó }
clrscr;
writeln('El jugador 1 ha ganado!');
{ BREAK: lo que hace es "romper" o "salir" del ciclo repeat }
{ sin importar que falte ejecutar algo, o que la condición no se cumpla. }
{ Si quedan dudas pregunten  }
break;
end;
 
clrscr;
writeln('Turno del jugador 2');
writeln; writeln('Presiona <enter> para continuar...');
readln;
 
{ Lo mismo para el jugador 2: pide coordenadas, ataca, verifica si ganó }
realizar_ataque('Turno de ataque: jugador 2', tablero1);
if tablero_completo(tablero1) = true then
begin
clrscr;
writeln('El jugador 2 ha ganado!');
break; { Si gano, sale del ciclo repeat }
end;
 
until (false);
{ Aquà uso "false" como condición para que el ciclo se detenga }
{ Esto quiere decir que no se va a detener nunca por si solo, porque }
{ No hay variables en la condición que se modifiquen dentro del ciclo }
{ La única forma de detener el ciclo es con un break; adentro (el que uso cuando un jugador gana) }
writeln; writeln('Presiona <enter> para continuar...');
readln;
end;
{ Y todo esto se va a repetir hasta que el jugador decida salir en el menú }
until (opcion = 0);
end.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Batalla Naval. TP

Publicado por Manuel (5 intervenciones) el 27/08/2014 14:52:44
Hola

Hace poco le realice una tarea similar a otra persona, lo que la matriz era de 8x8, si lo deseas escribeme a manviadom@gmail.com

este que le hice tiene todo el codigo comentareado y explicado y ademas incluye la modalidad de juego PC-computadora

ademas de la modalidad persona-persona

saludos,
Manuel
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar