Fecha y hora actual: Jueves 18 Dic 2014 10:32
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

CREACIÓN DE UN JUEGO: AHORCADO

Responder al Tema Ir a página 12Siguiente

Índice del Foro > Programación de juegos o videojuegos > CREACIÓN DE UN JUEGO: AHORCADO

Autor Mensaje
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Martes 01 Nov 2011 21:36

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO

Responder citando

CREACIÓN DE UN JUEGO: AHORCADO

por

Orlando Vila García

2011


1. Introducción

El objetivo de este tema es explicar paso a paso, el proceso para la creación de un juego utilizando las técnicas de la Programación Orientada a Objetos (POO). Estos mismos pasos pueden servir para la creación de cualquier programa, pero me parece que el programar un juego puede ser más ameno para el que está empezando.
Es cierto que hay decenas y decenas de manuales sobre POO circulando por la red, pero aún así trataré de evitar en lo posible el uso de palabras demasiado extrañas como las que se utilizan en muchos de ellos y procuraré en su lugar que las explicaciones sean en un lenguaje lo más sencillo posible y con el apoyo de ejemplos para que se entienda mejor lo que se explica, incluso para un principiante en la programación.
A la hora de crear el algoritmo del juego, se empleará un pseudocódigo de manera que al final –tomando como guía dicho programa en pseudocódigo--, se pueda hacer el verdadero programa en cualquier lenguaje que permita la POO. En este caso en particular se utilizará al final el lenguaje C# para explicar el proceso de programación, si bien, con solo algunos pequeños cambios podrá llevarse a C++, Delphi, Visual Basic o cualquier otro lenguaje orientado a objetos que se desee.
Creo que este tema será de gran utilidad para el principiante en POO, porque se irá explicando todo el proceso paso a paso. Quizás para alguien experto no sea necesario dar tantos detalles, pero para el que se inicia en la POO será muy útil. Esa misma metodología les servirá para poder crear no solo juegos, sino cualquier tipo de programa orientado a objetos, sin importar el lenguaje que se utilice para ello.



Ultima edición por Vila el Martes 01 Nov 2011 21:48; editado 1 vez
Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Martes 01 Nov 2011 21:43

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO (parte 2)

Responder citando

2. Descripción del juego a hacer (Ahorcado)

Antes de que comencemos a programar, lo primero es hacer una descripción lo más detallada posible de lo que se quiere lograr. Un error muy frecuente entre los programadores –incluso no principiantes-- es el de lanzarse de inmediato a escribir instrucciones en el lenguaje que se elija para comenzar a crear el programa deseado (en este caso el juego), sin haber primero planificado este. Lo correcto es partir de lo que se desea lograr, sin importar aún en este punto el cómo lograrlo. Eso nos permitirá, cuando llegue el punto 3, es decir el de hacer el modelado del problema a resolver mediante la creación de una clase, saber exactamente qué propiedades y métodos incluir en ella; de lo contrario, corremos el riesgo de perdernos en improvisaciones que nos desvíen de nuestro propósito inicial o que incluso nos impidan llevarlo a feliz término.
Así pues, describamos en lenguaje natural, lo más detalladamente posible pero sin pensar aún en cómo lograrlo, lo que pretendemos hacer.
El clásico Juego de Ahorcado que vamos a programar consiste en proponer al jugador adivinar una palabra o frase, extraída de una lista que desde luego permanece oculta a él. Dicha palabra o frase se elige de la lista de forma aleatoria (es decir, casual) y es mostrada al jugador sustituyendo cada una de sus letras por el símbolo de guión bajo o subrayado ( _ ), excepto la primera letra que es mostrada tal cual es a modo de guía. Para facilitar el juego, utilizaremos sólo las letras mayúsculas y prescindiremos de los acentos o tildes
Por ejemplo, si la palabra fuese “JUEGO”, se le mostraría al jugador como sigue:
J _ _ _ _
Si la primera letra estuviese repetida en la palabra a adivinar, esta se mostraría como tal donde quiera que estuviese. Por ejemplo, si la palabra fuese “AHORCADO” se mostraría así:
A _ _ _ _ A _ _
Si en lugar de una sola palabra se mostrase una frase compuesta por varias palabras (el juego debe permitir una u otra indistintamente), se mostrarían desde el inicio los espacios que separan cada palabra. Por ejemplo, si se tratase de adivinar la frase “CADENA DE CARACTERES”, se le mostraría al jugador de la siguiente manera al inicio:
C _ _ _ _ _ _ _ C _ _ _ C _ _ _ _ _
Para comenzar a jugar, deberá indicarse qué letras van en cada posición, según lo que el jugador estime según la pista que se le da, pero procurando no equivocarse, porque cada equivocación se penaliza realizando una fase del “ahorcamiento”. Deberá establecerse un límite de equivocaciones permitidas antes de que la víctima sea “ahorcada”. En nuestro caso estableceremos dicho límite en 4, pero con solo cambiar dicha cantidad por otra, podremos hacer más fácil o difícil el juego según convenga. El jugador puede introducir las letras que él cree completan la palabra, ya sea por el teclado o dando clic con el Mouse en una lista de letras que se muestre en pantalla; sin embargo, en esta fase de la creación del juego aún no entraremos en ese detalle, tan solo nos importa que el jugador indicará las letras una a una sin importarnos por el momento cómo lo haga.
Si la letra indicada es correcta, de inmediato se sustituye por ella el guión correspondiente a cada una de las posiciones donde aparezca. Continuando con el ejemplo anterior (“CADENA DE CARACTERES”), si se marca la A, se le mostrará de inmediato como sigue:
C A _ _ _ A _ _ C A _ A C _ _ _ _ _
En cambio, si se marca una letra incorrecta, es decir, que no pertenece a la palabra o frase (en nuestro ejemplo una B), se le indica de alguna manera al jugador que se ha equivocado y cuántas equivocaciones ha cometido hasta el momento. Aunque en una versión más elaborada del juego puede mostrarse mediante imágenes cómo el personaje va siendo ahorcado, por el momento vamos a simplificar el trabajo prescindiendo de esto y mostrando simplemente la cantidad de equivocaciones que se han cometido. Una buena idea para que el usuario sepa qué letras ya ha utilizado y que no vuelva a marcarlas por haberlo olvidado, es irle mostrando en pantalla, la lista de letras utilizadas.
¿Cuándo el jugador gana? Pues cuando logra adivinar la frase completa antes de que lo “ahorquen”, es decir, antes de que la cantidad de equivocaciones sobrepase el límite máximo permitido. Lo mismo si logra adivinar la palabra que si no lo logra, deberá permitírsele a continuación escoger entre abandonar el juego si ya se aburrió de jugar o de continuar este intentando adivinar otra palabra o frase, para lo cual el programa seleccionará otra de la lista (siempre de manera aleatoria). Para evitar que una misma palabra o frase se le muestre de nuevo poco después de haberla utilizado, cada vez que se seleccione una de la lista, se quitará de esta, de manera que siempre se mostrará una distinta durante una misma sesión de juegos. Podemos alimentar la lista con cuantas palabras o frases deseemos y así habrá una menor probabilidad de que el jugador las agote todas durante una sesión de juego. Pero como quiera que por muy larga que sea la lista siempre contendrá una cantidad limitada de palabras, de quedar totalmente vacía, esta volverá a llenarse con las mismas palabras que contenía a partir de una copia de la lista que se hará al comienzo.
Cada vez que se seleccione una nueva frase, el contador de fallos volverá a ser cero y la lista de letras usadas volverá a vaciarse, de manera que para cada frase el jugador pueda recomenzar el juego desde el principio.
Ya tenemos descrito nuestro juego. El próximo paso será diseñar la clase que lo representará.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Miércoles 02 Nov 2011 16:17

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO - Parte 3-A

Responder citando

3. Creación de la clase que representa al juego

Vamos ahora a determinar cuales propiedades y métodos debemos incluir en la clase Ahorcado para que represente todas las características de nuestro juego así como todas las acciones que deseamos pueda hacer éste. Esto no lo haremos todavía en ningún lenguaje concreto, sino que lo haremos en lenguaje natural aunque utilizaremos para ellos los nombres que usaremos posteriormente a la hora de escribir el verdadero programa. Tampoco nos ocuparemos en este punto de la programación que deberá hacerse para cada uno de los métodos, sino que nos limitaremos a poner una breve descripción de lo que cada uno hace (a manera de comentario). Para las propiedades, igualmente indicaremos para qué se usará cada una de ellas y con qué valor inicial comenzará cada una si fuese necesario. También indicaremos si la propiedad o el método será privado o público; ¿qué significa esto? Si una propiedad fuese de uso interno para la clase, la crearíamos como privada, lo que significa que desde el programa en que se ponga en uso esta clase no tendríamos acceso a ella. En cambio, si pensamos permitir que desde el programa que usa la clase se tenga acceso a la propiedad, la declaramos como pública. Lo mismo haremos para los métodos según sean de uso interno a la clase o se puedan usar desde fuera de esta.
Con respecto a las propiedades, es necesario también indicar de qué tipo será cada una de ellas, o sea, qué tipo de valores representará cada una, (numérica entera, numérica real, caracteres, cadena de caracteres, lógica, etc). Esto se hará, repetimos, indicándolo en idioma natural (en español en nuestro caso) y no en los tipos de variables que existen en los diferentes lenguajes. Si alguno de los métodos tuviera que devolver un resultado, igualmente indicaremos de qué tipo es este.
También es necesario indicar si las propiedades son de Lectura/Escritura, de Sólo Lectura o de Sólo Escritura según se permita desde el programa que ponga en uso esta clase cambiar o no el valor de cada una.
En ocasiones conviene utilizar en nuestro algoritmo más de una clase. Esto ocurrirá cuando alguna de las propiedades de nuestra clase sea de alguna complejidad y requiera a su vez de propiedades y métodos propios. Todas esas clases auxiliares también deberán ser definidas en esta etapa de la misma manera que se hace con la clase principal. En el ejemplo que nos ocupa, el juego “Ahorcado”, hay una propiedad: la lista de palabras, que nos convendrá representar mediante una clase auxiliar, debido a que con estas palabras hay una serie de operaciones que se pueden hacer, tales como seleccionar la palabra, agregarla, eliminarla, etc. El poner estas operaciones en una clase auxiliar y no en la principal nos facilita la planificación de esta última al ponerle solo lo que compete al juego como tal, mientras que todo lo que tenga que ver con el manejo de la lista de palabras y las propias palabras, lo pondremos en la clase auxiliar.
Aunque se le puede poner cualquier nombre, le pondremos a la clase uno que indique claramente lo que ella representa (lo mismo haremos con las propiedades y métodos que ella contiene):
Código:
Clase Ahorcado
   Propiedades públicas:
      •   L   --- >  De tipo ListaPalabra (una clase aún no definida). Para almacenar la lista de palabras a usar
      •   L2   --- >  De tipo ListaPalabra. Para almacenar copia de lista de palabras
      •   Conta   --- > Numérico entero y de sólo lectura. Devuelve cantidad de intentos fallidos de adivinar la palabra.
      •   Maxcanti  --- >   Numérico entero. Contiene máxima cantidad de fallos que se permitirá antes de que el jugador pierda (valor asumido 4).
      •   LetrasUsadas --- > Tipo cadena de caracteres y sólo lectura. Devuelve lista de letras usadas separadas por comas (por EJ:  A, E, S, T).
      •   Separador --- > Tipo cadena de caracteres. Contiene carácter o caracteres que separan cada letra de la palabra que se muestra para ser adivinada. Por defecto contiene un espacio en blanco. Se le puede asignar una diferente cantidad de espacios según nos convenga que los guiones que sustituyen a las letras de la palabra a adivinar se muestren más o menos separados.

   Propiedades privadas:
      •   Palabra   --- >  De tipo cadena de caracteres y sólo lectura. Contiene la palabra a adivinar.
      •   PalabraMostrada --- > De tipo cadena de caracteres. Se usa para ir construyendo en ella la palabra a medida que se intenta adivinarla. Inicialmente contiene un símbolo _ (guión bajo) por cada letra de la propiedad Palabra excepto el primero que se muestra tal cual es donde quiera que aparezca y el carácter espacio en caso de contenerlo.

   Métodos públicos:
      •   PonPalabra(Pal de tipo cadena de caracteres)   --- >  No devuelve ningún resultado. Al ser llamado pone el valor del parámetro Pal en la propiedad de sólo lectura Palabra. Además pone en las diferentes propiedades el valor necesario para iniciar el juego con dicha palabra ( contador de intentos fallidos en cero, la lista de letras usadas vacía, convierte la palabra en mayúsculas). Además, se encarga de que la propiedad PalabraMostrada contenga tantos guiones bajos ( _ ) como letras tenga la palabra, excepto la primera letra y los espacios en blanco que se muestran tal cual son.
      •   EligePalabra()   --- >   No devuelve ningún resultado. Al ser llamado, elige de la lista L una palabra de manera aleatoria y la almacena en la propiedad Palabra usando el método PonPalabra. El juego queda iniciado para dicha palabra. La palabra elegida se quita de la lista L para que no se repita.
      •   RestableceLista()   --- > No devuelve nada. Al ser llamado  restablece el contenido de la lista L (cuando L quede vacía), a partir de la copia L2 de dicha lista.
      •   CopiaLista()   --- > No devuelve nada. Al ser llamado hace una copia de la lista original L en la lista auxiliar L2.
      •   MuestraPalabra(Letra de tipo carácter)       --- > Devuelve resultado de tipo cadena de caracteres. Al ser llamado, reemplaza el carácter guión bajo ( _ ) de la propiedad PalabraMostrada donde quiera que el parámetro Letra coincida con la letra que va en esa posición. Agrega dicha Letra a la propiedad LetrasUsadas si ya no estuviese ahí; en caso de no estar ya allí incrementa en 1 el contador de intentos fallidos. Además, devuelve el mismo contenido de PalabraMostrada pero intercalando el valor de la propiedad Separador entre un carácter y otro de manera que dicho resultado esté listo para ser mostrado en pantalla al que juega.
      •   Comprueba()   --- > Devuelve resultado lógico (verdadero o falso). Al ser llamado, averigua si la palabra ha sido ya adivinada, es decir, si la propiedad PalabraMostrada es ya igual que la propiedad Palabra al haber sido sustituidos todos sus signos de guión bajo por la letra que va en esas posiciones; en ese caso devuelve verdadero, con lo que el jugador se salva de la horca (al menos para esa palabra).
      •   Pierde()   --- > Devuelve resultado lógico (verdadero o falso). Al ser llamado, averigua si el jugador ya perdió ese juego por ser la cantidad de fallos superior a MaxCanti (es decir, a la cantidad máxima de fallos permitidos).
      •   AgregaLetraUsada(letra de tipo carácter)   --- >   Devuelve resultado lógico (verdadero o falso). Al ser llamado, agrega la letra del parámetro a la propiedad LetrasUsadas, pero sólo si no estuviese ya ahí. Será llamado cada vez que el jugador teclee una nueva letra. Si se agregó devuelve verdadero; si ya estaba (por lo que no se agregó), devuelve falso.

Fin de Clase Ahorcado

Ya hemos descrito todos los componentes –propiedades y métodos—de la clase Ahorcado¸ si bien aún no se ha descrito el algoritmo de sus métodos, sino tan solo lo que cada uno hace. Pero falta aún por describir la segunda clase que participa en este proyecto: la clase ListaPalabras, que manejará la lista de palabras o frases a ser adivinadas y que es el tipo de las propiedades L y L2 de la clase anterior.

(CONTINUARÁ)



Ultima edición por Vila el Miércoles 09 Nov 2011 14:54; editado 1 vez
Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Jueves 03 Nov 2011 14:53

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO - Parte 3-B

Responder citando

3. Creación de la clase que representa al juego (Continuación)

Ya hemos descrito todos los componentes –propiedades y métodos—de la clase Ahorcado¸ si bien aún no se ha descrito el algoritmo de sus métodos, sino tan solo lo que cada uno hace. Pero falta aún por describir la segunda clase que participa en este proyecto: la clase ListaPalabras, que manejará la lista de palabras o frases a ser adivinadas y que es el tipo de las propiedades L y L2 de la clase anterior.

Código:
Clase ListaPalabras
   Propiedades públicas:
      •   CanPalabras   --- >  De tipo numérico entero y de sólo lectura. Contiene la cantidad de palabras almacenada en la lista (inicialmente vale 0 por comenzar la lista vacía).
      •   MaxCanti   --- >  De tipo numérico entero y de sólo lectura. Contiene la máxima cantidad de palabras que pueden almacenarse en la lista.

   Propiedades privadas:
      •   A   --- >    De tipo arreglo de cadenas de caracteres. Permitirá guardar en cada uno de sus elementos una palabra o frase de la lista.

   Métodos públicos:
      •   LimpiaLista()   --- >   No devuelve nada. Al ser llamado limpia la lista (es decir, borra todas las palabras que contiene, dejando el contador de palabras CanPalabras en cero).
      •   AgregaPalabra(Pal de tipo cadena de caracteres)   --- >   No devuelve nada. Al ser llamado agrega la palabra Pal a la lista e incrementa la propiedad CanPalabras en 1, pero sólo si la cantidad de palabras fuera menor que la máxima cantidad que cabe en la lista (MaxCanti).
      •   EliminaPalabra(NumPalabra de tipo numérico entero)   --- >   No devuelve nada. Al ser llamado elimina la palabra # NumPalabra de la lista y decrementa el contador CanPalabras en 1.
      •   TomaPalabra(indi de tipo numérico entero)   --- >   Devuelve valor de tipo cadena de caracteres. Al ser llamado, devuelve la palabra # indi de la lista, pero sin quitarla de la lista. Útil para conocer lo que la lista contiene sin cambiar su contenido.
      •   PalabraAleatoria()   --- >   Devuelve valor de tipo cadena de caracteres. Al ser llamado, elige de manera aleatoria de la lista una palabra, la quita de la lista y la devuelve (la quita de la lista para que no se repita una misma palabra durante una sesión de juegos).

Fin de clase ListaPalabras


Ahora ya tenemos definidas las dos clases que forman parte del proyecto. En la parte siguiente, escribiremos (usando un pseudocódigo), el algoritmo de los métodos de ambas clases.

(CONTINUARÁ)

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Lunes 07 Nov 2011 18:41

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO - Parte 4-A

Responder citando

4. Algoritmo de las propiedades y métodos en pseudocódigo

Ahora vamos a describir, usando un pseudolenguaje, la manera en que cada uno de los métodos de las dos clases anteriores hace su trabajo.
Comencemos por los métodos de la clase Ahorcado.
Código:
•   PonPalabra(Pal de tipo cadena de caracteres)   --- >  No devuelve ningún resultado.
Palabra <--- Pal            //almacena Pal en Palabra
Palabra <--- Mayúscula(Palabra)            //pone Palabra en mayúscula
Conta <--- 0   //Contador de fallos en cero
LetrasUsadas <--- “”   //Lista de letras usadas vacía al comienzo
PalabraMostrada <--- “”
Ciclo i=0 hasta Longitud(Palabra)-1
   PalabraMostrada <--- PalabraMostrada + “_”
Fin Ciclo
//Al final del anterior ciclo, PalabraMostrada tendrá tantos guiones como letras tenga Palabra
      MuestraPalabra(Palabra[0])   //Reemplaza el primer carácter de PalabraMostrada por la primera letra de Palabra (de lo que se encarga el método llamado MuestraPalabra)
      MuestraPalabra(“ “)   //Reemplaza el carácter _ de PalabraMostrada por el carácter espacio donde quiera que esté (para el caso de que Palabra contenga una frase)
Fin PonPalabra


Nota:
El signo < --- significa “asignación”, es decir, darle valor a una variable. Por ejemplo, si se pusiera A < --- 1 significaría que a la variable A se le asigna valor 1.

Código:
•   EligePalabra()   --- > No devuelve ningún resultado.
Si  L.CanPalabras = 0  //Lista L vacía
      RestableceLista()  //Si no quedan palabras volver a llenar lista
Fin Si
p < --- L.PalabraAleatoria()  //El método PalabraAleatoria de L selecciona una palabra aleatoriamente de la lista L y la almacena en la variable p
PonPalabra(p)   //Se pone palabra elegida en propiedad Palabra
   Fin EligePalabra


Nota: Cuando se pone L.CanPalabras, se está usando la propiedad CanPalabras de la lista L, que es una instancia de la clase ListaPalabra. Igualmente L.PalabraAleatoria() significa que se está llamando al método PalabraAleatoria de la lista L.

Código:
•   RestableceLista()   --- > No devuelve nada.
L.LimpiaLista()  //Vacía la lista  L
Ciclo i=0 hasta L2.CanPalabras – 1
   L.AgregaPalabra(L2.TomaPalabra(i)) //Agregar a lista L cada una de las palabras de L2
Fin Ciclo
Fin RestableceLista

•   CopiaLista()   --- > No devuelve nada.
L2.LimpiaLista()  //Vacía la lista  L2
Ciclo i=0 hasta L.CanPalabras – 1
   L2.AgregaPalabra(L.TomaPalabra(i)) //Agregar a lista L2 cada una de las palabras de L
Fin Ciclo
Fin CopiaLista

•    MuestraPalabra(Letra de tipo carácter)    --- > Devuelve resultado de tipo
cadena de caracteres.
agregada < --- AgregaLetraUsada(Letra)  //Se agrega Letra a lista de letras usadas. Si no estuviese ya allí devuelve Verdadero (valor que se almacena en la variable agregada). Si ya estuviese, devuelve Falso y no se agrega a dicha lista

pal < --- “”   //Poner cadena vacía en Pal
b < --- Falso
Ciclo i=0 hasta Longitud(Palabra)-1
   Si Palabra[i] = Letra   //Letra coincide con carácter #i de Palabra
      B < --- Verdadero  //Indica que se encontró Letra en Palabra
      PalabraMostrada[i] < --- Letra    //Reemplazar carácter #i de PalabraMostrada por Letra
   fin Si
   pal < --- pal + PalabraMostrada[i] + Separador   
//pal contiene lo mismo que PalabraMostrada, pero con un carácter de separador entre guión y guión para ser mostrado así
Fin Ciclo
Si b = Falso y agregada = Verdadero   //Intento fallido y letra agregada a lista de fallos
   Incrementar Conta   //El contador de fallos se incrementa en 1
fin Si
devolver pal   //Se devuelve contenido de pal como resultado del método
Fin MuestraPalabra

•   Comprueba()   --- > Devuelve resultado lógico (verdadero o falso).
Si Palabra = PalabraMostrada
   Devolver Verdadero //Se adivinó Palabra
Sino
   Devolver Falso //Aún no ha sido adivinada Palabra
Fin Si
   Fin Comprueba

•   Pierde()   --- > Devuelve resultado lógico (verdadero o falso).
Si Conta > MaxCanti   //Contador de fallos mayor que máxima cantidad de fallos permitidos
   Devolver Verdadero //Juego perdido
Sino
   Devolver Falso //Aún no se ha perdido el juego
Fin Si
Fin Pierde
•   AgregaLetraUsada(Letra de tipo carácter)   --- >   Devuelve verdadero o falso
Si Letra = “ “   //Letra contiene especio. En ese caso no se agrega a lista de letras usadas
   Devolver Falso   //Se abandona método sin agregar
Fin Si
Si Contiene(LetrasUsadas,Letra) = Falso      //Si Letra no está en LetrasUsadas
   Si LetrasUsadas <> “”   //LetrasUsadas no vacía
      LetrasUsadas < --- LetrasUsadas + “,”   //Poner coma entre letra y letra
   Fin Si
   LetrasUsadas < --- LetrasUsadas + Letra
   Devolver Verdadero   //Indica que Letra se agregó a LetrasUsadas
Sino
   Devolver Falso   //Letra no se agregó a LetrasUsadas por ya estar allí
Fin Si
   Fin AgregaLetraUsada


Hasta aquí el algoritmo de la clase Ahorcado. En la siguiente parte veremos el algoritmo de los métodos de la clase ListaPalabras.

(continuará)



Ultima edición por Vila el Miércoles 09 Nov 2011 19:14; editado 2 veces
Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Lunes 07 Nov 2011 19:12

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO - Parte 4-B

Responder citando

Métodos de la clase ListaPalabras.

Código:
•   LimpiaLista()   --- >  No devuelve ningún resultado.
   CanPalabras < --- 0   Pone el contador de palabras de la lista en cero
   Fin LimpiaPalabras

•   AgregaPalabra(Pal de tipo Cadena de Caracteres)   --- >  No devuelve ningún resultado.
   Si Pal <> “” y  CanPalabras < MaxCanti   //Pal no vacía y Lista aún con
               //capacidad
   A[CanPalabras] < --- Pal      //Poner Pal al final del arreglo A
   Incrementar CanPalabras   //Se incrementa en 1 cantidad de
               //palabras en la Lista
   Fin Si
Fin AgregaPalabra

•   EliminaPalabra(NumPalabra de tipo numérico entero)   --- >  No devuelve ningún resultado.
   Ciclo i=NumPalabra hasta CanPalabras-2
   A[i] < --- A[i+1]  //En cada elemento del arreglo A, a partir de
         //índice NumPalabra, ponemos el contenido
         //del siguiente elemento
   Fin Ciclo
   decrementar CanPalabras   //El valor de CanPalabras disminuye
                                                //en 1
Fin EliminaPalabra

•   TomaPalabra(indi de tipo numérico entero)   --- >  Devuelve valor tipo cadena de caracteres
   devolver A[indi]
Fin TomaPalabra

•   PalabraAleatoria()   --- >  Devuelve valor tipo cadena de caracteres
   NumPalabra < --- NúmeroAleatorio (CanPalabras -1)
   P < --- A[NumPalabra]   //Ponemos en p el contenido del elemento
                                       // de A seleccionado aleatoriamente
   EliminaPalabra(NumPalabra)   //Eliminar palabra #NumPalabra
                  //de la Lista (la que se seleccionó)
   Devolver P
Fin PalabraAleatoria


Hasta aquí el algoritmo de los métodos de la clase ListaPalabras. En la siguiente parte se mostrará el algoritmo (también en pseudocódigo) del programa que pone en uso las clases anteriores para jugar.
(continuará)

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Martes 08 Nov 2011 15:49

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO - Parte 5

Responder citando

5. ALGORITMO DEL PROGRAMA PRINCIPAL

Una vez hemos descrito mediante pseudolenguaje los métodos de las clases Ahorcado y ListaPalabras, debemos ahora describir el algoritmo del programa que usará a ambas clases y que será el que ejecute el usuario para jugar. Hay varias formas de hacer este programa. Lo ideal sería crearlo usando las herramientas gráficas que traen los principales lenguajes de POO en uso hoy día, pero para simplificar, lo haremos en “modo consola”, es decir, un modo extremadamente simple que no usa gráficos sino que se comunica con el usuario totalmente en texto.
Comencemos por describir la forma en que deseamos que nuestro programa se comunique con el jugador. Esta es la pantalla que debería aparecernos al ejecutarlo:

    J _ _ _ _ _ _ _ _ _ _ _ _

    Letras usadas:
    J

    Cantidad de fallos: 0

    Teclee letra:

En el ejemplo la palabra a adivinar es: “JUEGO AHORCADO”. Esta es la forma en que se le mostraría al jugador al empezar a jugar. La cantidad de fallos es 0 al comienzo y la letra usada es J por ser la primera de la palabra seleccionada de la lista.
Desarrollemos el algoritmo del programa que hace lo mostrado:

Código:
Programa Principal    //en modo Consola
Ah <--- Instancia de clase Ahorcado   //Para poder usar la clase, hay que crear una instancia de la misma
Ah.L.AgregaPalabra(“Juego Ahorcado”)
Ah.L.AgregaPalabra(“Aventuras del Zorro Reynard”)
Ah.L.AgregaPalabra(“Programacion Orientada a Objetos”)
Ah.L.AgregaPalabra(“Algoritmo”)
Ah.L.AgregaPalabra(“  . . . ”)
Ah.L.AgregaPalabra(“  . . . ”) //Se agregan de esta forma cuantas palabras o frases se desee
   //Todas estas palabras se almacenan en la Lista L de donde serán seleccionadas al azar
Ah.CopiaLista()   //Se crea copia auxiliar de lista L
Ciclo   //Primer ciclo
      Ah.EligePalabra()   //Elige palabra al azar de lista L
      Letra <--- “ “   //Variable usada para que el jugador teclee una a una las letras de la palabra a adivinar
      Ciclo   //Segundo ciclo
         LimpiarPantalla()   //Limpia el contenido de la pantalla en modo consola
         Imprimir(Ah.MuestraPalabra(Letra))   //Muestra palabra con guiones en vez de letras
         Imprimir(“Letras usadas:”)
         Imprimir(Ah.LetrasUsadas)
         Imprimir(“Cantidad de fallos:”)
         Imprimir(Ah.Conta)   //Propiedad que devuelve cantidad de fallos
         C <--- Ah.Comprueba()      //Para comprobar si ya se ganó el juego
         P <--- Ah.Pierde()   //Para comprobar si se perdió el juego
         Si  c=Falso  y  p=Falso   //Ni se ganó ni se perdió aún
            Imprimir(“Teclee letra: “)
            LeerCaracter(Letra)   //Se lee letra desde teclado (sólo si el juego aún no ha terminado)
            Letra <--- Mayúscula(Letra)   //Se convierte Letra a mayúscula
         Fin Si
      Mientras c=Falso y p=Falso   //Fin de segundo ciclo
      Si c = Verdadero
         Imprimir(“¡¡¡ Ud. Ganó el juego !!!”)
      Sino
         Imprimir(“Ud.ha sido ahorcado”)
      Fin si
      Imprimir(“¿Seguir jugando (S/N)?”)
      LeerCaracter(R)
      R <--- Mayúscula(R)   //Convertir R a mayúscula
   Mientras R = “S”   //Fin de primer ciclo
   Fin de programa principal


Tenemos ya desarrollado el programa que usa a la clase Ahorcado y que es el que se ejecutará para poder jugar. En la próxima parte mostraremos el equivalente del anterior pseudocódigo escrito en lenguaje C#, que podrá ya ser ejecutado en la computadora para jugar de verdad (y sobre todo para aprender).


(CONTINUARÁ)

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Martes 08 Nov 2011 17:14

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO - Parte 6-A

Responder citando

6. Programación de las clases en C# y creación de biblioteca (.DLL)

Vamos ahora a programar en lenguaje C# el equivalente del anterior pseudocódigo. Aunque se pueden desarrollar las clases en el mismo proyecto que el programa que las usa, es preferible hacerlo en un proyecto independiente que sea de tipo “Biblioteca de clases”. ¿Por qué? Pues porque de esta forma dicha biblioteca al ser compilada, genera un fichero .dll que puede luego ser usado por cualquier programa que deseemos, lo mismo si es en modo consola que si es en modo gráfico e incluso desde cualquier lenguaje que sea .net (como Visual Basic.net o C++ .net).
El primer paso es por tanto, una vez dentro del medio ambiente del Visual Studio, crear un proyecto nuevo en C# que sea de tipo “Biblioteca de clases” (Class Library). Pongámosle como nombre “JuegoAhorcado”. En el código, pondremos lo siguiente:

Código:
namespace JuegoAhorcado
{
      /*******************************************
       *       J u e g o   A H O R C A D O       *
       *                 por                     *
       *        Orlando Vila García              *
       *            ANTILIA SOFT                 *
       *            Ver. 7/11/2011               *
       *******************************************/

   public abstract class AhorcadoAbstracta
   {
      public abstract int Conta
      { /* Propiedad de sólo lectura que devuelve cantidad
         * de intentos fallidos */
         get;
      }

      public abstract int MaxCanti
      { /* Propiedad que permite indicar máxima cantidad
         * de intentos fallidos que se permitirán
         * (valor asumido = 4) */
         get;
         set;
      }

      protected abstract string Palabra
      { /* Palabra a adivinar. Propiedad de sólo lectura
           * de uso interno a la clase */
         get;
      }

      public abstract void PonPalabra(string Pal);
         /* Método que al ser llamado, pone el valor del parámetro Pal
          * en la propiedad protegida Palabra */

      public abstract string LetrasUsadas
      { /* Propiedad de sólo lectura que devuelve lista de las
         * letras ya usadas en este juego separadas por comas */
         get;
      }

      public abstract void EligePalabra();
         /* Elige palabra aleatoriamente de la lista
          * que las contiene y la pone en la propiedad Palabra.
          * Cada vez que se elija una palabra de la lista,
          * se quita de esta para que no se repita en una
          * misma sesión de juegos */

      public abstract void RestableceLista();
         /* Al ser llamada, restablece la lista de palabras
          * cuando esta quede vacía, a partir de una copia
          * auxiliar que se hizo al comienzo, de manera que
          * se pueda seguir jugando */

      public abstract void CopiaLista();
         /* Al ser llamada, hace una copia de la lista original
          * de palabras en la lista auxiliar. De esta manera será
          * posible cuando se vacíe la lista, restaurarla a partir
          * de la copia */

      public abstract string MuestraPalabra(char Letra);
        /* Devuelve cadena compuesta por caracteres de _
         * correspondiente a letras de cadena aún no adivinadas */

      public abstract bool Comprueba();
        /* Comprueba si Palabra = PalabraMostrada. En caso
         * afirmativo (adivinó la Palabra) devuelve True,
         * en caso negativo (aún no la ha adivinado) devuelve False */

      public abstract bool Pierde();
        /* Devuelve True si perdió el juego por ser Conta (contador
         * de fallos) > MaxCanti (máxima cantidad de fallos permitidos) */

        public abstract bool AgregaLetraUsada(char Letra);
          /* Cada vez que se marque una letra durante el juego actual,
           * la agrega a la propiedad LetrasUsadas separada por una coma
           * de la letra anterior, pero sólo si la letra no estuviese aún
           * en la lista. Devuelve True si se agregó la letra a la lista
           * y False si no se agregó por estar ya */
       
   }
}


El código anterior corresponde a la escritura de una clase “abstracta” (declarada como abstract) llamada AhorcadoAbstracta. La creación de esta clase abstracta no es imprescindible, pues se pudiera directamente escribir la clase Ahorcado basándonos en el pseudocódigo anteriormente expuesto. Sin embargo, es algo que nos ayuda para lo que deseamos hacer. Una clase abstracta es aquella que contiene recursos asbtractos (sean propiedades o métodos), los que a su vez llevan el identificador abstract, aunque también puede contener recursos concretos. Basta con que uno solo de los recursos de una clase sea abstracto para que a su vez la clase tenga obligatoriamente que serlo ella también. Lo mismo las propiedades que los métodos abstractos no se desarrollan en la clase abstracta (es decir no se pone el código que contienen sino sólo su encabezamiento) y es obligación de las clases concretas que sean descendientes de ella hacerlos concretos. Una ventaja de hacer esto es que a este nivel aún no necesitamos poner el código sino tan solo declarar las propiedades y métodos en la clase abstracta sin importarnos aún cómo funcionan, lo que nos permite organizar mejor las ideas. Pero además, cuando creamos la clase descendiente de ella, podremos hacerle sobreescritura (override) de todos los métodos (polimorfismo) desde cualquier clase descendiente de ella, lo que nos permite mayor flexibilidad en la programación.

(CONTINUARÁ)

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Martes 08 Nov 2011 17:19

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO - Parte 6-B

Responder citando

Una vez escrita la clase abstracta, agreguemos una nueva clase al proyecto llamada “Ahorcado” que será descendiente de la clase AhorcadoAbstracta y que por ser concreta sí tendrá que tener desarrollados todos los recursos que herede de esta:
Código:
namespace JuegoAhorcado
{
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;

      /*******************************************
       *       J u e g o   A H O R C A D O       *
       *                 por                     *
       *        Orlando Vila García              *
       *            ANTILIA SOFT                 *
       *            Ver. 7/11/2011               *
       *******************************************/
      
      public class Ahorcado:AhorcadoAbstracta
      { /* Clase para juego de ahorcado descendiente
         * de AhorcadoAbstracta */

         public ListaPalabras L; //Lista de palabras a usar
         public ListaPalabras L2; //Copia de lista de palabras a usar

         public Ahorcado(int nn) //Constructor
         { /* El parámetro nn indica el tamaño de la lista
            * de palabras que se tendrá (y de su copia) */
             L = new ListaPalabras(nn);
             L2 = new ListaPalabras(nn);
         }

         private int _Conta = 0; /* Inicialización en 0 de
                                  * contador de intentos
                                  * fallidos */

         public override int Conta
         { /* Propiedad de sólo lectura que devuelve cantidad
            * de intentos fallidos */
            get
            {
               return _Conta;
            }
         }

         private int _MaxCanti = 4;

         public override int MaxCanti
         { /* Propiedad que permite indicar máxima cantidad
            * de intentos fallidos que se permitirán
            * (valor asumido = 4) */
            get
            {
               return _MaxCanti;
            }
            set
            {
               _MaxCanti = value;
            }
         }

         protected string PalabraMostrada="";
            /* Variable protegida utilizada internamente para
             * construir en ella la palabra a medida que se
             * intenta adivinarla. Cada llamado al método
             * MuestraPalabra reemplaza en ella el carácter _
             * por la letra acertada en la posición que le
             * corresponda */

         private string _Palabra = "";

         protected override string Palabra
         { /* Palabra a adivinar. Propiedad de sólo lectura
            * de uso interno a la clase */
            get
            {
               return _Palabra;
            }
         }

         public override void PonPalabra(string Pal)
         {/* Método que al ser llamado, pone el valor del parámetro Pal
           * en la propiedad protegida Palabra. Inicializa además los
           * valores de las diferentes propiedades para comenzar el
           * juego con esa palabra */
            _Palabra = Pal; //Poner valor del parámetro Pal en la propiedad Palabra
            _Palabra = _Palabra.ToUpper(); //Convertir Palabra a mayúsculas
            _Conta = 0; /* Al fijar nueva palabra a adivinar volver a
                         * poner en 0 contador de intentos de adivinar */
            _LetrasUsadas = ""; //Vaciar lista de letras usadas
            PalabraMostrada = "";
            for (int i = 0; i < Palabra.Length; i += 1)
               PalabraMostrada = PalabraMostrada + "_"; /* Se llena PalabraMostrada
                                                         * con tantos signos de _ como
                                                         * letras tenga la Palabra a
                                                         * adivinar */
            MuestraPalabra(Palabra[0]); /* Al darle nuevo valor a la Palabra a
                                         * adivinar automáticamente es mostrado
                                         * el conjunto de guiones con la primera
                                         * letra ya sustituida */
            MuestraPalabra(' '); /* Igualmente se reemplazan todos los espacios
                                  * en blanco de la cadena (por si Palabra
                                  * contiene una frase) */
         }

         private string _LetrasUsadas="";

         public override string LetrasUsadas
         { /* Propiedad de sólo lectura que devuelve lista de las
            * letras ya usadas en este juego separadas por comas */
            get
            {
               return _LetrasUsadas;
            }
         }

         public override void EligePalabra()
         {/* Elige palabra aleatoriamente de la lista
           * que las contiene y la pone en la propiedad Palabra.
           * Cada vez que se elija una palabra de la lista,
           * se quita de esta para que no se repita en una
           * misma sesión de juegos */
            if (L.CanPalabras == 0) //Lista L vacía
               RestableceLista(); //Si no quedan palabras, volver a llenar lista
            string p = L.PalabraAleatoria(); /* Palabra a devolver. Se toma una palabra
                                              * de la lista L aleatoriamente y se elimina
                                              * de ésta */
            PonPalabra(p); //Se pone la palabra elegida en la propiedad Palabra
         }

         public override void RestableceLista()
         {/* Al ser llamada, restablece la lista de palabras
           * cuando esta quede vacía, a partir de una copia
           * auxiliar que se hizo al comienzo, de manera que
           * se pueda seguir jugando */
            L.LimpiaLista();
            for (int i = 0; i < L2.CanPalabras; i++)
               L.AgregaPalabra(L2.TomaPalabra(i));
         }

         public override void CopiaLista()
         {/* Al ser llamada, hace una copia de la lista original
           * de palabras en la lista auxiliar. De esta manera será
           * posible cuando se vacíe la lista, restaurarla a partir
           * de la copia */
            L2.LimpiaLista();
            for (int i=0; i < L.CanPalabras; i++)
               L2.AgregaPalabra(L.TomaPalabra(i));
         }

         public string Separador = " "; /* Separador entre guiones
                                         * de PalabraMostrada */

         public override string MuestraPalabra(char Letra)
         { /* Devuelve cadena compuesta por caracteres de _ correspondiente
            * a letras de cadena aún no adivinadas */
            bool agregada= AgregaLetraUsada(Letra); /* Agregar Letra marcada a
                                                     * lista de letras usadas.
                                                     * Si agregada vale True,
                                                     * es porque se agregó a dicha
                                                     * lista. Si vale False es
                                                     * porque ya estaba y no se
                                                     * agregó */
            string pal = "";
            bool b = false;
            for (int i = 0; i < Palabra.Length; i += 1)
            {
               if (Palabra[i] == Letra) //Encontrada Letra en posición i
               {
                  b = true;
                  PalabraMostrada = PalabraMostrada.Remove(i, 1);
                  PalabraMostrada = PalabraMostrada.Insert(i, Letra.ToString());
                  /* Las dos instrucciones anteriores reemplazan el carácter _
                   * de la posición i de PalabraMostrada por la Letra que
                   * le corresponde (la primera elimina el carácter _ de la
                   * cadena de la posición i y la segunda inserta la Letra
                   * en su lugar) */
               }
               pal = pal + PalabraMostrada[i] + Separador;
            }
            if (!b && agregada) //Intento fallido y letra fue agregada a la lista
               _Conta += 1; /* Incrementar contador de intentos fallidos
                             * si no se hizo ningún reemplazo y si la letra no
                             * estaba ya en la lista */
            return pal;
         }

         public override bool Comprueba()
         { /* Comprueba si Palabra = PalabraMostrada. En caso
            * afirmativo (adivinó la Palabra) devuelve True,
            * en caso negativo (aún no la ha adivinado)
            * devuelve False */
            return (Palabra == PalabraMostrada);
         }

         public override bool Pierde()
         { /* Devuelve True si perdió el juego por ser Conta
            * (contador de fallos) > MaxCanti (máxima cantidad
            * de fallos permitidos) */
            if (Conta > MaxCanti)
               return true;
            else
               return false;
         }

         public override bool AgregaLetraUsada(char Letra)
         { /* Cada vez que se marque una letra durante el juego actual,
            * la agrega a la propiedad LetrasUsadas separada por una coma
            * de la letra anterior, pero sólo si la letra no estuviese aún
            * en la lista. Devuelve True si se agregó la letra a la lista
            * y False si no se agregó por estar ya */
            if (Letra == ' ') //Si el carácter es el espacio, no agregar a la lista
               return false; //No se agregó a la lista por ser un espacio
            if (LetrasUsadas.Contains(Letra) == false) //Agregar sólo si no está en la lista
            {
               if (_LetrasUsadas != "") //Lista de letras usadas no vacía
                  _LetrasUsadas = _LetrasUsadas + ", "; /* Poner coma antes
                                                         * de nueva letra usada */
               _LetrasUsadas = _LetrasUsadas + Letra.ToString();
               return true; //Se agregó a la lista
            }
            else
               return false; //No se agregó a la lista por estar ya
         }

      }
   }


(CONTINUARÁ)

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Martes 08 Nov 2011 17:38

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO - Parte 6 - C

Responder citando

No nos olvidemos de incluir en el proyecto la clase ListaPalabras que es el tipo de las propiedades L y L2 de la clase Ahorcado:

Código:
namespace JuegoAhorcado
{      
      /*******************************************
       *       J u e g o   A H O R C A D O       *
       *                 por                     *
       *        Orlando Vila García              *
       *            ANTILIA SOFT                 *
       *            Ver. 7/11/2011               *
       *******************************************/

   public class ListaPalabras
   { // Para contener lista de palabras a adivinar
      private string[] A; // Arreglo de strings

      private Random R = new Random(); //Para selección aleatoria

      public ListaPalabras(int nn) //Constructor de la clase
      {
         A = new string[nn]; /* Se crea el arreglo con capacidad
                              * máxima nn (índices desde 0 hasta nn-1) */
         LimpiaLista(); //El arreglo comienza vacío (CanPalabras = 0)
      }

      private int _CanPalabras = 0;

      public int CanPalabras
      { /* Propiedad de sólo lectura que contendrá la cantidad
         * de palabras almacenada en el arreglo A (inicialmente 0) */
         get
         {
            return _CanPalabras;
         }
      }

      public int MaxCanti
      { /* Propiedad de sólo lectura que contendrá la máxima
         * cantidad de palabras que se pueden almacenar en el
         * arreglo A (depende del valor del parámetro con que
         * se llamó al constructor) */
         get
         {
            return A.Length;
         }
      }

      public void LimpiaLista()
      { /* Limpia la Lista de todo su contenido.
         * CanPalabras vuelve a ser 0 */
         _CanPalabras = 0;
      }

      public void AgregaPalabra(string Pal)
      { /* Agrega la palabra Pal al final de la lista e
         * incrementa el contador CanPalabras. De no haber
         * capacidad de almacenamiento (CanPalabras==MaxCanti)
         * se lanza Exception */
         if (Pal != "") //Pal no vacía
         {
            if (CanPalabras < MaxCanti) //Aún hay capacidad
            {
               A[CanPalabras] = Pal;
               _CanPalabras += 1;
            }
            else
               throw new Exception("Lista llena.\n\nNo se pueden agregar más palabras");
         }
      }

      public void EliminaPalabra(int NumPalabra)
      { // Elimina la palabra # NumPalabra de la lista
         for (int i = NumPalabra; i < CanPalabras - 1; i += 1)
            A[i] = A[i + 1];
         _CanPalabras -= 1;
      }

      public string TomaPalabra(int indi)
      { //Devuelve palabra #indi de la lista pero sin quitarla de ella
         return A[indi];
      }

      public string PalabraAleatoria()
      { /* Devuelve una palabra de la lista seleccionada de manera aleatoria
         * y elimina ésta de la lista para que no vuelva a ser seleccionada
         * en la misma sesión de juego */
         int NumPalabra = R.Next(CanPalabras); /* Se genera aleatoriamente
                                                * un número entero (NumPalabra)
                                                * comprendido entre 0 y
                                                * CanPalabras-1 para la selección
                                                * de una palabra aleatoria de la
                                                * lista */
         string p = A[NumPalabra];
         EliminaPalabra(NumPalabra); //Se elimina la palabra de la lista una vez seleccionada
         return p;
      }

   }
}

Ahora, una vez guardado el proyecto en el disco, es necesario compilarlo para crear el archivo .dll, para lo que damos clic en el menú Build y dentro del submenú que se abre, en Build Solution, que compila todas las clases de la solution y genera el archivo JuegoAhorcado.dll.
En la siguiente parte pondremos el código del Programa Principal que usa esta dll.

(CONTINUARÁ

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Martes 08 Nov 2011 18:16

Título del mensaje: CREACIÓN DE UN JUEGO: AHORCADO - Parte 7 y final

Responder citando

7. Programación en C# del programa que usa la DLL ya creada

Ahora viene la parte final de nuestro proyecto, que consiste en escribir el “Programa Principal”, es decir, aquel por el que la ejecución comienza y el que pone en uso a nuestra clase Ahorcado. Como ya dijimos antes, será un proyecto escrito en “Modo Consola” para hacerlo mucho más simple y fácil de entender. Sin embargo, con un poco de imaginación se pudiera crear un proyecto en modo gráfico que usara las mismas clases que ya tenemos escritas.
Desde el medio ambiente del Visual Studio.net, creemos un nuevo proyecto de tipo “Consola” (Console Application) llamado JuegoAhorcadoConsola. Este contendrá en el archivo Program.cs que forma parte de él, una función llamada Main() dentro de la que pondremos el código siguiente:
Código:
namespace JuegoAhorcadoConsola
{
    class Program
    {
       static void Main(string[] args)
       {
          Ahorcado Ah = new Ahorcado(5); /* Al crearse instancia de clase Ahorcado,
                                          * se crea la lista de palabras de tamaño 5 */
          Ah.L.AgregaPalabra("Juego Ahorcado");
          Ah.L.AgregaPalabra("Aventuras del Zorro Reynard");
          Ah.L.AgregaPalabra("Programacion Orientada a Objetos");
          Ah.L.AgregaPalabra("Algoritmo");
          Ah.L.AgregaPalabra("ABC");
          Ah.CopiaLista(); //Copia contenido de la lista de palabras en la lista auxiliar
          string r; //Para leer respuesta de pregunta "¿Seguir jugando (S/N)?"
          do
          {
             Ah.EligePalabra(); //Elige palabra de forma aleatoria de la lista
             bool c, p;
             char letra = ' '; //Usada para leer cada letra que el jugador teclee
             do
             {
                Console.Clear(); //Limpiar pantalla sólo si el juego no termnina aún
                Console.WriteLine(Ah.MuestraPalabra(letra));
                Console.WriteLine();
                Console.WriteLine();
                Console.WriteLine("Letras usadas: "); //Muestra lista de letras usadas
                Console.WriteLine(Ah.LetrasUsadas); //Muestra lista de letras usadas
                Console.WriteLine();
                Console.WriteLine("Cantidad de fallos: " + Ah.Conta.ToString()); //Mostrar cantidad de fallos
                Console.WriteLine();
                c = Ah.Comprueba();
                p = Ah.Pierde();
                if (c == false && p == false)
                {
                   Console.Write("Teclee letra: ");
                   letra = Convert.ToChar(Console.ReadLine().ToUpper());
                   //Se lee letra desde el teclado (sólo si el juego no ha terminado)
                }
             }
             while (c == false && p == false); //Repetir mientras no se gane ni se pierda
             Console.WriteLine();
             Console.WriteLine();
             if (c) //Juego ganado
                Console.WriteLine("   ¡¡¡ UD. GANÓ EL JUEGO !!!");
             else //Se abandonó entonces ciclo porque se perdió
                Console.WriteLine("   UD. HA SIDO AHORCADO");
             Console.WriteLine();
             Console.WriteLine();
             Console.WriteLine();
             Console.Write("¿Seguir jugando (S/N)? ");
             r = Console.ReadLine().ToUpper();
          }
          while (r == "S");
        }

    }
}

Nota:
Cuando creamos la instancia de la clase Ahorcado:
Ahorcado Ah = new Ahorcado(5)
El número 5 que pusimos como argumento de su constructor hará que la lista de palabras que contiene el objeto Ah (o sea L) tendrá capacidad para 5 palabras solamente y por eso le agregamos mediante el método AgregaPalabra tan solo 5 palabras. No hay más que poner el número deseado para que la lista adquiera la capacidad de almacenar todas las palabras que querramos incluirle.


Sin embargo, falta algo muy importante para que este proyecto pueda funcionar, y es la referencia a la biblioteca de clases (.dll) que desarrollamos antes en la que están las definiciones de las clases Ahorcado y ListaPalabras sin las que este programa no puede funcionar. Para ello, vayamos al menú Project (Proyecto) y dentro de su submenú demos clic en Add Reference (Agregar Referencia); veremos entonces una caja de diálogos que nos permite seleccionar el archivo JuegoAhorcado.dll creado al compilar la biblioteca de clases ya hecha, con lo cual, todas las declaraciones públicas que esta contenga podrán ser usadas por nuestro programa.
No queda más que mandar a ejecutar el programa (F5 ó Start Debugging). Si no hubo errores en la escritura, la ejecución debe realizarse sin problemas y… ¡A jugar!
Cualquier duda que tengan, no tienen más que preguntarla.
Esta forma tan detallada de realizar paso a paso un programa, la pueden aplicar a cualquier otro proyecto de programación que deban enfrentar, usando las poderosas herramientas de la POO para solucionar cualquier tipo de problemas.

FIN

Volver arriba
Ver perfil del usuario Enviar mensaje privado
JamTe
Usuario Inquieto


Registrado: 30 Jun 2011
Mensajes: 65
Ubicación: En todas partes menos en la cama

Mensaje Publicado: Viernes 11 Nov 2011 09:51

Título del mensaje: Re: CREACIÓN DE UN JUEGO: AHORCADO

Responder citando

Super Super Super
Asi da gusto!!!!!!!!

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Alunes
Usuario Iniciado


Registrado: 13 Jul 2011
Mensajes: 10
Ubicación: Simelela, Africa del Sur

Mensaje Publicado: Viernes 11 Nov 2011 16:13

Título del mensaje: Re: CREACIÓN DE UN JUEGO: AHORCADO

Responder citando

Muy bien explicado, felicitaciones. Probando.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Vila
Usuario Inquieto


Registrado: 14 May 2010
Mensajes: 136
Ubicación: Vulpesheim

Mensaje Publicado: Viernes 11 Nov 2011 20:31

Título del mensaje: Re: CREACIÓN DE UN JUEGO: AHORCADO

Responder citando

Alunes escribió:
Muy bien explicado, felicitaciones. Probando.


Ok
Me alegro que te haya gustado, Alunes. Puedes aprender mucho si te lo propones. Te invito a entrar en los MP (ver menú del "Indice del Foro", el que aparece al inicio de entrar en el Foro) y ver los mensajes que allí te he dejado (dar clic donde dice "Tiene 1 MP nuevo" ó más de uno)

Saludos
Vila

Volver arriba
Ver perfil del usuario Enviar mensaje privado
mosquetambo



Registrado: 13 Feb 2011
Mensajes: 5

Mensaje Publicado: Domingo 13 Nov 2011 14:36

Título del mensaje: Re: CREACIÓN DE UN JUEGO: AHORCADO

Responder citando

Hola comunidad "LOSPILLAOS.ES"
Gracias por acordarse de mi y enviarme el e-mail con el enlace a la publicación de Vila.
Estoy bastante recargado de proyectos pero he de buscar algún momento para estudiar este tema.
Tambien quiero manifestar mi agradecimiento a agradecido a Orlando Vila García intentar ayudarnos.
Estoy seguro de estar expresando no solo mis sentimientos sino los de todos los novatos que como yo navegamos la red intentando reducir la (tal vez mal llamada) "brecha digital"
Mosquetambo

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema Ir a página 12Siguiente
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 1 Hora

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Mi juego Indie

javier_macross Programación de juegos o videojuegos 1 Miércoles 19 Nov 2014 03:37 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Crear un juego en Android 3D

Wozen 3D 1 Viernes 03 Oct 2014 19:25 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Vampirako, juego indie [Android]

OmarSD Programación de juegos o videojuegos 4 Domingo 31 Ago 2014 18:03 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Ayuda, cómo crear un juego FÁCIL Y SENCILLO par...

fercoslado Programación Web en general 0 Jueves 26 Jun 2014 00:51 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Paginas interesantes para la creación y persona...

P3p3 Temas generales 0 Domingo 22 Jun 2014 10:08 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,