Está en la página 1de 5

Juego del Snake

TOPICOS AVANZADOS DE PROGRAMACION


Juego del Snake
El origen del sencillo juego es en realidad el arcade, cuando en 1976 fuese lanzado
por Gremlin Industries y aún ni se hacía referencia a una serpiente que fue bautizado
como Blockade. El juego llegó a los hogares cuando Atari lanzase una versión no
oficial de Blockade para consolas titulada Surround. Poco después, en 1978, llegaría
Worm a los ordenadores de la mano de P. Trefonas, que sería la versión para
ordenador del posterior Snake.

El juego se trasladó algo más de una década cuando en 1998 Nokia empezó a
incorporarse en sus móviles a partir del Nokia 6110. No era una oferta exclusiva: los
Nokia del momento, incluían una carpeta de Juegos dentro de Aplicaciones, en la cual
se encontraban además el Memory y el Rotation. Pero estos juegos quedaron en la
sombra debido al éxito de la Serpiente.

En el juego, el jugador o usuario controla una larga y delgada criatura, semejante a


una serpiente, que vaga alrededor de un plano delimitado, recogiendo alimentos (o
algún otro elemento), tratando de evitar golpear a su propia cola o las "paredes" que
rodean el área de juego. Cada vez que la serpiente se come un pedazo de comida, la
cola crece más, provocando que aumente la dificultad del juego. El usuario controla la
dirección de la cabeza de la serpiente (arriba, abajo, izquierda o derecha) y el cuerpo
de la serpiente la sigue. Además, el jugador no puede detener el movimiento de la
serpiente, mientras que el juego está en marcha.

El funcionamiento del juego se apoya en 4 funciones:

1. El código que se encarga de dibujar la serpiente en la pantalla en su nueva


posición. El código indicando si el movimiento es posible, si no lo es, porque
la serpiente choca contra los bordes de la pantalla o contra su propia cola
devuelve false provocando el fin del juego.
2. El responsable de capturar las pulsaciones de teclado del jugador y modificar
la dirección que sigue la serpiente en función de éstas.
3. Se encarga de calcular la nueva posición de la serpiente teniendo en cuenta
su posición actual y la dirección.
4. Muestra en pantalla, en una posición aleatoria, un elemento que representa la
comida de la serpiente. Devuelve la posición en la que se ha mostrado la
comida.
// Código principal //
using System; if (e.KeyCode == Keys.Right)
using System.Drawing; {
using System.Windows.Forms; Y = 0;
X = Mov;
namespace Proyecto_Snake _X = true;
{ _Y = false;
public partial class Snake : Form }
{ }
Graphics g; }
Serpiente Cabeza;
Comida Ratas; private void tJuego_Tick(object
int X, Y, Mov = 10, i; sender, EventArgs e)
bool _X, _Y; {
g.Clear(Color.FromArgb(33, 33,
public Snake() 33));
{ Cabeza.Dibujar(g);
InitializeComponent(); Ratas.Dibujar(g);
Puntos(this, 0); Mover();
X = 0; Y = 0; i = 0; ChocarCuerpo();
_X = true; _Y = true; ChocarPared();
g = this.CreateGraphics();
Cabeza = new Serpiente(10, 10); if (Cabeza.Chocar(Ratas))
Ratas = new Comida(); {
this.Opacity = .85; i++;
} Puntos(this, i);
Ratas.Regenerar();
private void Snake_KeyDown(object Cabeza.Crecer();
sender, KeyEventArgs e) }
{ }
if(_X)
{ private void Puntos(Form f, int i)
if(e.KeyCode == Keys.Up) {
{ f.Text = "Score: " + i;
Y = -Mov; }
X = 0;
_X = false; private void Mover()
_Y = true; {
} Cabeza.setXY(Cabeza.getX() + X,
Cabeza.getY() + Y);
if (e.KeyCode == Keys.Down) }
{
Y = Mov; private void ChocarCuerpo()
X = 0; {
_X = false; Serpiente Muerta = null;
_Y = true;
} try
} {
if(_Y) Muerta =
{ Cabeza.getSiguiente().getSiguiente();
if (e.KeyCode == Keys.Left) }
{ catch(Exception e)
Y = 0; {
X = -Mov;
_X = true; }
_Y = false;
} while(Muerta != null)
{
if(Cabeza.Chocar(Muerta)) {
{
GameOver(); int DifX = Math.Abs(this.x - O.x);
}
else int DifY = Math.Abs(this.y - O.y);
{
Muerta =
Muerta.getSiguiente();
} if((DifX >= 0 && DifX < ancho) &&
} (DifY >= 0 && DifY < ancho))
}
{
private void ChocarPared()
{ return true;
if (Cabeza.getX() < 0 ||
Cabeza.getX() > 470 || }
Cabeza.getY() < 0 ||
Cabeza.getY() > 460) else
{
GameOver(); {
}
} return false;

private void GameOver() }


{
Puntos(this, 0); }
X = 0; Y = 0; i = 0;
_X = true; _Y = true; }
g = this.CreateGraphics();
Cabeza = new Serpiente(10, 10); }
Ratas = new Comida();
} // Código de comida: //
}
} using System;
using System.Drawing;
// Código de Objetos: //
namespace Proyecto_Snake
using System; {
class Comida : Objetos
namespace Proyecto_Snake {
public Comida()
{ {
this.x = Generar(47);
class Objetos this.y = Generar(46);
}
{
public void Dibujar(Graphics g)
protected int x, y, ancho; {
g.FillRectangle(new
SolidBrush(Color.FromArgb(231, 106,
24)), this.x,
public Objetos() this.y, this.ancho, this.ancho);
}
{
public int Generar(int n)
ancho = 10; {
Random rnd = new Random();
} int X = rnd.Next(0, n) * 10;
return X;
public bool Chocar(Objetos O)
} {
Cuerpo.Crecer();
public void Regenerar() }
{ }
this.x = Generar(47);
this.y = Generar(46); public int getX()
} {
} return x;
}
}
public int getY()
// Código de Serpiente: // {
return y;
using System.Drawing; }
namespace Proyecto_Snake public Serpiente getSiguiente()
{ {
class Serpiente : Objetos return Cuerpo;
{ }
Serpiente Cuerpo; }
public Serpiente(int x, int y) }
{
this.x = x;
this.y = y;
Cuerpo = null;
}

public void Dibujar(Graphics g)


{
if(Cuerpo != null)
{
Cuerpo.Dibujar(g);
}
g.FillEllipse(new
SolidBrush(Color.FromArgb(0, 230, 118)),
this.x,
this.y, this.ancho, this.ancho);
}

public void setXY(int x, int y)


{
if (Cuerpo != null)
{
Cuerpo.setXY(this.x,this.y);
}
this.x = x;
this.y = y;
}

public void Crecer()


{
if (Cuerpo == null)
{
Cuerpo = new
Serpiente(this.x,this.y);
}else