c# ¡Diseña el juego de propietarios! Entran los expertos
espacio de nombres GreedySnake
{
#region Serpiente Cuerpo de serpiente
///
/// Descripción abstracta de Snake.
///
clase pública Snake
{
Control privado dcControl; p>
private static int iMoveDirection = 0x1000; // La dirección de movimiento de la serpiente, inicializada hacia la derecha - 0x1000
private int iCount; // Número total de huesos
private int iRadius; // Radio del hueso
private static int iCurrentHeadX; // El centro X de la cabeza de serpiente actual
private static int iCurrentHeadY ; // El centro Y de la cabeza de serpiente actual
private static int iCurrentTrailX // El centro X de la cola de serpiente actual
private static int iCurrentTrailY // El centro Y de la cola de la serpiente actual
private static int iNextHeadX; // El centro de la cabeza de la serpiente en el siguiente momento, Point
private static int iPreTrailY // El punto central de la serpiente cola en el último momento Y
private static ArrayList alSnake; // Almacena la serpiente completa
private bool bDisposing = true
private bool bIsEatSelf = false; // Si se debe comer uno mismo
private bool bIsOutOfRange = false // Si se debe exceder el rango
public Control DcControl
{
establecer { dcControl = valor }
obtener { return dcControl }
}
public int MoveDirection
{
establecer { iMoveDirection = valor }
obtener { return iMoveDirection }
}
public int Count
{
establecer { iCount = valor }
obtener { return iCount }
}
radio int público
{
establecer { iRadius = valor }
obtener { return iRadius }
}
public int CurrentHeadX<; /p>
{
establecer { iRadius = valor }
obtener { return iRadius }
}
público; int CurrentHeadX
{
establecer { iCurrentHeadX = valor }
obtener { return iCurrentHeadX }
}
public int CurrentHeadY<
{
set { iCurrentHeadY = valor }
get { return iCurrentHeadY }
}
public int CurrentTrailX
{
establecer { iCurrentTrailX = valor }
obtener { return iCurrentTrailX }
public int CurrentTrailY
{
set { iCurrentTrailY = valor }
get { return iCurrentTrailY }
}
public int NextHeadX
{
set { iNextHeadX = valor }
get { return iNextHeadX }
}
public int NextHeadY
{
set { iNextHeadY = value;}
get { return iNextHeadY; }
}
public int PreTrailX
{
establecer { iPreTrailX = valor }
get { return iPreTrailX; }
}
public int PreTrailY
{
p> set { iPreTrailY = valor }
get { return iPreTrailY }
}
public bool IsEatself
{
set { bIsEatself = valor; }
get { return bIsEatself }
}
public bool IsOutOfRange
{
set { bIsOutOfRange = valor; }
obtener { return bIsOutOfRange }
}
pu
blic Snake(): this(null, 20, 5)
{
//
// TODO: Agregar lógica de constructor aquí
//
}
serpiente pública(): this(null, 20, 5)
{
//
public Snake( Control control , int iCount , int iRadius)
{
DcControl = control
Count = iCount
p>
Radio = iRadius;
CurrentHeadX = CurrentTrailX = PreTrailX = 5
CurrentHeadY = CurrentTrailY = PreTrailY = 5; > Inicializar();
}
~Serpiente()
{
Desechar(falso); > }
// Inicializar Snake
private void Inicializar()
{
alSnake = new ArrayList();
for (int i=0; i {
alSnake.Insert(0, new SnakeNode(DcControl, CurrentHeadX, CurrentHeadY, Radius));
CurrentHeadX = 2 * Radio;
}
CurrentHeadX -= 2 * Radio;
NextHeadX = CurrentHeadX 2 * Radio
NextHeadY = CurrentHeadY <; /p>
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize( this);
p>}
public void Dispose( bool bDisposing)
{
if ( bDisposing)
{
// Llama a Dispose para eliminar campos en recursos controlados
MoveDirection = 0x1000
CurrentHeadX = CurrentHeadY = NextHeadX = NextHeadY = 5 <; /p>
alSpose( bool bDisposing )
{
// Llama a Dispose para eliminar campos en recursos controlados.
alSnake.Clear();
}
// Limpiar recursos no controlados
}
// Agregar encabezado
public void AddHead()
{
alSnake.Insert(0, new Snake Novell);
alSnake.RemoveAt (alSnake.Count - 1);
Conteo--;
CurrentTrailX = ((SnakeNode)alSnake[Count - 1]).CenterX
CurrentTrailY; = ((SnakeNode)alSnake[Count - 1]).CenterY;
}
}
// Pasar a la siguiente posición
public void MoveNext()
{
// Agregar título.
AddHead();
// Dibuja la cabeza
((SnakeNode)alSnake[0]).Clear(); > // RemoveTrail (elimina la cola de serpiente de ArrayList)
RemoveTrail()
}
// Dibuja el serpiente entera
public void Draw()
{
for (int i=0; i {
((SnakeNode)alSnake [i ]).Draw();
}
}
// Limpia toda la serpiente
public void Clear()
{
for (int i=0; i {
((SnakeNode)alSnake[i]).Clear();
}
}
}
// Restablecer la dirección del movimiento
public void ResetMoveDirection(string strKeyData)
{
// Obtener entrada del teclado
int iKeyDirection;
switch (strKeyData)
{
caso "W":
caso "Arriba":
iKeyDirection = 0x0001
descanso
caso "S"; :
caso "Abajo":
iKeyDirection = 0x0010
descanso
caso "A":
<; p> case "Izquierda":iKeyDirection = 0x0100;
break
case "D":
case "Derecha" :
iKeyDirection = 0x1000;
interrupción
Predeterminado:
iKeyDirection = 0x0010
interrupción;
p>
}
//Restablece la dirección de movimiento de la serpiente (teniendo en cuenta la dirección de la tecla y la dirección de movimiento actual de la serpiente)
int iDirection = iKeyDirection;
if (iDirection == 0x0011 || iDirection == 0x1100)
MoveDirection = MoveDirection // La dirección del movimiento permanece sin cambios
else
MoveDirection = iKeyDirection; // La dirección del movimiento es igual a la dirección de la tecla
}
// Si está fuera de rango
public void Check()
{
GetNextHeadXY();
// Comprueba si se está comiendo a sí mismo
foreach (Sn Sn en alSnake)
{
if (sn.CenterX == NextHeadX amp; amp; sn.CenterY == NextHeadY)
{
IsEatself = true;
break;
}
}
}
// Comprobar si se excede el rango de actividad permitido
IsOutOfRange = NextHeadXlt; 0 ||| NextHeadXgt; DcControl.Width ||| NextHeadYlt.0 || NextHeadX; = CurrentHeadX - 2 * radio;
NextHeadX = CurrentHeadX - 2 * radio
NextHeadY = CurrentHeadY
break; 0x1000:
NextHeadX = CurrentHeadX 2 * radio
NextHeadY = CurrentHeadY
descanso
Predeterminado:
romper;
}
}
#endregion
#region SnakeNode Esqueleto de serpiente
// /
/// Comentarios de la serpiente
/// Esqueleto de la serpiente
///
clase pública SnakeNode
{
Control privado dcControl; // Control para dibujar
private int iCenterX; // Coordenada central X
private int iCenterY; Y
private int iRadius; // Radio
color privado colorNode; // Color
control público DcControl
{
establecer { dcControl = valor;}
obtener { return dcControl }
}
public int CenterX
{
p> set { iCenterX = valor }
get { return iCenterX }
}
public int CenterY
{
set { iCenterY = valor }
get { return iCenterY;}
}
public int Radio
{
establecer { iRa
dius = valor }
obtener { return iRadius }
}
color público ColorNode
{
establecer { colorNode = valor }
obtener { return colorNode }
}
private bool bDisposing = true
public; SnakeNode(): this(null, 0, 0, 5)
{
}
public SnakeNode(Control control, int iX, int iY, int iR)
{
DcControl = controlar;
CenterX = iX; SuppressFinalize(this); p> public void Dispose( bool bDisposing)
{
if (bDisposing)
{
// Llama a Dispose para eliminar el campos de objeto en recursos controlados
CenterX = CenterY = 0;
Radius = 5
}
// Borrar recursos no controlados
}
// Dibujándose a sí mismo
public void Draw()
{
Draw(Color.Blue) ;
}
public void Draw(Color color)
{
// Dibuja un círculo en el color especificado
ColorNode = color;
DrawCircle(ColorNode);
}
// Borrar
public void Clear()
{
// Dibuja un círculo usando el color de fondo del control
DrawCircle(DcControl.BackColor);
}
// // Dibuja un círculo en el centro del hueso
public void DrawCircle(Color color)
{
usando (Graphics dc = DcControl.CreateGraphics( ))
{
// Crea un pincel sólido
SolidBrush sbBrush = new SolidBrush(color);
// Crea un rango de intervalo redondo
float x = CenterX - Radius;
float y = CenterY - Radius
float width = 2 * Radius;
float height = 2 * Radius
// Crea ángulos iniciales y de escaneo
float fSta;
rtAngle = 0.0F;
float fSweepAngle = 360.0F;
// Dibuja un círculo
dc.FillPie(sbBrush, x, y, ancho, alto , fStartAngle, fSweepAngle);
}
}
}
#endregion
#region SnakeFood SnakeFood
///
/// Descripción resumida SnakeFood.
///
clase pública SnakeFood
{
control privado dcControl;
privado int iMaxCount; //La cantidad máxima de comida que se puede dejar
private int iCurrentCount; //La cantidad total actual de comida que queda
private int iRadius //El radio del hueso
p>Color privado[] acolor = new Color[]{Color.Red, Color.Green, Color.Yellow} // El rango de valores del color.
Yellow}; // El rango de valores del nuevo color de punto
private static ArrayList alSnakeFood; // Comida de serpiente
private bool bDisposing = true;
public Controlar DcControl<
{
establecer { dcControl = valor }
obtener { return dcControl }
}
public int MaxCount
{
set { iMaxCount = valor; // SnakeFood.}
get { return iMaxCount }
}
public int CurrentCount
{
set { iCurrentCount = valor }
get { return iCurrentCount }
}
public int Radio
{
set { iRadius = valor }
get { return iRadius; }
}
public SnakeNode this[int index]
{
get
{
if (indexlt; 0 || indexgt; =CurrentCount)
{
throw new IndexOutOfRangeException();
}
return (SnakeNode)alSnakeFood[index];
}
}
}
public SnakeFood(): this(null , 5, 5)
{
}
public SnakeFood(Control control, int iMaxCount, int iRadius)
{ p>
DcControl = control;
MaxCount = iMaxCount;
CurrentCount = 0;
Radio = iRadius; > alSnakeFood = new ArrayList();
}
~SnakeFood()
{
Dispose(false);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this) ;
}
public void Dispose( bool bDisposing )
{
if (bDisposing)
{
// Llamar a Di
suponemos para eliminar campos en recursos controlados
CurrentCount = 0;
alSnakeFood.Clear();
}
// Borrar no controlado recursos
}
// Agregar comida
public void AddFood()
{
Aleatorio aleatorio = new Random();
int iStep = Radio Radio;
int iX = Radio iStep * random.Next(0, DcControl.Width/iStep); > int iY = Radio iStep * aleatorio.
Color color = acolor[randomIndex.Next(0, acolor.Length)];
color = Color.Green ;
sn.Draw(color);
alSnakeFood.Draw(color);