SOLUCIÓN AL EJERCICIO 3º (TEMA 6)

MÓDULO procesarJugada:
M. llamador

t',res t,f,c

procesarJugada

1º) ANÁLISIS:
a) Datos de entrada:
 NUMFIL=9. Número de filas del tablero. Dato fijo.
 NUMCOL=9. Número de columnas del tablero. Dato fijo.
 t[1..NUMFIL][1..NUMCOL].ocu: Indicador de si la casilla está o no ocupada por una
porción de barco. Módulo llamador. (t[i][j].ocu є {0,1})
 t[1..NUMFIL][1..NUMCOL].tam: Tamaño del barco del que forma parte la casilla.
Módulo llamador. (si t[i][j].ocu=1, entonces 1 ≤ t[i][j].tam ≤ 4)
 t[1..NUMFIL][1..NUMCOL].pos: Posición que ocupa la porción respecto al barco
completo. Módulo llamador. (si t[i][j].ocu=1, entonces 1 ≤ t[i][j].pos ≤ t[i][j].tam)
 t[1..NUMFIL][1..NUMCOL].dir: Dirección en la que está situado el barco. Módulo
llamador. (si t[i][j].ocu=1, entonces t[i][j].dir є {'H','V'})
 t[1..NUMFIL][1..NUMCOL].des: Indicador de si la porción está o no destruida. Módulo
llamador. (si t[i][j].ocu=1, entonces t[i][j].des є {0,1})
 f: fila de la jugada. Módulo llamador. (0 ≤ f ≤ NUMFIL-1)
 c: columna de la jugada. Módulo llamador. (0 ≤ c ≤ NUMCOL-1)
b) Datos de salida:
 t'[1..NUMFIL][1..NUMCOL]: tablero actualizado. Módulo llamador.
 res: resultado de la jugada ('A','T','H'). Módulo llamador.
c) Comentarios:
 Suponemos que en algún módulo ascendiente se ha definido lo siguiente:
CONSTANTES
NUMCOL=9
TIPOS
tCasilla = ocu,tam,pos,des:entero
dir:carácter
 Utilizaremos una variable índice para, en el caso de que la casilla acertada contenga una
porción de barco, recorrer dicho barco para determinar si ha sido tocado o hundido.
2º) DISEÑO:
a) Parte declarativa:
procesarJugada(t[][NUMCOL]:tCasilla, f:entero, c:entero, *res:carácter)
VARIABLES
i:entero
 b) Representación algorítmica:
procesarJugada(t,f,c,res)
BLOCK

if then else

t[f][c].ocu BLOCK *res←'A'

t[f][c].des←1 i←1 if then else

t[f][c].dir='H' BLOCK BLOCK

while do if then else while do if then else

t[f][c-t[f][c].pos+i].des t[f-t[f][c].pos+i][c].des
i←i+1 t[f][c-t[f][c].pos+i].des *res←'H' *res←'T' i←i+1 t[f-t[f][c].pos+i][c].des *res←'H' *res←'T'
y i<t[f][c].tam y i<t[f][c].tam

3º) CODIFICACIÓN:
/******************************************************************/
/*** E J E R C I C I O 3 - T E M A 6 ***/
/*** ***/
/*** Módulo para procesar una jugada en el juego de los barcos ***/
/******************************************************************/

(...)
#define NUMCOL 9 /* Número de columnas del tablero */

typedef struct
{
int ocu,tam,pos,des;
char dir;
} tCasilla;
(...)

/** procesarJugada(t,f,c,*res) **/

/** Procesa el disparo en t[f][c], actualizando el tablero y devolviendo **/
/** el resultado del disparo ('A'-agua,'T'-tocado,'H'-hundido) **/
void procesarJugada(tCasilla t[][NUMCOL],int f,int c,char *res)
{
int i;

if (t[f][c].ocu) /* ¿La casilla contiene una porción de barco? */

{
t[f][c].des=1; /* Destruimos la porción de barco */
i=1;
if (t[f][c].dir=='H') /* ¿El barco está situado en posición horizontal? */
{
while (i<t[f][c].tam && t[f][c-t[f][c].pos+i].des) /* recorremos el barco */
i=i+1;
if (t[f][c-t[f][c].pos+i].des) /* ¿hay una casilla sin destruir? */
*res='H';
else
*res='T';
}
else /* El barco está situado en posición vertical */
{
while (i<t[f][c].tam && t[f-t[f][c].pos+i][c].des) /* recorremos el barco */
i=i+1;
if (t[f-t[f][c].pos+i][c].des) /* ¿hay una casilla sin destruir? */
*res='H';
else
*res='T';
}
}
else /* La casilla no contiene ninguna porción de barco */
*res='A';
}