Foros del Web » Programación para mayores de 30 ;) » .NET »

Cuerpo de la viborita en letras (Juego) - C#

Estas en el tema de Cuerpo de la viborita en letras (Juego) - C# en el foro de .NET en Foros del Web. ¡Hola! Pues recién me voy adentrando en el C#, y busqué un tutorial para hacer el juego de la viborita, y ya lo acabé, incluso ...
  #1 (permalink)  
Antiguo 25/01/2016, 18:36
Avatar de OPMUANRK  
Fecha de Ingreso: diciembre-2014
Mensajes: 52
Antigüedad: 9 años, 11 meses
Puntos: 1
Exclamación Cuerpo de la viborita en letras (Juego) - C#

¡Hola!
Pues recién me voy adentrando en el C#, y busqué un tutorial para hacer el juego de la viborita, y ya lo acabé, incluso le agregué unas líneas para que me guardara mi récord, pero lo que quiero hacer, es que en vez de bolitas, me salgan las letras de un nombre que escriba. Y cada que coma una bolita, se escriba mi nombre de nuevo, por ejemplo: "Juan" y si como una bolita "JuanJuan", que cada letra sea una bolita. Al iniciar el juego me pide mi nombre para mostrarlo en un label, pero ese lo pongo arriba del área del juego, la viborita está hecha en círculos.

En fin, mi código es este:

Clase círculos
Código C#:
Ver original
  1. namespace Viborita
  2. {
  3.     class Circulos
  4.     {
  5.         //Cuerpo de la víbora, con vectores "X" y "Y"
  6.         public int X
  7.         {
  8.             get;
  9.             set;
  10.         }
  11.         public int Y
  12.         {
  13.             get;
  14.             set;
  15.         }
  16.         //Constructor
  17.         public Circulos()
  18.         {
  19.             X = 0;
  20.             Y = 0;
  21.         }
  22.     }
  23. }

Clase Entrada
Código C#:
Ver original
  1. namespace Viborita
  2. {
  3.     class Entrada
  4.     {
  5.         //Esto carga la lista de los botones disponibles del teclado
  6.         private static Hashtable keyTable = new Hashtable();
  7.  
  8.         //Verificar si un botón en especifico es presionado
  9.         public static bool KeyPressed (Keys key)
  10.         {
  11.             if(keyTable[key]==null)
  12.             {
  13.                 return false;
  14.             }
  15.             return (bool) keyTable[key];
  16.         }
  17.         //Detecta si un botón del teclado es presionado
  18.         public static void CambiarEstado(Keys key, bool estado)
  19.         {
  20.             keyTable[key] = estado;
  21.         }
  22.     }
  23. }

Clase Config
Código C#:
Ver original
  1. namespace Viborita
  2. {
  3.     public enum Direccion
  4.     {
  5.         Arriba,
  6.         Abajo,
  7.         Izq,
  8.         Der,
  9.     };
  10.  
  11.     class Config
  12.     {
  13.         //Ancho y alto determinan lo alto y lo ancho de los círculos en pixeles horizontales y verticales.
  14.         public static int Ancho
  15.         {
  16.             get;
  17.             set;
  18.         }
  19.         public static int Alto
  20.         {
  21.             get;
  22.             set;
  23.         }
  24.         //Qué tan rápido se mueve la víbora.
  25.         public static int Velocidad
  26.         {
  27.             get;
  28.             set;
  29.         }
  30.         //Puntuación, es la puntuación total del juego.
  31.         public static int Puntuacion
  32.         {
  33.             get;
  34.             set;
  35.         }
  36.         //El número de puntos que se añadirán cada que se coma.
  37.         public static int Puntos
  38.         {
  39.             get;
  40.             set;
  41.         }
  42.         //Si está en true, el juego terminará.
  43.         public static bool FinJuego
  44.         {
  45.             get;
  46.             set;
  47.         }
  48.         public static Direccion direccion
  49.         {
  50.             get;
  51.             set;
  52.         }
  53.  
  54.         //Constructor
  55.         public Config()
  56.         {
  57.             Ancho = 15;
  58.             Alto = 15;
  59.             Velocidad = 10;
  60.             Puntuacion = 0;
  61.             Puntos = 25;
  62.             FinJuego = false;
  63.             direccion = Direccion.Abajo;
  64.         }
  65.     }
  66. }
ABAJO LES DEJO LA CLASE FORM1

Cabe mencionar que hice una referencia a Visual Basic para poder usar el campo para escribir al principio del programa.

Agradecería mucho su ayuda y mucho mejor si me explican lo que hicieron :D
  #2 (permalink)  
Antiguo 25/01/2016, 18:37
Avatar de OPMUANRK  
Fecha de Ingreso: diciembre-2014
Mensajes: 52
Antigüedad: 9 años, 11 meses
Puntos: 1
Exclamación Respuesta: Cuerpo de la viborita en letras (Juego) - C#

Y por último la clase form1

Código C#:
Ver original
  1. namespace Viborita
  2. {
  3.     public partial class Form1 : Form
  4.     {
  5.         int Record;
  6.         int RecordFinal;
  7.         //Cuerpo de la víbora
  8.         private List<Circulos>Viborita = new List<Circulos>();
  9.         //Formar comida
  10.         private Circulos comida = new Circulos();
  11.        
  12.         public Form1()
  13.         {
  14.             InitializeComponent();
  15.             //Cargar las configuraciones predeterminadas
  16.             new Config();
  17.             //Establecer la velocidad y empezar el temporizador
  18.             Tiempo.Interval = 1000 / Config.Velocidad;
  19.             Tiempo.Tick += Actualizar;
  20.             Tiempo.Start();
  21.             //Cuadro de diálogo para escribir tu nombre (Hacer referecia a Visual Basic para que funcione)
  22.             string nombre = Microsoft.VisualBasic.Interaction.InputBox("Escribe tu nombre", "Bienvenido", "");
  23.             lbNombre.Text = nombre;
  24.             //Empezar el juego
  25.             EmpezarJuego();
  26.         }
  27.  
  28.         private void EmpezarJuego()
  29.         {
  30.             lbFinJuego.Visible = false;
  31.             //Cargar las configuraciones predeterminadas
  32.             lbrecord.Text = RecordFinal.ToString();
  33.             new Config();
  34.  
  35.             //Esto crea a la víbora y la pone en el juego
  36.             Viborita.Clear();
  37.             Circulos cabeza = new Circulos();
  38.             cabeza.X = 10;
  39.             cabeza.Y = 5;
  40.             Viborita.Add(cabeza);
  41.  
  42.             lbPuntos.Text = Config.Puntuacion.ToString();
  43.  
  44.             GenerarComida();
  45.         }
  46.         //Genera la comida aleatoriamente en la pantalla
  47.         private void GenerarComida()
  48.         {
  49.             //Divide la altura y anchura de nuestra área de juego por la de la configuración
  50.             //para tener una variable qué usar y en dónde ponerla sin salir del área
  51.             int PosicionXmax = pbArea.Size.Width / Config.Ancho;
  52.             int PosicionYmax = pbArea.Size.Height / Config.Alto;
  53.  
  54.             //Esto crea un nuevo objeto aleatorio y un objeto de comida
  55.             //y lo coloca en un lugar del área de juego entre cero y el máximo del área de juego en X y Y
  56.             Random aleatorio = new Random();
  57.             comida = new Circulos();
  58.             comida.X = aleatorio.Next(0, PosicionXmax);
  59.             comida.Y = aleatorio.Next(0, PosicionYmax);
  60.         }
  61.  
  62.         private void Actualizar (object sender, EventArgs e)
  63.         {
  64.             //Ver si el juego terminó
  65.             if (Config.FinJuego==true)
  66.             {
  67.                 //Verificar si la tecla Enter es presionada
  68.                 if (Entrada.KeyPressed(Keys.Enter))
  69.                 {
  70.                     EmpezarJuego();
  71.                     Viborita.Clear();
  72.                     string nom = lbNombre.Text;
  73.                     string nombre = Microsoft.VisualBasic.Interaction.InputBox("Escribe tu nombre", "Bienvenido",""+nom+"");
  74.                     lbNombre.Text = nombre;
  75.                     nom = nombre;
  76.                     EmpezarJuego();
  77.                 }
  78.                
  79.             }
  80.             else
  81.             {
  82.                 if (Entrada.KeyPressed(Keys.Right) && Config.direccion != Direccion.Izq)
  83.                     Config.direccion = Direccion.Der;
  84.                 else if (Entrada.KeyPressed(Keys.Left) && Config.direccion != Direccion.Der)
  85.                     Config.direccion = Direccion.Izq;
  86.                 else if (Entrada.KeyPressed(Keys.Up) && Config.direccion != Direccion.Abajo)
  87.                     Config.direccion = Direccion.Arriba;
  88.                 else if (Entrada.KeyPressed(Keys.Down) && Config.direccion != Direccion.Arriba)
  89.                     Config.direccion = Direccion.Abajo;
  90.  
  91.                 Moverse();
  92.             }
  93.                 pbArea.Invalidate();
  94.         }
  95.  
  96.         private void Tiempo_Tick(object sender, EventArgs e)
  97.         {
  98.             throw new NotImplementedException();
  99.         }
  100.  
  101.         private void label1_Click(object sender, EventArgs e)
  102.         {
  103.  
  104.         }
  105.  
  106.         private void lbPuntos_Click(object sender, EventArgs e)
  107.         {
  108.  
  109.         }
  110.  
  111.         private void Form1_Load(object sender, EventArgs e)
  112.         {
  113.  
  114.         }
  115.  
  116.         private void pbArea_Paint(object sender, PaintEventArgs e)
  117.         {
  118.             Graphics area = e.Graphics;
  119.  
  120.             if(!Config.FinJuego)
  121.             {
  122.                 //Establecer el color de la víbora
  123.                 Brush colorVib;
  124.  
  125.                 //Colores de la víbora
  126.                 for(int i=0; i< Viborita.Count; i++)
  127.                 {
  128.                     if (i == 0)
  129.                         colorVib = Brushes.Black; //Dibuja la cabeza
  130.                     else
  131.                         colorVib = Brushes.OrangeRed; //Dibuja el resto del cuerpo
  132.  
  133.                     //Dibujar la víbora
  134.                     area.FillEllipse(colorVib, new Rectangle(Viborita[i].X * Config.Ancho,
  135.                         Viborita[i].Y * Config.Alto,
  136.                         Config.Ancho, Config.Alto));
  137.  
  138.                     //Dibujar comida
  139.                     area.FillEllipse(Brushes.Green,
  140.                         new Rectangle(comida.X * Config.Ancho,
  141.                         comida.Y * Config.Alto, Config.Ancho, Config.Alto));
  142.  
  143.                 }
  144.             }
  145.             else
  146.             {
  147.                 string finjuego = "Fin del juego.\nTu puntuación final fue: " + Config.Puntuacion +
  148.                     "\n Presiona la tecla Enter para reintentar.";
  149.                 if (RecordFinal==0)
  150.                 {
  151.                     Record = Config.Puntuacion;
  152.                     RecordFinal = Record;
  153.                 }
  154.                 if(Config.Puntuacion>RecordFinal)
  155.                 {
  156.                     RecordFinal = Config.Puntuacion;
  157.                 }
  158.                 lbFinJuego.Text = finjuego;
  159.                 lbFinJuego.Visible = true;
  160.             }
  161.         }
  162.  
  163.         private void Moverse()
  164.         {
  165.             for(int i = Viborita.Count -1; i>=0; i--)
  166.             {
  167.                 //Mover cabeza
  168.                 if (i == 0)
  169.                 {
  170.                     switch (Config.direccion)
  171.                     {
  172.                         case Direccion.Der:
  173.                             Viborita[i].X++;
  174.                             break;
  175.                         case Direccion.Izq:
  176.                             Viborita[i].X--;
  177.                             break;
  178.                         case Direccion.Arriba:
  179.                             Viborita[i].Y--;
  180.                             break;
  181.                         case Direccion.Abajo:
  182.                             Viborita[i].Y++;
  183.                             break;
  184.                     }
  185.                     //Obtener las posiciones máximas de X y Y
  186.                     int maxX = pbArea.Size.Width / Config.Ancho;
  187.                     int maxY = pbArea.Size.Height / Config.Alto;
  188.  
  189.                     //Detectar la colisión en las paredes
  190.                     if (Viborita[i].X < 0 || Viborita[i].Y < 0
  191.                         || Viborita[i].X >= maxX || Viborita[i].Y >= maxY)
  192.                     {
  193.                         Muere();
  194.                     }
  195.                     //Detectar colisión con el cuerpo
  196.                     for(int j=1; j<Viborita.Count; j++)
  197.                     {
  198.                         if(Viborita[i].X == Viborita[j].X &&
  199.                             Viborita[i].Y == Viborita[j].Y)
  200.                         {
  201.                             Muere();
  202.                         }                
  203.                     }
  204.                     //Detectar colisión con la comida
  205.                     if(Viborita[0].X==comida.X && Viborita[0].Y == comida.Y)
  206.                     {
  207.                         Come();
  208.                     }
  209.                 }
  210.                 else
  211.                 {
  212.                     //Mover el cuerpo
  213.                     Viborita[i].X = Viborita[i - 1].X;
  214.                     Viborita[i].Y = Viborita[i - 1].Y;
  215.                 }
  216.             }
  217.         }
  218.  
  219.         private void Come()
  220.         {
  221.             //Agregar un círculo a la víbora
  222.             Circulos comida = new Circulos();
  223.             comida.X = Viborita[Viborita.Count - 1].X;
  224.             comida.Y = Viborita[Viborita.Count - 1].Y;
  225.  
  226.             Viborita.Add(comida);
  227.  
  228.             //Actualizar puntaje
  229.             Config.Puntuacion += Config.Puntos;
  230.             lbPuntos.Text = Config.Puntuacion.ToString();
  231.                        
  232.             GenerarComida();
  233.         }
  234.  
  235.         private void Muere()
  236.         {
  237.             Config.FinJuego = true;
  238.         }
  239.  
  240.         private void lbFinJuego_Click(object sender, EventArgs e)
  241.         {
  242.  
  243.         }
  244.  
  245.         private void Form1_KeyDown(object sender, KeyEventArgs e)
  246.         {
  247.             Entrada.CambiarEstado(e.KeyCode, true);
  248.         }
  249.  
  250.         private void Form1_KeyUp(object sender, KeyEventArgs e)
  251.         {
  252.             Entrada.CambiarEstado(e.KeyCode, false);
  253.         }
  254.  
  255.         private void label1_Click_1(object sender, EventArgs e)
  256.         {
  257.  
  258.         }
  259.  
  260.         private void label1_Click_2(object sender, EventArgs e)
  261.         {
  262.  
  263.         }
  264.  
  265.         private void tbNomre_TextChanged(object sender, EventArgs e)
  266.         {
  267.          
  268.         }
  269.  
  270.         private void BAplicar_Click(object sender, EventArgs e)
  271.         {
  272.         }
  273.  
  274.         private void pbArea_Click(object sender, EventArgs e)
  275.         {
  276.          
  277.         }
  278.     }
  279. }
  #3 (permalink)  
Antiguo 26/01/2016, 06:09
 
Fecha de Ingreso: octubre-2014
Ubicación: Madrid
Mensajes: 1.212
Antigüedad: 10 años, 1 mes
Puntos: 204
Respuesta: Cuerpo de la viborita en letras (Juego) - C#

La colleja para empezar. Este foro es de C/C++. Para cuestiones de C# deberías acudir al foro de .NET.

Tener una clase llamada Circulos que realmente gestiona un único objeto en la pantalla (que, como bien dices pretendes que no sea ni tan siquiera un círculo es algo que tienes que evitar. Nombes de clases, métodos y variables coherentes a la utilidad que van a satisfacer mejoran la lectura del código y evitan errores.

Una posible solución pasa porque la clase Circulos almacenase una imagen. A la hora de pintar el objeto bastaría con recuperar la imagen asociada. Aun así la gestión de las imágenes podría ser un poco tortuosa, ya que ahora mismo utilizas este objeto para ubicar la comida y para pintar la serpiente.

El problema que le veo a pintar cada segmento de la serpiente con un texto es que el texto, si esperas que sea legible, no lo puedes comprimir todo lo que tu quieras y has de ser consciente que el texto ha de entrar en el hueco que ahora ocupa cada segmento de la serpiente. Quizás sería más realizable que cada segmento estuviese representado por una letra del texto.

Yo personalmente estructuraría un poco más el código, delegar toda la labor de pintado en el evento OnPaint del Form me parece excesivo, creo que cada objeto de la escena debería ser capaz de pintarse por si solo. ¿Por qué? El concepto detrás de esta idea se llama aislamiento y para no enrollarnos demasiado va encaminado a que puedas enviar a la escena lo que te de la gana sin tener que modificar el motor gráfico (sí, ahora mismo el evento OnPaint hace las veces de motor gráfico de tu juego). Imagínate que añades varios tipos de comida... te tocará modificar el evento OnPaint para que sepa pintar cada uno de ellos... no parece una solución muy elegante ni tampoco escalable.

Un saludo.
__________________
La ayuda se paga con esfuerzo o con dinero. Si no estás dispuesto a esforzarte y quieres que te hagan los deberes pide presupuesto, al menos así ahorrarás tiempo.
  #4 (permalink)  
Antiguo 26/01/2016, 18:30
Avatar de OPMUANRK  
Fecha de Ingreso: diciembre-2014
Mensajes: 52
Antigüedad: 9 años, 11 meses
Puntos: 1
Respuesta: Cuerpo de la viborita en letras (Juego) - C#

Gracias eferion, te digo que soy nuevo en esto del C#, generalmente trabajo con HTML y PHP.

Y sobre lo de los círculos, los usé para crear el juego normal, pero luego me pidieron que hiciera eso con las letras y es ahí donde surgieron los problemas.

Muchas gracias por tu ayuda.

Etiquetas: c#, c-c++, juego, nombre
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta




La zona horaria es GMT -6. Ahora son las 08:59.