Prctica N 6: Pilas

Asignatura PROGRAMACIN

Laboratorio de PROGRAMACIN
Grado en Ingeniera Multimedia (1)
Curso 2014-15

Prctica N 6: Pilas
Periodo de realizacin: Semana del 04/05/2015 al 08/05/2015
Fecha lmite de entrega: 6 das despus de la realizacin de la prctica
HAY QUE LLEVAR COPIA IMPRESA DEL GUIN DE PRCTICAS PARA ACCEDER AL LABORATORIO

Objetivos

Desarrollar una aplicacin en C++ desde cero.

Analizar la idoneidad de la utilizacin del Tipo Abstracto de Datos (TAD) Pila en la
solucin del problema propuesto.
Implementar y utilizar el TAD Pila con representacin esttica

Material a entregar

Solucin de la prctica: archivo zip o rar con los ficheros de la solucin final de la prctica:
o Pila.h
o Pila.cpp
o Carta.h
o Carta.cpp
o Solitario.h
o Solitario.cpp
o Pr6.cpp

Introduccin
En esta prctica vamos a implementar una versin del juego del solitario de cartas espaolas de
forma que al ejecutar nuestra aplicacin podamos jugar una o varias partidas de este solitario.
El juego requiere el manejo de diferentes montones de cartas implicados en el juego y consiste en
que el jugador mueva una carta de una pila a otra hasta no poder efectuar movimientos vlidos o
tener todas las cartas del mismo palo amontonadas en su correspondiente pila.
En el juego se emplear una baraja espaola con 48 cartas (4 palos y 12 cartas por palo), estando
cada carta representada por un carcter que indique el palo ('O', 'C', 'E', 'B') y un nmero. Antes de
iniciar el juego, el programa debe generar la baraja (en forma de pila) y proceder a barajar las cartas
para que no estn ordenadas. A continuacin, el estado inicial del juego requerir formar los
siguientes montones de cartas (pilas), adems de la propia baraja:

7 montones sobre la mesa: mazo1, mazo2, mazo3, mazo4, mazo5, mazo6, mazo7.

Grado en Ingeniera Multimedia

Prctica N 6: Pilas

Asignatura PROGRAMACIN

4 montones donde se irn amontonando las cartas de cada uno de los palos: Palo1, Palo2,
Palo3 y Palo4.

1 montn Auxiliar.

El juego se inicia repartiendo cartas de la baraja de la siguiente forma:

1 carta en cada uno de los montones de la mesa (mazo1, , mazo7)

5 cartas en la pila Auxiliar

A partir de ah el programa debe permitir al jugador realizar movimientos de cartas entre los
distintos montones, teniendo en cuenta que en cada movimiento se mueve slo una carta (la de
encima del correspondiente montn) y que se debe indicar el montn de donde se quita y el montn
al que se lleva la carta.
Para la implementacin de los distintos montones utilizaremos la implementacin esttica del TAD
Pila. As pues, tendremos 13 pilas que representarn los 13 montones (la baraja, los 7 mazos, los 4
palos y la pila auxiliar) que utilizan en esta versin del solitario.
Los movimientos posibles son:
Hacia las pilas de los palos (Oros, Copas, Espadas y Bastos):

Cuando se encuentran vacas solo se puede mover el as (B1, C1, E1, O1) del palo
correspondiente desde cualquier pila excepto de la Baraja.

Cuando contienen alguna carta solo se puede colocar otra del mismo palo y una unidad
superior desde cualquier pila excepto de la Baraja.

Hacia las pilas de trabajo (mazo1, ..., mazo7):

Grado en Ingeniera Multimedia

Prctica N 6: Pilas

Asignatura PROGRAMACIN

Cuando estn vacas se puede mover cualquier carta desde cualquier pila excepto de la
Baraja.

Cuando contienen alguna carta solo se puede colocar otra de distinto palo y una unidad
inferior procedente de cualquier pila excepto de la Baraja.

Si el jugador intenta realizar un movimiento no vlido, se debe impedir el movimiento y avisar al

jugador.
El jugador repetir este tipo de movimientos hasta que considere que con las cartas que tiene en la
mesa ya no se pueden hacer ms movimientos entre pilas. En ese caso, puede extraer de nuevo 5
cartas de la Baraja (las 5 superiores) y ponerlas en la pila Auxiliar. Si quedan menos de 5 cartas en la
Baraja se deben pasar a Auxiliar todas las que queden. La siguiente vez que el usuario quiera extraer
cartas de la Baraja se pasarn previamente todas las cartas de la pila Auxiliar a la Baraja y se contina
el juego.
Al iniciar el juego y cada vez que el jugador realice algn movimiento se debe visualizar en pantalla el
contenido de todas las pilas que intervienen en el juego. Para ello, se debe sobrecargar el operador
<< para mostrar las cartas existentes en la pila separadas por comas y siendo la cima de la pila la
carta ms a la derecha. (Nota: Mostraremos todas las pilas para que el jugador pueda comprobar la
correcta evolucin de las pilas despus de cada movimiento). La imagen del solitario anterior se
mostrar en nuestra aplicacin del siguiente modo:
TAPETE
===============================
Mazo1: O12,B11,E10
Mazo2: C5,E4
Mazo3:
Mazo4:
Mazo5: E11,C10
Mazo6:
Mazo7: C6
===============================
Palo1: O1,O2,O3
Palo2: C1
Palo3: B1,B2,B3,B4
Palo4:
===============================
Auxiliar: O5,O6,E1,B5
Baraja: (Resto de cartas de la baraja separadas por comas)

En esta situacin:
El mazo 1 contiene el Rey de oros, el caballo de bastos y la sota de espadas.
El mazo 2 contiene el 5 de copas y el 4 de espadas.
Los mazos 3, 4 y 6 estn vacos.
El mazo 5 contiene las cartas caballo de espadas y sota de copas.
El mazo 7 contiene el 6 de copas.
La pila del palo 1 contiene el as, el 2 y el 3 de oros.
La pila del palo 2 contiene el as de copas,
La pila del palo 3 contiene el as, el 2, el 3, el 4 de bastos,
La pila del palo 4 est vaca.
Grado en Ingeniera Multimedia

Prctica N 6: Pilas

Asignatura PROGRAMACIN

La pila auxiliar contiene el 5 de oros, el 6 de oros, el as de espadas y el 5 de bastos.

La baraja contiene las restantes cartas restantes separadas por comas.
A partir de la descripcin del juego definiremos una clase Solitario para gestionar la informacin que
se maneja en el juego y definir las operaciones permitidas sobre l.
TAD Solitario
Domino: Vector con las 13 pilas que se manejan en el solitario. Posiciones del vector:

0: Pila con la Baraja.

1 - 7: Pilas con los 7 mazos.
8 11: Pilas con los Palos.
12: Pila auxiliar.

Operaciones:
CrearSolitario() -> Solitario
IniciarJuego(Solitario) -> Solitario
MoverCarta(Solitario) -> Solitario
Sacar5Mas(Solitario) -> Solitario
JuegoFinalizado(Solitario) -> Lgico
MostrarTapete(Solitario)
Axiomas:
Sea sSolitario,
CrearSolitario()
IniciarJuego(s)

MoverCarta(s)

Sacar5Mas(s)

JuegoFinalizado(s)
MostrarTapete(s)

Grado en Ingeniera Multimedia

Crea un solitario. Debe rellenar la pila 0 (Baraja) con las 48 cartas de

la Baraja.
Sita todas las cartas de las distintas pilas en la pila de la Baraja, a
continuacin Baraja las cartas, y reparte las cartas segn la posicin
inicial del juego: una en cada uno de los siete mazos y 5 en la pila
Auxiliar.
Solicita al jugador las pila de la que coger la carta y la pila donde la
depositar. Comprobar que sea un movimiento vlido (segn la
descripcin de la introduccin), si lo es, realizar el movimiento, en
caso contrario, mostrar un mensaje de movimiento invlido al
jugador.
Pasa 5 cartas de la pila de la Baraja a la pila Auxiliar. Si quedan
menos de 5 pasar las que queden en la Baraja. Si la Baraja est
vaca primero volcar la pila Auxiliar en la Baraja y a continuacin
pasar las 5 primeras a la pila Auxiliar.
Devuelve verdadero si se ha completado el solitario. Todas las
cartas estn en las pilas de los 4 palos.
Muestra el tapete tal como se describe en la introduccin.

Prctica N 6: Pilas

Asignatura PROGRAMACIN

Ejercicios
Tarea 1 (TAD Carta): Como las distintas pilas almacenarn Cartas, es preciso especificar antes este
tipo de datos. Implementa la clase Carta que responde al siguiente interfaz:
class Carta
{
public:
Carta(); //constructor
void PutPalo(char); //asigna palo a la carta
void PutNumero(int);//asigna nmero a la cara
char GetPalo();
//devuelve el palo de la carta
int GetNumero();
//devuelve el nmero de la carta
//muestra por pantalla la carta segn formato PaloNumero
ostream & operator << (ostream &, const & Carta);
private:
char palo; //'O'=oros, 'C'=copas, 'E'=espadas, 'B'=bastos
int numero; //1..12
};

Tarea 2 (TAD Pila): Implementa el TAD Pila (ficheros Pila.cpp, Pila.h) con representacin
esttica, de manera similar al visto en clase, que almacene nmeros enteros. Incluye en la definicin
de la clase el nmero mximo de elementos que puede almacenar la pila:
static const int MAX = 48;

Tarea 3 (Sobrecarga de operador de salida, clase Pila): Sobrecarga el operador << del TAD
Pila mediante una funcin friend que permita escribir el contenido de la pila:
friend ostream & operator << (ostream &, const & Pila);
Los elementos de la pila deben imprimirse en formato horizontal, y la cima de la pila debe
corresponder al elemento del extremo derecho.

Tarea 4 (TAD Solitario): Implementa el TAD solitario de acuerdo a la especificacin expuesta en la

introduccin.
Nota: Se recomienda realizar por lo menos los siguientes mtodos privados para facilitar la
implementacin de los mtodos propuestos.
void Solitario::Barajar ()
Se encargar de barajar las cartas de la baraja. Existen varios mtodos para barajar las cartas.
Un mtodo sencillo puede ser el siguiente:
1. Volcar las cartas de la pila en un vector auxiliar.
2. Repetir este proceso 1000 veces:
a. Generar dos nmeros aleatorios i, j entre 0 y el tamao del vector.
Grado en Ingeniera Multimedia

Prctica N 6: Pilas

Asignatura PROGRAMACIN

b. Intercambiar los elementos de las posiciones v[i] y v[j].

3. Volcar de nuevo los datos del vector a la pila.
bool Solitario::Validar(int, int)
Se encargar de comprobar si el movimiento de una carta de la pila indicada por el primer
parmetro a la del segundo es vlido o no.
Tarea 5 (Sobrecarga): Sustituye el mtodo MostrarTapete() por la sobrecarga del operador <<.
Tarea 6 (Programa principal): Crea un fichero llamado Pr06.cpp con la funcin main() que,
haciendo uso de la clase Solitario, permita al usuario jugar uno o varios solitarios. Se debe mostrar el
tapete en su situacin inicial y preguntar al usuario si desea: 1. Mover una carta 2. Sacar 5 ms de la
Baraja. 3. Iniciar un nuevo juego. 4. Finalizar el juego.
Este men se repetir hasta que el jugador pulse la opcin 4 o complete el solitario. Debe mostrarse
el tapete cada vez que el usuario pulse una opcin.

Grado en Ingeniera Multimedia