Programa GreedSnake:
GreedSnake.java (también la entrada del programa):
importar java.awt.BorderLayout;
importar java .awt.Canvas;
importar java.awt.Color;
importar java.awt.Container;
importar java.awt.Graphics;
p>
importar java.awt.event.KeyEvent;
importar java.awt.event.KeyListener;
importar java.util.Iterator;
importar java.util.LinkedList;
importar javax.swing.JFrame;
importar javax.swing.JLabel;
importar javax. swing.JPanel;
clase pública GreedSnake implementa KeyListener {
JFrame mainFrame
Canvas paintCanvas
JLabel labelScore;
p>
SnakeModel SnakeModel = null; // serpiente
public static final int canvasWidth = 200
public static final int canvasHeight = 300;
public static final int nodeWidth = 10;
public static final int nodeHeight = 10
// -----------; ------- ------------------------------------------- ------- --
// GreedSnake(): Inicializa la interfaz del juego
// --------------- -------- ------------------------------------------ -----
public GreedSnake() {
// Establecer elementos de la interfaz
mainFrame = new JFrame("GreedSnake");
Contenedor cp = mainFrame. getContentPane();
labelScore = new JLabel("Score:");
cp.add(labelScore, BorderLayout.NORTH);
paintCanvas = new Canvas();
paintCanvas.setSize(canvasWidth 1, canvasHeight 1);
paintCanvas.add
KeyListener(this);
cp.add(paintCanvas, BorderLayout.CENTER);
JPanel panelButtom = new JPanel();
panelButtom.setLayout(new BorderLayout());
JLabel labelHelp; // Información de ayuda
labelHelp = new JLabel("PageUp, PageDown para mayor velocidad;", JLabel.CENTER);
panelButtom.add(labelHelp, BorderLayout.NORTH);
labelHelp = new JLabel("ENTER o R o S para inicio;", JLabel.CENTER);
panelButtom. add(labelHelp, BorderLayout.CENTER);
labelHelp = new JLabel("ESPACIO o P para pausa", JLabel.CENTER);
panelButtom.add(labelHelp, BorderLayout.SOUTH
cp.add(panelButtom, BorderLayout.SOUTH);
mainFrame.addKeyListener(this
mainFrame.pack(); >
mainFrame.setResizable(false);
mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mainFrame.setVisible(true);
comenzar( );
}
// ------------------------------- --- ---------------------------------------
/ / keyPressed( ): Detección de clave
// ---------------------------------- --- ----------------------------------
tecla vacía pública presionada(KeyEvent e ) {
int keyCode = e.getKeyCode();
if (snakeModel.running)
switch (keyCode) {
case KeyEvent.VK_UP ：
SnakeModel.changeDirection(SnakeModel.UP);
break
case KeyEvent.VK_DOWN:
SnakeModel; .changeDirection(SnakeModel .DOWN);
romper;
caso KeyEvent.VK_LEFT:
SnakeModel.changeDirection(SnakeModel.LEFT);
romper
caso KeyEvent.VK_RIGHT; ：
SnakeModel.changeDirection(SnakeModel.RIGHT);
break;
caso KeyEvent.VK_ADD:
caso KeyEvent.VK_PAGE_UP:
SnakeModel.speedUp(); // acelerar
break;
case KeyEvent.VK_SUBTRACT:
case KeyEvent.VK_PAGE_DOWN:
SnakeModel.speedDown(); // Reducir la velocidad
pausa;
case KeyEvent.VK_SPACE:
case KeyEvent.VK_P:
p>
SnakeModel.changePauseState(); // Pausar o continuar
break
predeterminado:
}
// Empezar de nuevo
if (keyCode == KeyEvent.VK_R || keyCode == KeyEvent.VK_S
|| keyCode == KeyEvent.VK_ENTER) {
SnakeModel.running = false;
comenzar();
}
}
// - ------- ------------------------------------------- ------- ------------
// keyReleased(): función vacía
// ------- ------- ------------------------------------------- ------- ------
public void keyReleased(KeyEvent e) {
}
// ----- -------- ------------------------------------------ -------- --------
// keyTyped(): función vacía
// ---------- -------- ------------------------------------------ -------- --
public void keyTyped(KeyEvent e) {
}
//-------- -------- ------------------------------------------ -------- ----
// re
paint(): dibuja la interfaz del juego (incluidas serpientes y comida)
// --------------------------- - ------------------------------------
void repaint() {
Gráficos g = paintCanvas.getGraphics();
// dibujar fondo
g.setColor(Color.WHITE);
g.fillRect(0, 0, canvasWidth, canvasHeight);
// dibuja la serpiente
g.setColor(Color.BLACK);
LinkedList na = SnakeModel.nodeArray;
Iterador it = na.iterator();
while (it.hasNext()) {
Nodo n = (Nodo) it.next();
drawNode(g, n);
}
// dibuja la comida
g.setColor(Color.RED);
Nodo n = serpienteModel.food
drawNode(g, n
updateScore();
}
// --------------------------------- - ------------------------------------
// dibujarNodo(): dibujando Un determinado nodo (cuerpo de serpiente o comida)
// ------------------------------- --- ---------------------------------------
privado void drawNode( Gráficos g, Nodo n) {
g.fillRect(n.x * nodeWidth, n.y * nodeHeight, nodeWidth - 1,
nodeHeight - 1); p> }
// -------------------------------------- ---- --------------------------
// updateScore(): Cambia el marcador
//------------------------------------------------------ --- -----------------------
public void updateScore() {
String s = " Puntuación: " SnakeModel.score;
labelScore.setText(s);
}
// ------------ ---------------------------
----------------------------
// comenzar(): El juego comienza, coloca la serpiente codiciosa
// ------------------------------------------ ----- --------------------------
void comenzar() {
if (snakeModel = = null || !snakeModel.running) {
SnakeModel = new SnakeModel(this, canvasWidth / nodeWidth,
this.canvasHeight / nodeHeight
);( nuevo hilo (modelo de serpiente)).start();
}
}
// ---------- ---- ---------------------------------------------- ---- ------
// main(): función principal
// ---------------- ---- ---------------------------------------------- ----
public static void main(String[] args) {
GreedSnake gs = new GreedSnake()
}
<; p>}Nodo.java:
Nodo de clase pública {
int x
int y
<; p> Nodo( int x, int y) {this.x = x
this.y = y
}
}
SnakeModel.java:
importar java.util.Arrays;
importar java.util.LinkedList;
importar java.util.Random;
importar javax.swing.JOptionPane;
la clase pública SnakeModel implementa Runnable {
GreedSnake gs;
boolean[][ ] matriz; // Los datos de la interfaz se almacenan en una matriz
LinkedList nodeArray = new LinkedList();
Comida del nodo;
int maxX; // Ancho máximo
int maxY; // largo máximo
int dirección = 2; // dirección
booleano corriendo = false
int timeInterval = 200; // Tiempo de intervalo (velocidad)
double speedChangeRate = 0.75 // Grado de cambio de velocidad
booleano pausado = 200;
false; // Estado del juego
int score = 0;
int countMove = 0
// ARRIBA y ABAJO son números pares, DERECHA e IZQUIERDA son números pares; números impares
int final estático público ARRIBA = 2;
int final estático público ABAJO = 4
int final estático público IZQUIERDA = 1; >
public static final int DERECHA = 3;
// ----------------------- ----- ---------------------------------------
// GreedModel( ): Interfaz de inicialización
// -------------------------------- ----- ----------------------------------
public SnakeModel(GreedSnake gs, int maxX, int maxY) {
this.gs = gs;
this.maxX = maxX
this.maxY = maxY
matriz = nuevo booleano[maxX][];
for (int i = 0; i lt; maxX; i) {
matriz[i] = nuevo boolean[maxY];
Arrays.fill(matrix[i], false // Establece falso en áreas sin serpientes ni comida
}
/ / Inicializar serpiente codiciosa
int initArrayLength = maxX gt; 20 10 : maxX / 2 ? >
int x = maxX / 2 i;
int y = maxY / 2;
nodeArray.addLast(new Node(x, y));
matriz[ x][y] = true; // Eliminación del cuerpo de la serpiente true
}
comida = createFood();
matriz[comida] .x][food .y] = true; // eliminación de alimentos true
}
// ----------------- ------ ----------------------------------------
// changeDirection(): cambia la dirección del movimiento
// --------------------------- ------------------------------------------
público void cambioDirección(int nuevaDirección) {<
/p>
if (dirección 2 != nuevaDirección 2)// evitar conflictos
{
dirección = nuevaDirección;
}
}
//------------------------------------- -------- ----------------------------------
/ / moveOn(): Función de movimiento de serpiente
// --------------------------------- ------- ----------------------------------
público booleano moveOn() {
Nodo n = (Nodo) nodeArray.getFirst();
int x = n.x
int y = n.y; >
cambiar (dirección) {
p>
caso ARRIBA:
y--;
romper
y;
romper;
caso IZQUIERDA:
x--; romper;
caso DERECHA:
x;
romper
}
si ((0 lt ; = x amp; y lt; maxX) amp; (0 lt;= y lt; maxY)) {
if (matriz[x][y])// Comer comida o golpear el cuerpo
{
if (x == comida.x amp; y == comida.y)// Comer comida
{
nodeArray.addFirst (comida); // Agrega un nodo a la cabeza
// Las reglas de puntuación están relacionadas con la longitud y la velocidad del movimiento
int puntuaciónGet = (10000 - 200 * countMove) / timeInterval;
puntuación = puntuaciónGet 0 ? puntuaciónGet : 10; createFood();
matriz[food.x][food.y] = true;
devuelve verdadero
} else
return false; // Golpea el cuerpo
} else// No se encontró nada
{
nodeArray.addFirst(new Node(x, y)); // Agregar encabezado
matriz[x][y] = true;
n = (Nodo) nodeArray.removeLast();/
/ Quitar la cola
matriz[n.x][n.y] = false
countMove
return true
}
}
return false; // Fuera de límites (golpear la pared)
}
// ------- --- ----------------------------------------------- --- ----------
// run(): Hilo de movimiento de serpiente
// ------------ ------------------------------------------------- - -------
public void run() {
corriendo = true
mientras (corriendo) {
Thread.sleep(timeInterval);
} catch (Exception e) {
break
}
if (!paused) {
if (moveOn())// no finalizado
{
gs.repaint();
p>} else// Juego terminado
{
JOptionPane.showMessageDialog(null, "JUEGO TERMINADO",
"Juego terminado ", JOptionPane .INFORMATION_MESSAGE);
break;
}
}
}
corriendo = false ;
p>
}
// --------------------------- ------- ----------------------------------
// createFood(): Genera comida y ubicación de ubicación
// -------------------------------- --------------- --------------------------------
Nodo privado createFood() {
int x = 0
int y = 0
hacer {
; Aleatorio r = nuevo Aleatorio();
x = r.nextInt(maxX
y = r.nextInt(maxY
} mientras ( matriz[x][y]);
devolver nuevo Nodo(x, y);
}
// -------- --------------- ----------------------------------- ------------
// s
speedUp(): acelera el movimiento de la serpiente
// ------------------------------ --- -------------------------------------
velocidad de anulación pública () {
timeInterval *= speedChangeRate;
}
// ------------------ -------- ------------------------------------------ --------
// speedDown(): Reduce la velocidad de movimiento de la serpiente
// -------------- ------------ -------------------------------------- ------------
public void speedDown() {
timeInterval /= speedChangeRate;
}
// ------------- --------------------------------- ----------------- --------
// changePauseState(): cambia el estado del juego (pausar o continuar)
// ------------ -------------------------------- ------------------ --------
public void changePauseState() {
pausado = !pausado ;
}
}