Código fuente del nodo del minijuego
Pegue el código, busque el botón ejecutar y presiónelo para ejecutar. Si no se puede encontrar, la tecla de acceso directo es Ctrl F11.
Importar Java .awt .
Importar Java . Java awt . evento de acción;
Importar evento de clave Java .
Importar Java. awt. evento.
Importar Java util.
Importar javax. .jframe;
Importar javax.swing.jlabel;
Importar javax.swing.jmenu;
Importar javax.swing.jmenubar;
Importar javax.swing.jmenuitem;
Importar javax.swing.jpanel;
Juego público tipo serpiente{
Principal vacío estático público (String[ ] args) {
marco de serpiente = nuevo marco de serpiente();
marco . setdefaultcloseoperation(JFrame. EXIT _ ON _ CLOSE); set visible(true);
}
}
// - Hilo que registra el estado.
La clase StatusRunnable implementa Runnable {
Ejecución de estado público (serpiente serpiente, etiqueta de estado JLabel, etiqueta de puntuación JLabel) {
esta etiqueta de estado = etiqueta de estado;
p>
p>
this . etiqueta de puntuación = etiqueta de puntuación;
this.snake = serpiente
}
Ejecución de vacío público() {
String sta =
String spe =
mientras (verdadero) {
Cambiar (snake.status) {
Caso serpiente. corriendo:
sta = "corriendo";
romper;
caso serpiente. Pausa:
sta = "pausa";
Romper
Caso Serpiente.
Juego terminado:
sta = " GameOver
Pausa;
}
etiqueta de estado . settext(sta);
etiqueta de puntuación . settext(" serpiente . puntuación);
Prueba {
thread . sleep(100);
} catch(Exception e) {
}
}
}
ScoreLabel privado de JLabel
Etiqueta de estado de JLabel privado;
Private Snake;
}
// - El movimiento de la serpiente y la línea que registra la puntuación.
La clase SnakeRunnable implementa Runnable {
public SnakeRunnable(Snake serpiente, componente Componente) {
this.snake = serpiente
this . componente = componente;
}
Ejecución de vacío público(){
mientras (verdadero) {
intento{
snake.move();
component.repaint();
Thread.sleep(snake.speed);
} catch(Excepción e ) {
}
}
}
Componente privado;
Componente privado;
p>
}
Snake{
Boolean isRun// - ¿Se está ejecutando?
ArrayList ltNode gt body; //-cuerpo de serpiente
Alimento del nodo; //-comida
Dirección de interacción //-dirección
puntuación int;
estado int;
velocidad int;
int final estático público LENTO = 500
int final estático público MID = 300
Publica static final int FAST = 100;
public static final int RUNNING = 1;
public static final int PAUSED = 2;
p>
juego int final estático público terminado = 3;
int final estático público IZQUIERDA = 1;
int final estático público ARRIBA = 2;
public static final int DERECHA = 3;
public static final int ABAJO = 4;
Public Snake(){
Velocidad = serpiente. lento;
puntuación = 0;
isRun = false
estado = serpiente. Pausa;
Dirección=serpiente.
Derecha;
body = new ArrayList ltNode gt();
body.add(nuevo nodo (60, 20));
body.add(new Nodo(40, 20));
body.add(new Node(20, 20));
hacer comida(); p>
// - Determina si la serpiente comió la comida.
// - Si la comida está justo en frente de la dirección de carrera de la serpiente y entra en contacto con la cabeza de la serpiente, se la comerá.
Booleano privado isEaten() {
nodo head = body . get(0);
if(direction == Snake.right amp amp(head . x Node. W) == comida.x
amp amphead.y == comida.y)
Devuelve verdadero
if(dirección == Serpiente . amplificador izquierdo amp(head.x - Node.W) == food.x
amp amphead.y == food.y)
devuelve verdadero
if(dirección == Snake.UP amp amphead.x == comida.x
amp amp(head.y node.H) == comida.y)
Devuelve verdadero
if(dirección == Serpiente. Abajo amp amphead.x == comida.x
amp amp(head.y Node.H) == comida.y)
Devuelve verdadero
Otros
Devuelve falso
}
// - Si hay una colisión.
Privado booleano isCollsion() {
nodo nodo = body . get(0);
// - Golpea la pared.
if(dirección == Snake.Right amp ampnode.x == 280)
Devuelve verdadero
if(dirección == Snake.UP ampnode. y == 0)
Devuelve verdadero
if(dirección == Snake. left amp ampnode.x == 0)
Devuelve verdadero
if(direction == Snake. Down amp ampnode.y == 380)
Devuelve verdadero
// - La cabeza de una serpiente se encuentra con una serpiente.
Temperatura del nodo = null
int I = 0
for(I = 3; i ltbody . size(); i ) {
temp = cuerpo . get(I);
if(temp . x == nodo . x amp; amptemp.y == nodo.y)
romper;
}
Si (I ltbody.size())
Devuelve verdadero
Otro
Devuelve falso
}
//- Produce alimentos en lugares aleatorios.
public void makeFood() {
Nodo nodo = nuevo nodo (0, 0
booleano isInBody = true
int); x = 0, y = 0;
int X = 0, Y = 0;
int I = 0;
mientras (isInBody) {
x =(int)(matemáticas. aleatorio()* 15);
y =(int)(matemáticas. aleatorio()* 20); = x*nodo. w;
Y = y*nodo. h;
for(I = 0; i ltbody . size(); i ) {
if (X == cuerpo.get(i).x amp ampY == cuerpo .get(i).y)
romper;
}
if (iltbody.size())
isInBody = true
Otro
isInBody = false
}
Alimento = nuevo nodo (X, Y);
}
//-Cambiar la dirección de carrera
public void cambiar dirección(int newDer){
if(dirección 2!= newDer 2)// - Si la dirección es la misma o opuesta a la dirección original, no se puede cambiar.
derection = newDer
}
Movimiento de vacío público(){
If(iseaten()){//-Si come tenía comida.
body.add(0, food); // - Trata la comida como una cabeza de serpiente y conviértete en un nuevo cuerpo de serpiente.
Puntuación = 10;
hacer comida(); // - Producir comida
} else if (iscollision ()) // - Si golpea la pared o usted mismo.
{
isRun = false
status = serpiente. GAMEOVER//-Finalizar
} else if(se ejecuta){//-Operación normal (sin comida, sin paredes, sin tocar)
nodo nodo = cuerpo get(0). );
int X = node.x
int Y = node.y
// - La cabeza de serpiente avanza una unidad según la dirección de carrera. .
Cambio(dirección){
Caso 1:
X -= nodo. w;
Rotura;
Caso 2:
Y -= nodo. h;
Rotura;
Caso 3:
X = nodo. w;
Rotura;
Caso 4:
Y = nodo. h;
Romper;
}
body.add(0, nuevo nodo (X, Y)); - .
cuerpo . remove(cuerpo . tamaño()-1);
}
}
}
// -Las unidades que componen el cuerpo de la serpiente, el alimento.
Nodo de clase{
Público estático final int W = 20
Público estático final int H = 20
int x;
p>
int y;
Nodo público (int x, int y) {
this.x = x
this .y = y
}
}
//-Artboard
La clase SnakePanel extiende JPanel {
Snake;
p>Tablero de serpiente pública (Snake Snake){
this.snake = serpiente
}
componente de pintura pública vacía (Gráficos g){
super . paint componente(g);
Nodo nodo = null
for(int I = 0; i ltsnake . body . size(); I i ) {// - Dibuja el cuerpo de la serpiente en intervalos rojos y azules.
If (i 2 == 0)
g set color(color . blue);
Otros
g . color(color . amarillo);
nodo = cuerpo de serpiente . get(I
g.fillRect(nodo.x, nodo.y, nodo.h nodo.w); );//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
}
nodo = serpiente.comida
g . establecer color(color . rojo
g.fillRect(nodo.x, nodo.y, nodo.h);
w);
}
}
La clase SnakeFrame extiende JFrame {
Etiqueta de estado privada de JLabel;
JLabel privado speedLabel
JLabel privado ScoreLabel
JPanel privado SnakePanel
Snake privado;
JMenuBar privado;
Menú del juego JMenu;
JMenu helpMenu
JMenu speedMenu
JMenuItem newItem
JMenuItem pausaItem
JMenuItem beginItem
JMenuItem helpItem
JMenuItem sobre el artículo;
JMenuItem slowItem
JMenuItem midItem
JMenuItem fastItem
p>Serpiente pública(){
init();
escucha de acción l = nueva acción oyente(){
acción de anulación pública realizada( evento de acción e){
if (e.getSource() == pausaItem)
snake.isRun = false
if (e.getSource() = = comenzarItem)
snake.isRun = true
if (e.getSource() == newItem) {
nuevo juego();
p>}
// -El menú controla la velocidad de carrera.
if (e.getSource() == slowItem) {
Serpiente. velocidad = serpiente. Lento;
etiqueta de velocidad . settext(" Lento ");
}
if (e.getSource() == midItem) {
Serpiente. velocidad = serpiente. MEDIO
etiqueta de velocidad . settext(" Medio ");
}
if (e.getSource() == fastItem) {
Serpiente. Velocidad = serpiente.
Rápido;
etiqueta de velocidad . settext(" Rápido ");
}
}
};
pausar elemento . addactionlistener(l);
comenzar elemento . addactionlistener(l);
nuevo elemento . (l);
elemento lento . addactionlistener(l);
miditem .
addkey oyente(nuevo oyente de clave(){
Clave de anulación pública (evento clave e) {
cambiar (e.getKeyCode()) {
// - Las teclas de flecha cambian la dirección del movimiento de la serpiente
Case VK_Tang: //
snake.changeDerection(Snake. Down);
Break. ;
Evento clave de caso VK_UP://
snake.changeDerection(Snake.UP);
Pausa;
evento clave de caso vk_left: //
snake.changeDerection(Snake.left);
Break;
evento clave de caso: //
snake.changeDerection(Snake.right);
Pausa;
//Barra espaciadora, pausa o continúa el juego
Eventos clave del caso: //
if (snake.isRun == true) {
snake.isRun = false
estado de serpiente = Pausa;
Romper;
}
if (snake.isRun == false) {
snake.isRun = true
snake.status = Serpiente.
Ejecutar;
Interrupción;
}
}
}
clave pública nula liberada (evento clave k ){
}
clave nula públicaTyped(KeyEvent k) {
}
});
}
Private void init() {
speed label = new JLabel();
Snake = new Snake();
setSize(380, 460);
establecer diseño(null);
this . setresizable(false);
bar = new JMenuBar();
p>
gameMenu = new JMenu("Juego");
newItem = new JMenuItem("Nuevo juego");
menú del juego add(. nuevo elemento);
Pausar elemento = nuevo JMenuItem(" Pausa ");
menú del juego agregar(pausar elemento
comenzar elemento = nuevo JMenuItem); (" Continuar ");
menú del juego . agregar(comenzar elemento);
Menú de ayuda = new JMenu(" Ayuda ");
Acerca del elemento = new JMenuItem("Acerca de");
menú de ayuda agregar(acerca del elemento);
Menú de velocidad = new JMenu("Velocidad");
slowItem = nuevo JMenuItem(" Lento ");
Elemento rápido = nuevo JMenuItem(" Rápido ");
midItem = nuevo JMenuItem(" Medio ");
menú de velocidad .añadir (elemento lento);
menú de velocidad .
menú de velocidad . >bar .add(menú del juego);
bar .add(menú de ayuda);
bar .
etiqueta de estado = nuevo JLabel();
etiqueta de puntuación = nuevo JLabel();
snakePanel = nuevo JPanel();
snakePanel.setBounds(0, 0, 300, 400);
panel de serpiente. establecer borde (fábrica de bordes. crear borde de línea (color. gris oscuro)); (panel de serpiente);
statusLabel.setBounds(3)
00, 25, 60, 20);
add(etiqueta de estado);
scoreLabel.setBounds(300, 20, 60, 20); (etiqueta de partitura);
JLabel temp = new JLabel(" estado ");
temp.setBounds(310, 5, 60, 20);
agregar(temp);
temp = new JLabel(" puntuación ");
temp.setBounds(310,105,60,20);
añadir (temp );
temp = new JLabel(" velocidad ");
temp.setBounds(310, 55, 60, 20);
añadir( temp) ;
speedLabel.setBounds(310, 75, 60, 20);
Agregar (etiqueta de velocidad);
}
Privado void newGame() {
this .eliminar(snakePanel);
this eliminar(etiqueta de estado);
this eliminar(etiqueta de puntuación);
etiqueta de velocidad . settext(" Lento ");
etiqueta de estado = new JLabel();
etiqueta de puntuación = new JLabel();
p>
snakePanel = nuevo JPanel();
Snake = nuevo Snake();
snakePanel = nuevo SnakePanel(serpiente);
snakePanel. setBounds(0, 0, 300, 400);
panel de serpiente. establecer borde(fábrica de bordes. crear borde de línea (color. gris oscuro));
r ejecutable. 1 = nueva serpiente ejecutable (serpiente, panel de serpiente);
ejecutable R2 = nuevo estado ejecutable (serpiente, etiqueta de estado, etiqueta de puntuación);
Hilo t1 = nuevo hilo (r 1) ;
p>
Hilo t2 = nuevo hilo (R2);
t 1 . /p>
Agregar (serpientePanel);
etiqueta de estado.establecer límites(310,25,60,20);
agregar(etiqueta de estado);
scoreLabel.setBounds(310 , 125, 60, 20
add(etiqueta de puntuación);
}
}