Usa JAVA para compilar un pequeño juego u otro programa

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

caso ABAJO:

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) {

prueba {

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 ;

}

}