Código de programación de juegos pequeños Rusia
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 .escucha de claves
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, JLabel statusLabel, JLabel scoreLabel) {
esta etiqueta de estado = etiqueta de estado;
esta. 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 de serpiente.
Juego terminado:
sta = " GameOver
Pausa;
}
etiqueta de estado . settext(sta);
score label . settext("+snake . score);
Pruebe {
thread . sleep(100);
} catch(Exception e ) {
}
}
}
ScoreLabel privado de JLabel
Etiqueta de estado de JLabel privado; p>
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 & gtbody; //-cuerpo de serpiente
Comida del nodo
Dirección de interacción //-dirección
puntuación int;
estado int;
velocidad int;
Final estática pública int SLOW = 500
Final estática pública int MID = 300
Public 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; p>public static final int RIGHT = 3;
public static final int DOWN = 4;
Serpiente pública(){
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 (nuevo Nodo(40, 20));
body.add(nuevo Nodo(20, 20));
hacer comida();
// - Determinar 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() {
cabeza de nodo = cuerpo . get(0);
if(dirección == Snake.right& amp& amp( head. x + Nodo W) == comida.x
& amp& amphead.y == comida.y)
Devuelve verdadero
if(dirección == Snake.left& amp& amp(head.x - Node.W) == comida.x
& amp& amphead.y == comida.y)
devuelve verdadero
if(dirección == Serpiente.UP & amp& amphead.x == comida.x
& amp& amp(head.y nodo.H) == comida.y)
Devuelve verdadero
if(direction == Snake.down&& amphead.x == comida.x
& amp& amp(head.y + Node.H) == comida. y)
Devuelve verdadero
Otro
Devuelve falso
}
// -Si colisiona.
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 & amp& ampnode .y == 0)
Devuelve verdadero
if(direction == Snake.left&& ampnode.x == 0)
Devuelve verdadero
if(direction == Snake.down&& 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<body . size(); i++) {
temp = cuerpo . get(I);
if(temp . x == nodo . x & & amptemp.y == nodo.y)
break;
}
if(i<body.size())
devuelve verdadero
otro
Devuelve falso
}
//-Produce comida 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 == body.get(i).x & amp& ampY = = body.get(i).y)
break;
}
if(i<body.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(direction% 2!= newDer% 2 ) // - La dirección no se puede cambiar si es igual o opuesta a la dirección original.
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 el pared o Propia.
{
isRun = false
status = serpiente. GAMEOVER//-Fin
} else if(se ejecuta){//-Operación normal (sin comida, sin pared, sin contacto)
node node = body 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;
Romper;
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<snake . body . size (); I +i++) {// - Dibuja el cuerpo de la serpiente con intervalos rojos y azules.
Si (i % 2 == 0)
g establece color(color . azul);
Otro
g. establecer color(color . amarillo);
nodo = cuerpo de serpiente . w);//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
}
nodo = serpiente.comida
g . set color(color . rojo);
g.fillRect(nodo.x, nodo.y, nodo.h nodo.
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 direccionales cambian la dirección del movimiento de la serpiente.
Hechos clave del caso. VK_Don://
snake.changeDerection(Snake.down);
Pausa;
Evento clave del caso. VK_UP://
snake.changeDerection(Snake.UP);
Pausa;
Evento clave del caso. VK_left://
snake.changeDerection(Snake.left);
Pausa;
Evento clave del caso. VK _right://
snake.changeDerection(Snake.right);
Pausa;
//Barra espaciadora, pausa o continúa el juego.
Hechos clave del caso. Espacio VK://
if (snake.isRun == true) {
snake.isRun = false
snake.status = Snake. Pausa;
Pausa;
}
if (snake.isRun == false) {
snake.isRun = true p>
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)); (snakePanel);
statusLabel.setBounds(300, 25, 60, 20);
añadir(etiqueta de estado);
scoreLabel.setBounds(300, 20, 60, 20);
p>
add(laboratorio de puntuación
el);
JLabel temp = new JLabel(" estado ");
temp.setBounds(310, 5, 60, 20);
add( temp);
temp = new JLabel(" puntuación ");
temp.setBounds(310,105,60,20);
add(temp);
temp = new JLabel(" velocidad ");
temp.setBounds(310, 55, 60, 20);
add(temp);
speedLabel.setBounds(310, 75, 60, 20);
Agregar (etiqueta de velocidad);
}
Nuevo juego nulo privado () {
this . remove(snakePanel);
this . remove(etiqueta de estado);
this . >
etiqueta de velocidad . settext(" Lento ");
etiqueta de estado = new JLabel();
etiqueta de puntuación = new JLabel();
snakePanel = nuevo JPanel();
Snake = nuevo Snake();
snakePanel = nuevo SnakePanel(serpiente);
snakePanel.setBounds( 0, 0, 300, 400);
panel de serpiente. set border(border factory. create line border(color. dark grey));
runnable r 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);
Hilo t2 = nuevo hilo (R2);
t 1 .
T2
Agregar (snakePanel);
etiqueta de estado.establecer límites(310,25,60,20);
añadir(etiqueta de estado);
scoreLabel.setBounds(310,125, 60, 20 );
añadir(etiqueta de puntuación);
}
}