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

Hacer juego de viborita con letras C#.

Estas en el tema de Hacer juego de viborita con letras C#. en el foro de .NET en Foros del Web. Hola, había puesto este tema en C/C++, pero esto es de C#, así que.... Pues recién me voy adentrando en el C#, y busqué un ...
  #1 (permalink)  
Antiguo 29/01/2016, 16:53
Avatar de OPMUANRK  
Fecha de Ingreso: diciembre-2014
Mensajes: 52
Antigüedad: 9 años, 4 meses
Puntos: 1
Pregunta Hacer juego de viborita con letras C#.

Hola, había puesto este tema en C/C++, pero esto es de C#, así que....

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, que se forme de nuevo "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.

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 29/01/2016, 16:55
Avatar de OPMUANRK  
Fecha de Ingreso: diciembre-2014
Mensajes: 52
Antigüedad: 9 años, 4 meses
Puntos: 1
Exclamación Respuesta: Hacer juego de viborita con letras 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. }

Como ya dije, soy nuevo, y quisiera saber, gracias de nuevo.

Etiquetas: c#, juego, letras
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 23:15.