Proyecto Estructura

PROYECTO FINAL

ÍNDICE

BIBLIOGRAFÍA 3

PLANTEAMIENTO DEL PROBLEMA 3

OBJETIVO DEL SISTEMA 3

JUSTIFICACIÓN 3

DESCRIPCIÓN DE LAS ESTRUCTURAS UTILIZADAS 3

LISTAS ENLAZADAS SIMPLES 3

ARREGLOS 4

MATRICES 4

CONSTRUCCIÓN DEL SISTEMA 5

IMPLEMENTACIÓN DEL SISTEMA 17

BIBLIOGRAFÍA

Harvey M. Deitel, Paul J. Deitel. Como programar en C/C++ y Java

http://c.conclase.net/curso/?cap=011

PLANTEAMIENTO DEL PROBLEMA

Como proyecto final nos proponemos a realizar un sistema, el cual tendrá como fin el juego “Domino”, donde el programa mostrará un tablero donde se desplegaran las fichas con las cuales jugaremos en contra del sistema que será el contrincante a vencer.

OBJETIVO DEL SISTEMA

Programar un sistema que nos permita realizar el juego “Domino” haciendo uso de estructuras de datos como pueden ser: Arreglos, Pilas, Listas, Colas, Arboles, Grafos, etc.

Para la realización de este sistema se programará en lenguaje C++ con interfaz gráfica por medio del software “Embarcadero C++, Versión 2010”.

JUSTIFICACIÓN

La decisión de realizar un sistema que nos permita realizar el juego de “Domino”, fue porque a través del uso de algunas estructuras podemos realizar dicho fin.

Primero hay que señalar el uso de clases, las cuales nos permitirá realizar objetos para las distintas operaciones que utiliza el juego como la entrega y control de fichas utilizadas en juego, ingresando atributos o variables y los métodos o funciones.

DESCRIPCIÓN DE LAS ESTRUCTURAS UTILIZADAS

LISTAS ENLAZADAS SIMPLES

Las listas enlazadas son estructuras de datos semejantes a los array salvo que el acceso a un elemento no se hace mediante un índice sino mediante un puntero. La asignación de memoria es hecha durante la ejecución.

Dentro del sistema se emplean para realizar la repartición de las fichas que tendrán los jugadores (usuario y computadora) al inicio del juego, y que estas listas se irán modificando de acuerdo al movimiento que se haga en el turno de cualquiera de los jugadores, por lo que las modificaciones que tendrán las listas será la inserción de nodos (al momento en que el jugador “come” una ficha), eliminación de nodos (cuando el jugador utiliza una ficha) y también el recorrido de la lista (reasignar el primer y último nodo).

ARREGLOS

Un arreglo es el espacio de memoria que permite almacenar una colección de elementos, todos del mismo tipo. Es una secuencia contigua de celdas (espacios de memoria), o casillas, en cada una de las cuales se puede guardar un elemento de la colección.

Los arreglos los utilizamos para la almacenar las 28 fichas que existen dentro del juego de domino. El arreglo utilizado es un arreglo de estructuras, donde la estructura contiene los valores de las dos partes de las fichas y un número que nos permite tener una referencia a la ficha. Por lo tanto, cada elemento del arreglo contiene la información completa de una ficha (valores de ambos lados de la ficha y una referencia que nos permite tener un manejo más fácil para trabar y hacer movimientos con las fichas).

MATRICES

Espacio de memoria que permite almacenar una colección de elementos, todos del mismo tipo. La diferencia con los arreglos está en que, en las matrices, los elementos no están organizados linealmente, sino que su organización es bidimensional, es decir, en filas y columnas. Es una organización de celdas de memoria, o casillas, en cada una de las cuales se puede guardar un elemento de la colección.

Esta estructura se utiliza para girar los mapas de bits que contienen los dibujos de las fichas, para insertar ya sea vertical u horizontal las fichas. Esta estructura se emplea solamente para la parte de la interfaz del sistema, prácticamente nos sirve solo para organizar las fichas dentro de la parte visual del sistema.

CONSTRUCCIÓN DEL SISTEMA

//NOTA. LLS = Lista ligada simple

struct fichas

{//Estructura para guardar los datos de las fichas, una por una.

int numero;

int arriba;

int abajo;

};

struct mano

{//Estructura para generar una LLS que guardara las manos de los jugadores

fichas pieza;

mano *siguiente;

};

struct reparticion

{//Estructura que guarda los datos de la mano de cada jugador

mano *ultimo;//Apunta al último elemento de una LLS

int FichasEnMano;//Guarda el numero de fichas en mano.

};

class juego_domino

{

public:

/************Atributos************/

fichas contenido[28];//Arreglo donde se guardarán las 28 fichas

fichas tablero[28];//Arreglo para guardar las inserciones de fichas jugadas

reparticion jugador[2];//Arreglo que guarda los datos de la mano de 2 jugadores

mano *ultimo;//Apuntador para guardar el ultimo elemento de una LLS

int i, j, l;//Contadores para procesos

int disponibles;//Guarda el numero de fichas en la sopa

int usadas[28], ContadorUsadas;//El arreglo guarda el número de las fichas que han salido de la sopa

int derecha, izquierda;//Guardan la posición de la última inserción en el tablero

int SistemaPasa, UsuarioPasa;//Cuentan el numero de veces que un jugador pasa turno

/************Métodos************/

void generar()

{//GENERA LAS 28 FICHAS DE DOMINO

SistemaPasa = 0;

UsuarioPasa = 0;

disponibles = 0;

for (i = 0; i < 7 ; i++)

{

for (j = 0; j <= i; j++)

{

contenido[disponibles].numero = disponibles;

contenido[disponibles].arriba = i;

contenido[disponibles].abajo = j;

disponibles++;

}

}

ContadorUsadas = 0;

for (i = 0; i < 28; i++)

usadas[i] = -1;

}

void repartir()

{//REPARTE UNA MANO

mano *a, *b;

int entregadas[7];

//Genera 7 numeros aleatorios

randomize();

if (ContadorUsadas == 0)

{

for(i=0;i<7;i++)

entregadas[i]=random(28);

for(i=0;i<7;i++)

{

for(j=0;j<7;j++)

{

if(j == i)

continue;

if(entregadas[i] == entregadas[j])

{

entregadas[i]=random(28);

i=0;

...