Curso De Programacion Java Developer Free Courses Online
loading...
miércoles, 18 de noviembre de 2015 0 comentarios

Dibujar un carro con Graphics Applet java


bueno muchachos como vemos en la imagen un carro bonito pareciera dibujado en paint pero lo vamos a dibujar con la libreria Graphics en java, y utilizando un Applet , primero que todo vamos a crear una clase y unica llamada Carro esta la vamos a extender como Applet:




import java.awt.* ;
import java.applet.Applet ;

public class Carro extends Applet
{
  // size of area needed for applet figure
 public final int FIGUREHEIGHT = 280;
 public final int FIGUREWIDTH  = 445;

  // color definitions (red, green, blue)
        Color ROJO = new Color ( 182, 100, 110 ) ;
        Color NEGROGRIS = new Color ( 150, 70, 80 ) ;
        Color AZUL = new Color ( 35, 206, 255 ) ;
        Color ORO = new Color ( 240, 220, 0 ) ;

  // Applets have a paint method
 public void paint (Graphics micarro)
   // all paint methods require a Graphics parameter)
 {
   // background for figure
                micarro.setColor ( Color.white ) ;
                micarro.fillRect ( 0, 0, FIGUREWIDTH, FIGUREHEIGHT ) ;

   // front tire
                micarro.setColor ( Color.black ) ;
     micarro.fillOval ( 20, 170, 100, 100 ) ;
                micarro.setColor ( Color.white ) ;
     micarro.fillOval ( 30, 180, 80, 80 ) ;
                micarro.setColor ( Color.black ) ;
     micarro.drawOval ( 40, 190, 60, 60 ) ;

   // back tire
                micarro.setColor ( Color.black ) ;
     micarro.fillOval ( 270, 170, 100, 100 ) ;
                micarro.setColor ( Color.white ) ;
     micarro.fillOval ( 280, 180, 80, 80 ) ;
                micarro.setColor ( Color.black ) ;
     micarro.drawOval ( 290, 190, 60, 60 ) ;

   // car hood
                micarro.setColor ( NEGROGRIS ) ;
     micarro.fillRect ( 10, 113, 122, 12 ) ;
                micarro.setColor ( ROJO ) ;
     micarro.fillRect ( 10, 123, 122, 82 ) ;

   // car hood ornament
                micarro.setColor ( ORO ) ;
     micarro.fillOval ( 10, 105, 10, 10 ) ;

   //  car window
                micarro.setColor ( AZUL ) ;
                micarro.fillRect ( 130, 15, 130, 100 ) ; 

   // car door
                micarro.setColor ( ROJO ) ;
     micarro.fillRect ( 130, 113, 130, 92 ) ;

   // car backseat
                micarro.setColor ( ROJO ) ;
     micarro.fillRect ( 258, 15, 122, 190 ) ;

   // car trunk
                micarro.setColor ( ROJO ) ;
     micarro.fillRect ( 378, 80, 57, 125 ) ;

   // car running board
                micarro.c ( NEGROGRIS ) ;
     micarro.fillRect ( 118, 205, 154, 10 ) ;

   // visor
                micarro.setColor ( Color.black ) ;
   micarro.drawLine ( 131, 15, 110, 30) ;
   micarro.drawLine ( 131, 16, 110, 31) ;
   micarro.drawLine ( 131, 17, 110, 32) ;

   // door handle
                micarro.setColor ( Color.black ) ;
   micarro.drawLine ( 145, 125, 170, 125) ;
   micarro.drawLine ( 145, 124, 170, 124) ;
   micarro.drawLine ( 145, 123, 170, 123) ;
 }
}

como vemos utilizaremos todos los componentes que tiene la libreria Graphics como son fillRect,drawLine,fillOval y para el color setColor
martes, 29 de septiembre de 2015 0 comentarios

hacer girar un objeto en second life

bueno como sabemos second life es una segunda vida y por tanto viene con una cantidad de programacion ,en esta ocacion les voy a enseñar un codigo para hacer girar un objeto en second life
primero que todos elegimos la carpeta donde vamos a crear un script en second life se llaman script nos aparecera algo asi:



default
{
    state_entry()
    {
        llSay(0, "Hello, Avatar!");
      
    }

    touch_start(integer total_number)
    {
        llSay(0, "Touched.");
    }
}


solo debemos agregar en la linea de state entry osea cuando el objeto es visto por un avatar la siguiente linea llTargetOmega(<0,0,1>,0.3,PI); esta se encarga de mover el objeto a cierta velocida en grados PI el codigo como tal quedaria asi:

default
{
    state_entry()
    {
        llSay(0, "Hello, Avatar by andres2288!");
llTargetOmega(<0,0,1>,0.3,PI);
     
    }

    touch_start(integer total_number)
    {
        llSay(0, "Touched.");
    }
}

por ultimo guardar ,lego es crear un objeto y arrastrar este script al objetoy listo le dara un movimiento lentamente,puedes ajustar la velocidad del objeto en el campo dentro del parentesis.

a proposito puedes visitar mi tienda en second life apenas estoy empezando en este mundo
https://marketplace.secondlife.com/es-ES/stores/174957
sábado, 15 de agosto de 2015 0 comentarios

Tetris en java2D games codigo netbeans





el juego de tetris es uno de los juegos mas populares y divertidos que hay en el mundo de gamers
El juego original  y relevante fue diseñado y programado por el programador ruso Alexey Pajitnov en 1985, hasta la actualidad este juego sencillo pero divertido ha sido implementado en varias plataformas,este jeugo tiene varias formas con las letras del abecedario , el objetivo es mover y rotar esta formas, para que lleguen a alinearse hasta formar una fila y asi resivimos puntos.
el juego lo modifique ya que se encontraba con problemas al cargar las imagenes la primer clase que nesesitamos es la clase formas con esta nos encargaremos de formar las piezas del tetris como acomodar cada una en su respectivo lugar:



import java.util.Random;
import java.lang.Math;


public class formas {

    enum Tetrominoes { NoShape, ZShape, SShape, LineShape, 
               TShape, SquareShape, LShape, MirroredLShape };

    private Tetrominoes pieceShape;
    private int coords[][];
    private int[][][] coordsTable;


    public formas() {

        coords = new int[4][2];
        setShape(Tetrominoes.NoShape);

    }

    public void setShape(Tetrominoes shape) {

         coordsTable = new int[][][] {
            { { 0, 0 },   { 0, 0 },   { 0, 0 },   { 0, 0 } },
            { { 0, -1 },  { 0, 0 },   { -1, 0 },  { -1, 1 } },
            { { 0, -1 },  { 0, 0 },   { 1, 0 },   { 1, 1 } },
            { { 0, -1 },  { 0, 0 },   { 0, 1 },   { 0, 2 } },
            { { -1, 0 },  { 0, 0 },   { 1, 0 },   { 0, 1 } },
            { { 0, 0 },   { 1, 0 },   { 0, 1 },   { 1, 1 } },
            { { -1, -1 }, { 0, -1 },  { 0, 0 },   { 0, 1 } },
            { { 1, -1 },  { 0, -1 },  { 0, 0 },   { 0, 1 } }
        };

        for (int i = 0; i < 4 ; i++) {
            for (int j = 0; j < 2; ++j) {
                coords[i][j] = coordsTable[shape.ordinal()][i][j];
            }
        }
        pieceShape = shape;

    }

    private void setX(int index, int x) { coords[index][0] = x; }
    private void setY(int index, int y) { coords[index][1] = y; }
    public int x(int index) { return coords[index][0]; }
    public int y(int index) { return coords[index][1]; }
    public Tetrominoes getShape()  { return pieceShape; }

    public void setRandomShape()
    {
        Random r = new Random();
        int x = Math.abs(r.nextInt()) % 7 + 1;
        Tetrominoes[] values = Tetrominoes.values(); 
        setShape(values[x]);
    }

    public int minX()
    {
      int m = coords[0][0];
      for (int i=0; i < 4; i++) {
          m = Math.min(m, coords[i][0]);
      }
      return m;
    }


    public int minY() 
    {
      int m = coords[0][1];
      for (int i=0; i < 4; i++) {
          m = Math.min(m, coords[i][1]);
      }
      return m;
    }

    public formas rotateLeft() 
    {
        if (pieceShape == Tetrominoes.SquareShape)
            return this;

        formas result = new formas();
        result.pieceShape = pieceShape;

        for (int i = 0; i < 4; ++i) {
            result.setX(i, y(i));
            result.setY(i, -x(i));
        }
        return result;
    }

    public formas rotateRight()
    {
        if (pieceShape == Tetrominoes.SquareShape)
            return this;

        formas result = new formas();
        result.pieceShape = pieceShape;

        for (int i = 0; i < 4; ++i) {
            result.setX(i, -y(i));
            result.setY(i, x(i));
        }
        return result;
    }
}

luego seguimos con la clase tablero es el panel que se va encargar de dibujar las imagenes y la accion del Timer:



import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.Timer;

import tetris.formas.Tetrominoes;


public class tablero extends JPanel implements ActionListener {


    final int BoardWidth = 10;
    final int BoardHeight = 22;

    Timer timer;
    boolean isFallingFinished = false;
    boolean isStarted = false;
    boolean isPaused = false;
    int numLinesRemoved = 0;
    int curX = 0;
    int curY = 0;
    JLabel statusbar;
    formas curPiece;
    Tetrominoes[] board;



    public tablero(Tetris parent) {

       setFocusable(true);
       curPiece = new formas();
       timer = new Timer(400, this);
       timer.start(); 

       statusbar =  parent.getStatusBar();
       board = new Tetrominoes[BoardWidth * BoardHeight];
       addKeyListener(new TAdapter());
       clearBoard();  
    }

    public void actionPerformed(ActionEvent e) {
        if (isFallingFinished) {
            isFallingFinished = false;
            newPiece();
        } else {
            oneLineDown();
        }
    }


    int squareWidth() { return (int) getSize().getWidth() / BoardWidth; }
    int squareHeight() { return (int) getSize().getHeight() / BoardHeight; }
    Tetrominoes shapeAt(int x, int y) { return board[(y * BoardWidth) + x]; }


    public void start()
    {
        if (isPaused)
            return;

        isStarted = true;
        isFallingFinished = false;
        numLinesRemoved = 0;
        clearBoard();

        newPiece();
        timer.start();
    }

    private void pause()
    {
        if (!isStarted)
            return;

        isPaused = !isPaused;
        if (isPaused) {
            timer.stop();
            statusbar.setText("paused");
        } else {
            timer.start();
            statusbar.setText(String.valueOf(numLinesRemoved));
        }
        repaint();
    }

    public void paint(Graphics g)
    { 
        super.paint(g);

        Dimension size = getSize();
        int boardTop = (int) size.getHeight() - BoardHeight * squareHeight();


        for (int i = 0; i < BoardHeight; ++i) {
            for (int j = 0; j < BoardWidth; ++j) {
                Tetrominoes shape = shapeAt(j, BoardHeight - i - 1);
                if (shape != Tetrominoes.NoShape)
                    drawSquare(g, 0 + j * squareWidth(),
                               boardTop + i * squareHeight(), shape);
            }
        }

        if (curPiece.getShape() != Tetrominoes.NoShape) {
            for (int i = 0; i < 4; ++i) {
                int x = curX + curPiece.x(i);
                int y = curY - curPiece.y(i);
                drawSquare(g, 0 + x * squareWidth(),
                           boardTop + (BoardHeight - y - 1) * squareHeight(),
                           curPiece.getShape());
            }
        }
    }

    private void dropDown()
    {
        int newY = curY;
        while (newY > 0) {
            if (!tryMove(curPiece, curX, newY - 1))
                break;
            --newY;
        }
        pieceDropped();
    }

    private void oneLineDown()
    {
        if (!tryMove(curPiece, curX, curY - 1))
            pieceDropped();
    }


    private void clearBoard()
    {
        for (int i = 0; i < BoardHeight * BoardWidth; ++i)
            board[i] = Tetrominoes.NoShape;
    }

    private void pieceDropped()
    {
        for (int i = 0; i < 4; ++i) {
            int x = curX + curPiece.x(i);
            int y = curY - curPiece.y(i);
            board[(y * BoardWidth) + x] = curPiece.getShape();
        }

        removeFullLines();

        if (!isFallingFinished)
            newPiece();
    }

    private void newPiece()
    {
        curPiece.setRandomShape();
        curX = BoardWidth / 2 + 1;
        curY = BoardHeight - 1 + curPiece.minY();

        if (!tryMove(curPiece, curX, curY)) {
            curPiece.setShape(Tetrominoes.NoShape);
            timer.stop();
            isStarted = false;
            statusbar.setText("game over");
        }
    }

    private boolean tryMove(formas newPiece, int newX, int newY)
    {
        for (int i = 0; i < 4; ++i) {
            int x = newX + newPiece.x(i);
            int y = newY - newPiece.y(i);
            if (x < 0 || x >= BoardWidth || y < 0 || y >= BoardHeight)
                return false;
            if (shapeAt(x, y) != Tetrominoes.NoShape)
                return false;
        }

        curPiece = newPiece;
        curX = newX;
        curY = newY;
        repaint();
        return true;
    }

    private void removeFullLines()
    {
        int numFullLines = 0;

        for (int i = BoardHeight - 1; i >= 0; --i) {
            boolean lineIsFull = true;

            for (int j = 0; j < BoardWidth; ++j) {
                if (shapeAt(j, i) == Tetrominoes.NoShape) {
                    lineIsFull = false;
                    break;
                }
            }

            if (lineIsFull) {
                ++numFullLines;
                for (int k = i; k < BoardHeight - 1; ++k) {
                    for (int j = 0; j < BoardWidth; ++j)
                         board[(k * BoardWidth) + j] = shapeAt(j, k + 1);
                }
            }
        }

        if (numFullLines > 0) {
            numLinesRemoved += numFullLines;
            statusbar.setText(String.valueOf(numLinesRemoved));
            isFallingFinished = true;
            curPiece.setShape(Tetrominoes.NoShape);
            repaint();
        }
     }

    private void drawSquare(Graphics g, int x, int y, Tetrominoes shape)
    {
        Color colors[] = { new Color(0, 0, 0), new Color(204, 102, 102), 
            new Color(102, 204, 102), new Color(102, 102, 204), 
            new Color(204, 204, 102), new Color(204, 102, 204), 
            new Color(102, 204, 204), new Color(218, 170, 0)
        };


        Color color = colors[shape.ordinal()];

        g.setColor(color);
        g.fillRect(x + 1, y + 1, squareWidth() - 2, squareHeight() - 2);

        g.setColor(color.brighter());
        g.drawLine(x, y + squareHeight() - 1, x, y);
        g.drawLine(x, y, x + squareWidth() - 1, y);

        g.setColor(color.darker());
        g.drawLine(x + 1, y + squareHeight() - 1,
                         x + squareWidth() - 1, y + squareHeight() - 1);
        g.drawLine(x + squareWidth() - 1, y + squareHeight() - 1,
                         x + squareWidth() - 1, y + 1);
    }

    class TAdapter extends KeyAdapter {
         public void keyPressed(KeyEvent e) {

             if (!isStarted || curPiece.getShape() == Tetrominoes.NoShape) {  
                 return;
             }

             int keycode = e.getKeyCode();

             if (keycode == 'p' || keycode == 'P') {
                 pause();
                 return;
             }

             if (isPaused)
                 return;

             switch (keycode) {
             case KeyEvent.VK_LEFT:
                 tryMove(curPiece, curX - 1, curY);
                 break;
             case KeyEvent.VK_RIGHT:
                 tryMove(curPiece, curX + 1, curY);
                 break;
             case KeyEvent.VK_DOWN:
                 tryMove(curPiece.rotateRight(), curX, curY);
                 break;
             case KeyEvent.VK_UP:
                 tryMove(curPiece.rotateLeft(), curX, curY);
                 break;
             case KeyEvent.VK_SPACE:
                 dropDown();
                 break;
             case 'd':
                 oneLineDown();
                 break;
             case 'D':
                 oneLineDown();
                 break;
             }

         }
     }
}


esta clase tablero tambien se encarga de capturar las acciones del teclado como por ejemplo la tecla p se puede pausar el juego

y por ultimo la clase principal Tetris que es Jframe o mejor lo extendemos como un jframe





import java.awt.BorderLayout;

import javax.swing.JFrame;
import javax.swing.JLabel;


public class Tetris extends JFrame {

    JLabel statusbar;


    public Tetris() {

        statusbar = new JLabel(" 0");
        add(statusbar, BorderLayout.SOUTH);
        tablero board = new tablero(this);
        add(board);
        board.start();

        setSize(200, 400);
        setTitle("Tetris http://javayotros.blogspot.com/");
        setDefaultCloseOperation(EXIT_ON_CLOSE);
   }

   public JLabel getStatusBar() {
       return statusbar;
   }

    public static void main(String[] args) {

        Tetris game = new Tetris();
        game.setLocationRelativeTo(null);
        game.setVisible(true);

    } 
}


terminando descargamos la siguiente imagen para el juego donde estan  todas las piezas del tetris


martes, 11 de agosto de 2015 0 comentarios

juego ping pong en java codigo clasico de los 80







bueno amigos como hemos venido diciendo andamos con codigo de juegos clasicos en este momento les traigo un clasico de los 80  desarrollado por Atari.inc fue creado en 1976 alrededor de este año ,para los desarrolladores de juegos el ping pong una pelotica que rebota destrozando ladrillos y tu tirandola con punteria, es un juego muy divertido que si le agregamos  mas podemos variar de niveles.

la primera clase que vamos a desarrollar es comun donde agregaremos el ancho,tamaño ,alto etc etc




public interface comun {
    public static final int WIDTH = 300;
    public static final int HEIGTH = 400;
    public static final int BOTTOM = 390;
    public static final int PADDLE_RIGHT = 250;
    public static final int BALL_RIGHT = 280;
}

luego de esto seguimos con la clase Sprite donde pomdremos el siguiente codigo:



import java.awt.Image;
import java.awt.Rectangle;

public class Sprite {

    protected int x;
    protected int y;
    protected int width;
    protected int heigth;
    protected Image image;


    public void setX(int x) {
        this.x = x;
    }

    public int getX() {
        return x;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getY() {
        return y;
    }

    public int getWidth() {
        return width;
    }

    public int getHeight() {
        return heigth;
    }

    Image getImage()
    {
      return image;
    }

    Rectangle getRect()
    {
      return new Rectangle(x, y, 
          image.getWidth(null), image.getHeight(null));
    }
}

se encargara del movimiento de la pelotica y de otras imagenes.

la siguiente clase se llama balon esta obviamente se encarga del balon su movimiento y su recorrido


import javax.swing.ImageIcon;


public class balon extends Sprite implements comun {

   private int xdir;
   private int ydir;

   protected String ball = "balon.png";

   public balon() {

     xdir = 1;
     ydir = -1;

     ImageIcon ii = new ImageIcon(this.getClass().getResource(ball));
     image = ii.getImage();

     width = image.getWidth(null);
     heigth = image.getHeight(null);

     resetState();
    }


    public void move()
    {
      x += xdir;
      y += ydir;

      if (x == 0) {
        setXDir(1);
      }

      if (x == BALL_RIGHT) {
        setXDir(-1);
      }

      if (y == 0) {
        setYDir(1);
      }
    }

    public void resetState() 
    {
      x = 230;
      y = 355;
    }

    public void setXDir(int x)
    {
      xdir = x;
    }

    public void setYDir(int y)
    {
      ydir = y;
    }

    public int getYDir()
    {
      return ydir;
    }
}

seguimos con la clase ladrillo donde va ser los obstáculos a romper con la raqueta




import javax.swing.ImageIcon;


public class ladrillo extends Sprite {

    String brickie = "ladrillo.png";

    boolean destroyed;


    public ladrillo(int x, int y) {
      this.x = x;
      this.y = y;

      ImageIcon ii = new ImageIcon(this.getClass().getResource(brickie));
      image = ii.getImage();

      width = image.getWidth(null);
      heigth = image.getHeight(null);

      destroyed = false;
    }

    public boolean isDestroyed()
    {
      return destroyed;
    }

    public void setDestroyed(boolean destroyed)
    {
      this.destroyed = destroyed;
    }

}

seguimos con la clase paleta  donde esta la raqueta para hacer el rebote  de la pelota hacia el ladrillo




import java.awt.event.KeyEvent;

import javax.swing.ImageIcon;


public class paleta extends Sprite implements comun {

    String paddle = "paleta.png";

    int dx;

    public paleta() {

        ImageIcon ii = new ImageIcon(this.getClass().getResource(paddle));
        image = ii.getImage();

        width = image.getWidth(null);
        heigth = image.getHeight(null);

        resetState();
    }

    public void move() {
        x += dx;
        if (x <= 2) 
          x = 2;
        if (x >= comun.PADDLE_RIGHT)
          x = comun.PADDLE_RIGHT;
    }

    public void keyPressed(KeyEvent e) {

        int key = e.getKeyCode();

        if (key == KeyEvent.VK_LEFT) {
            dx = -2;

        }

        if (key == KeyEvent.VK_RIGHT) {
            dx = 2;
        }
    }

    public void keyReleased(KeyEvent e) {
        int key = e.getKeyCode();

        if (key == KeyEvent.VK_LEFT) {
            dx = 0;
        }

        if (key == KeyEvent.VK_RIGHT) {
            dx = 0;
        }
    }

    public void resetState() {
        x = 200;
        y = 360;
    }
}



luego seguimos con la clase tablero donde va cargar el jframe



import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

import java.util.Timer;
import java.util.TimerTask;

import javax.swing.JPanel;


public class tablero extends JPanel implements comun {

    Image ii;
    Timer timer;
    String message = "Game Over";
    balon ball;
    paleta paddle;
    ladrillo bricks[];

    boolean ingame = true;
    int timerId;


    public tablero() {

        addKeyListener(new TAdapter());
        setFocusable(true);

        bricks = new ladrillo[30];
        setDoubleBuffered(true);
        timer = new Timer();
        timer.scheduleAtFixedRate(new ScheduleTask(), 1000, 10);
    }

        public void addNotify() {
            super.addNotify();
            gameInit();
        }

    public void gameInit() {

        ball = new balon();
        paddle = new paleta();


        int k = 0;
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 6; j++) {
                bricks[k] = new ladrillo(j * 40 + 30, i * 10 + 50);
                k++;
            }
        }
    }


    public void paint(Graphics g) {
        super.paint(g);

        if (ingame) {
            g.drawImage(ball.getImage(), ball.getX(), ball.getY(),
                        ball.getWidth(), ball.getHeight(), this);
            g.drawImage(paddle.getImage(), paddle.getX(), paddle.getY(),
                        paddle.getWidth(), paddle.getHeight(), this);

            for (int i = 0; i < 30; i++) {
                if (!bricks[i].isDestroyed())
                    g.drawImage(bricks[i].getImage(), bricks[i].getX(),
                                bricks[i].getY(), bricks[i].getWidth(),
                                bricks[i].getHeight(), this);
            }
        } else {

            Font font = new Font("Verdana", Font.BOLD, 18);
            FontMetrics metr = this.getFontMetrics(font);

            g.setColor(Color.BLACK);
            g.setFont(font);
            g.drawString(message,
                         (comun.WIDTH - metr.stringWidth(message)) / 2,
                         comun.WIDTH / 2);
        }


        Toolkit.getDefaultToolkit().sync();
        g.dispose();
    }

    private class TAdapter extends KeyAdapter {

        public void keyReleased(KeyEvent e) {
            paddle.keyReleased(e);
        }

        public void keyPressed(KeyEvent e) {
            paddle.keyPressed(e);
        }
    }


    class ScheduleTask extends TimerTask {

        public void run() {

            ball.move();
            paddle.move();
            checkCollision();
            repaint();

        }
    }

    public void stopGame() {
        ingame = false;
        timer.cancel();
    }


    public void checkCollision() {

        if (ball.getRect().getMaxY() > comun.BOTTOM) {
            stopGame();
        }

        for (int i = 0, j = 0; i < 30; i++) {
            if (bricks[i].isDestroyed()) {
                j++;
            }
            if (j == 30) {
                message = "Victory";
                stopGame();
            }
        }

        if ((ball.getRect()).intersects(paddle.getRect())) {

            int paddleLPos = (int)paddle.getRect().getMinX();
            int ballLPos = (int)ball.getRect().getMinX();

            int first = paddleLPos + 8;
            int second = paddleLPos + 16;
            int third = paddleLPos + 24;
            int fourth = paddleLPos + 32;

            if (ballLPos < first) {
                ball.setXDir(-1);
                ball.setYDir(-1);
            }

            if (ballLPos >= first && ballLPos < second) {
                ball.setXDir(-1);
                ball.setYDir(-1 * ball.getYDir());
            }

            if (ballLPos >= second && ballLPos < third) {
                ball.setXDir(0);
                ball.setYDir(-1);
            }

            if (ballLPos >= third && ballLPos < fourth) {
                ball.setXDir(1);
                ball.setYDir(-1 * ball.getYDir());
            }

            if (ballLPos > fourth) {
                ball.setXDir(1);
                ball.setYDir(-1);
            }
        }


        for (int i = 0; i < 30; i++) {
            if ((ball.getRect()).intersects(bricks[i].getRect())) {

                int ballLeft = (int)ball.getRect().getMinX();
                int ballHeight = (int)ball.getRect().getHeight();
                int ballWidth = (int)ball.getRect().getWidth();
                int ballTop = (int)ball.getRect().getMinY();

                Point pointRight =
                    new Point(ballLeft + ballWidth + 1, ballTop);
                Point pointLeft = new Point(ballLeft - 1, ballTop);
                Point pointTop = new Point(ballLeft, ballTop - 1);
                Point pointBottom =
                    new Point(ballLeft, ballTop + ballHeight + 1);

                if (!bricks[i].isDestroyed()) {
                    if (bricks[i].getRect().contains(pointRight)) {
                        ball.setXDir(-1);
                    }

                    else if (bricks[i].getRect().contains(pointLeft)) {
                        ball.setXDir(1);
                    }

                    if (bricks[i].getRect().contains(pointTop)) {
                        ball.setYDir(1);
                    }

                    else if (bricks[i].getRect().contains(pointBottom)) {
                        ball.setYDir(-1);
                    }

                    bricks[i].setDestroyed(true);
                }
            }
        }
    }
}



bueno por ultimo la clase principal llamada raketa donde va empezar el juego

import javax.swing.JFrame;

public class raketa extends JFrame {

    public raketa()
    {
        add(new tablero());
        setTitle("tennis de mesa");
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setSize(comun.WIDTH, comun.HEIGTH);
        setLocationRelativeTo(null);
        setIgnoreRepaint(true);
        setResizable(false);
        setVisible(true);
    }

    public static void main(String[] args) {
        new raketa();
    }
}


por ultimo los sprites o imagenes:






viernes, 7 de agosto de 2015 0 comentarios

juego puzzle en java codigo tutorial

bueno muchachos aqui les dejo este buen juego de puzzle desarrollado en java por medio de la plataforma de netbeans como vemos este blog nos enseña a la creacion de juegos clasicos con codigo facil y accesible a cualquier usuario con niveles de programacion basicos
primero vamos a crear una nueva clase llamada Puzzle la cual va ser extendida como un jframe el codigo es el siguiente:



import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.image.BufferedImage;
import java.awt.image.CropImageFilter;
import java.awt.image.FilteredImageSource;
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class Puzzle extends JFrame {

    private JPanel panel;
    private BufferedImage source;
    private ArrayList buttons;

    ArrayList solution = new ArrayList();

    private Image image;
    private boton lastButton;
    private int width, height;
    private final int DESIRED_WIDTH = 600;
    private BufferedImage resized;

    public Puzzle() throws URISyntaxException {

        initUI();
    }

    private void initUI() throws URISyntaxException {

        solution.add(new Point(0, 0));
        solution.add(new Point(0, 1));
        solution.add(new Point(0, 2));
        solution.add(new Point(1, 0));
        solution.add(new Point(1, 1));
        solution.add(new Point(1, 2));
        solution.add(new Point(2, 0));
        solution.add(new Point(2, 1));
        solution.add(new Point(2, 2));
        solution.add(new Point(3, 0));
        solution.add(new Point(3, 1));
        solution.add(new Point(3, 2));

        buttons = new ArrayList();

        panel = new JPanel();
        panel.setBorder(BorderFactory.createLineBorder(Color.gray));
        panel.setLayout(new GridLayout(4, 3, 0, 0));

        try {
            source = loadImage();
            int h = getNewHeight(source.getWidth(), source.getHeight());
            resized = resizeImage(source, DESIRED_WIDTH, h,
                    BufferedImage.TYPE_INT_ARGB);

        } catch (IOException ex) {
            Logger.getLogger(Puzzle.class.getName()).log(
                    Level.SEVERE, null, ex);
        }

        width = resized.getWidth(null);
        height = resized.getHeight(null);

        add(panel, BorderLayout.CENTER);

        for (int i = 0; i < 4; i++) {

            for (int j = 0; j < 3; j++) {

                image = createImage(new FilteredImageSource(resized.getSource(),
                        new CropImageFilter(j * width / 3, i * height / 4,
                                (width / 3), height / 4)));
                boton button = new boton(image);
                button.putClientProperty("position", new Point(i, j));

                if (i == 3 && j == 2) {
                    lastButton = new boton();
                    lastButton.setBorderPainted(false);
                    lastButton.setContentAreaFilled(false);
                    lastButton.setLastButton();
                    lastButton.putClientProperty("position", new Point(i, j));
                } else {
                    buttons.add(button);
                }
            }
        }

        Collections.shuffle(buttons);
        buttons.add(lastButton);

        for (int i = 0; i < 12; i++) {

            boton btn = buttons.get(i);
            panel.add(btn);
            btn.setBorder(BorderFactory.createLineBorder(Color.gray));
            btn.addActionListener(new ClickAction());
        }

        pack();
        setTitle("Puzzle");
        setResizable(false);
        setLocationRelativeTo(null);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    private int getNewHeight(int w, int h) {

        double ratio = DESIRED_WIDTH / (double) w;
        int newHeight = (int) (h * ratio);
        return newHeight;
    }

    private BufferedImage loadImage() throws IOException, URISyntaxException {
//new ImageIcon(getClass().getResource(imageName)).getImage()
       // BufferedImage bimg = ImageIO.read(new File("sid.jpg"));
        
        BufferedImage bimg = null;
try {
    bimg = ImageIO.read(new File(getClass().getResource("sid.jpg").toURI()));
        
} catch (IOException e) {
    System.out.println(""+e.getMessage());
}

        return bimg;
    }

    private BufferedImage resizeImage(BufferedImage originalImage, int width,
            int height, int type) throws IOException {

        BufferedImage resizedImage = new BufferedImage(width, height, type);
        Graphics2D g = resizedImage.createGraphics();
        g.drawImage(originalImage, 0, 0, width, height, null);
        g.dispose();

        return resizedImage;
    }

    private class ClickAction extends AbstractAction {

        @Override
        public void actionPerformed(ActionEvent e) {

            checkButton(e);
            checkSolution();
        }

        private void checkButton(ActionEvent e) {

            int lidx = 0;
            for (boton button : buttons) {
                if (button.isLastButton()) {
                    lidx = buttons.indexOf(button);
                }
            }

            JButton button = (JButton) e.getSource();
            int bidx = buttons.indexOf(button);

            if ((bidx - 1 == lidx) || (bidx + 1 == lidx)
                    || (bidx - 3 == lidx) || (bidx + 3 == lidx)) {
                Collections.swap(buttons, bidx, lidx);
                updateButtons();
            }
        }

        private void updateButtons() {

            panel.removeAll();

            for (JComponent btn : buttons) {

                panel.add(btn);
            }

            panel.validate();
        }
    }

    private void checkSolution() {

        ArrayList current = new ArrayList();

        for (JComponent btn : buttons) {
            current.add((Point) btn.getClientProperty("position"));
        }

        if (compareList(solution, current)) {
            JOptionPane.showMessageDialog(panel, "Finalizado correctamente",
                    "Felicidades", JOptionPane.INFORMATION_MESSAGE);
        }
    }

    public static boolean compareList(List ls1, List ls2) {
        return ls1.toString().contentEquals(ls2.toString());
    }

    public static void main(String[] args) {

        EventQueue.invokeLater(new Runnable() {

            @Override
            public void run() {
                Puzzle puzzle = null;
                try {
                    puzzle = new Puzzle();
                } catch (URISyntaxException ex) {
                    Logger.getLogger(Puzzle.class.getName()).log(Level.SEVERE, null, ex);
                }
                puzzle.setVisible(true);
            }
        });
    }
}

luego creamos una clase llamada boton la cual ponemos el siguiente codigo:



import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.awt.image.CropImageFilter;
import java.awt.image.FilteredImageSource;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

class boton extends JButton {

    private boolean isLastButton;

    public boton() {

        super();

        initUI();
    }

    public boton(Image image) {

        super(new ImageIcon(image));

        initUI();
    }

    private void initUI() {

        isLastButton = false;
        BorderFactory.createLineBorder(Color.gray);

        addMouseListener(new MouseAdapter() {

            @Override
            public void mouseEntered(MouseEvent e) {
                setBorder(BorderFactory.createLineBorder(Color.yellow));
            }

            @Override
            public void mouseExited(MouseEvent e) {
                setBorder(BorderFactory.createLineBorder(Color.gray));
            }
        });
    }

    public void setLastButton() {
        
        isLastButton = true;
    }

    public boolean isLastButton() {

        return isLastButton;
    }
}



finalmente importamos una imagen puede ser cualquiera yo importe la imagen de la era del hielo el personaje perezosito sib :P


lunes, 3 de agosto de 2015 0 comentarios

juego de asteroides en java 2D codigo parte 2



bueno en la entrada anterior estaba realizando el juego de aviones contra extraterrestres, el cual solo movia el avion un sprite de avion pero ahora este juego no solo mueve el avion si no que dispara misiles y colisiona, tambien los aliens atacando, bueno lo primero que vamos a hacer es crear una clase llamada Alien la vamos a extender como un sprite aqui el codigo:



public class Alien extends Sprite {

    private final int INITIAL_X = 400;

    public Alien(int x, int y) {
        super(x, y);

        initAlien();
    }

    private void initAlien() {

        loadImage("alien.png");
        getImageDimensions();
    }

    public void move() {

        if (x < 0) {
            x = INITIAL_X;
        }

        x -= 1;
    }
}

luego creamos otra clase llamada Sprite la que se va encargar del movimiento de las imagenes


import java.awt.Image;
import java.awt.Rectangle;
import javax.swing.ImageIcon;

public class Sprite {

    protected int x;
    protected int y;
    protected int width;
    protected int height;
    protected boolean vis;
    protected Image image;

    public Sprite(int x, int y) {

        this.x = x;
        this.y = y;
        vis = true;
    }

    protected void getImageDimensions() {

        width = image.getWidth(null);
        height = image.getHeight(null);
    }

    protected void loadImage(String imageName) {
  Image ii = new ImageIcon(getClass().getResource(imageName)).getImage();
      //  ImageIcon ii = new ImageIcon(imageName);
        image = ii;
    }

    public Image getImage() {
        return image;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public boolean isVisible() {
        return vis;
    }

    public void setVisible(Boolean visible) {
        vis = visible;
    }

    public Rectangle getBounds() {
        return new Rectangle(x, y, width, height);
    }
}


seguimos con la clase llamada avion el cual pondremos el siguiente codigo:



import java.awt.event.KeyEvent;
import java.util.ArrayList;

public class avion extends Sprite {

    private int dx;
    private int dy;
    private ArrayList missiles;

    public avion(int x, int y) {
        super(x, y);

        initCraft();
    }

    private void initCraft() {
        
        missiles = new ArrayList();
        loadImage("avion.png");
        getImageDimensions();
    }

    public void move() {

        x += dx;
        y += dy;

        if (x < 1) {
            x = 1;
        }

        if (y < 1) {
            y = 1;
        }
    }

    public ArrayList getMissiles() {
        return missiles;
    }

    public void keyPressed(KeyEvent e) {

        int key = e.getKeyCode();

        if (key == KeyEvent.VK_SPACE) {
            fire();
        }

        if (key == KeyEvent.VK_LEFT) {
            dx = -1;
        }

        if (key == KeyEvent.VK_RIGHT) {
            dx = 1;
        }

        if (key == KeyEvent.VK_UP) {
            dy = -1;
        }

        if (key == KeyEvent.VK_DOWN) {
            dy = 1;
        }
    }

    public void fire() {
        missiles.add(new misil(x + width, y + height / 2));
    }

    public void keyReleased(KeyEvent e) {

        int key = e.getKeyCode();

        if (key == KeyEvent.VK_LEFT) {
            dx = 0;
        }

        if (key == KeyEvent.VK_RIGHT) {
            dx = 0;
        }

        if (key == KeyEvent.VK_UP) {
            dy = 0;
        }

        if (key == KeyEvent.VK_DOWN) {
            dy = 0;
        }
    }
}

seguimos con la clase colision que va ser un Jframe pondremos el siguiente codigo:



import java.awt.EventQueue;
import javax.swing.JFrame;

public class colision extends JFrame {

    public colision() {
        
        initUI();
    }
    
    private void initUI() {
        
        add(new tablero());
        
        setResizable(false);
        pack();
        
        setTitle("Collision");
        setLocationRelativeTo(null);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                colision ex = new colision();
                ex.setVisible(true);
            }
        });
    }
}


seguimos con la clase misil obviamente se va a encargar de los disparos hacia los asteroides:

public class misil extends Sprite {

    private final int BOARD_WIDTH = 390;
    private final int MISSILE_SPEED = 2;

    public misil(int x, int y) {
        super(x, y);

        initMissile();
    }
    
    private void initMissile() {
        
        loadImage("misil.png");
        getImageDimensions();        
    }

    public void move() {
        
        x += MISSILE_SPEED;
        
        if (x > BOARD_WIDTH)
            vis = false;
    }
}


por ultimo la clase tablero donde se va a encargar de dibujar todo:


import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import javax.swing.JPanel;
import javax.swing.Timer;

public class tablero extends JPanel implements ActionListener {

    private Timer timer;
    private avion craft;
    private ArrayList aliens;
    private boolean ingame;
    private final int ICRAFT_X = 40;
    private final int ICRAFT_Y = 60;
    private final int B_WIDTH = 400;
    private final int B_HEIGHT = 300;
    private final int DELAY = 15;

    private final int[][] pos = {
        {2380, 29}, {2500, 59}, {1380, 89},
        {780, 109}, {580, 139}, {680, 239},
        {790, 259}, {760, 50}, {790, 150},
        {980, 209}, {560, 45}, {510, 70},
        {930, 159}, {590, 80}, {530, 60},
        {940, 59}, {990, 30}, {920, 200},
        {900, 259}, {660, 50}, {540, 90},
        {810, 220}, {860, 20}, {740, 180},
        {820, 128}, {490, 170}, {700, 30}
    };

    public tablero() {

        initBoard();
    }

    private void initBoard() {

        addKeyListener(new TAdapter());
        setFocusable(true);
        setBackground(Color.BLACK);
        ingame = true;

        setPreferredSize(new Dimension(B_WIDTH, B_HEIGHT));

        craft = new avion(ICRAFT_X, ICRAFT_Y);

        initAliens();

        timer = new Timer(DELAY, this);
        timer.start();
    }

    public void initAliens() {
        aliens = new ArrayList();

        for (int[] p : pos) {
            aliens.add(new Alien(p[0], p[1]));
        }
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        if (ingame) {

            drawObjects(g);

        } else {

            drawGameOver(g);
        }

        Toolkit.getDefaultToolkit().sync();
    }

    private void drawObjects(Graphics g) {

        if (craft.isVisible()) {
            g.drawImage(craft.getImage(), craft.getX(), craft.getY(),
                    this);
        }

        ArrayList ms = craft.getMissiles();

        for (misil m : ms) {
            if (m.isVisible()) {
                g.drawImage(m.getImage(), m.getX(), m.getY(), this);
            }
        }

        for (Alien a : aliens) {
            if (a.isVisible()) {
                g.drawImage(a.getImage(), a.getX(), a.getY(), this);
            }
        }

        g.setColor(Color.WHITE);
        g.drawString("Aliens left: " + aliens.size(), 5, 15);
    }

    private void drawGameOver(Graphics g) {

        String msg = "Game Over";
        Font small = new Font("Helvetica", Font.BOLD, 14);
        FontMetrics fm = getFontMetrics(small);

        g.setColor(Color.white);
        g.setFont(small);
        g.drawString(msg, (B_WIDTH - fm.stringWidth(msg)) / 2,
                B_HEIGHT / 2);
    }

    @Override
    public void actionPerformed(ActionEvent e) {

        inGame();

        updateCraft();
        updateMissiles();
        updateAliens();

        checkCollisions();

        repaint();
    }

    private void inGame() {
        
        if (!ingame) {
            timer.stop();
        }
    }

    private void updateCraft() {

        if (craft.isVisible()) {
            craft.move();
        }
    }

    private void updateMissiles() {

        ArrayList ms = craft.getMissiles();

        for (int i = 0; i < ms.size(); i++) {

            misil m = ms.get(i);

            if (m.isVisible()) {
                m.move();
            } else {
                ms.remove(i);
            }
        }
    }

    private void updateAliens() {

        if (aliens.isEmpty()) {

            ingame = false;
            return;
        }

        for (int i = 0; i < aliens.size(); i++) {

            Alien a = aliens.get(i);
            if (a.isVisible()) {
                a.move();
            } else {
                aliens.remove(i);
            }
        }
    }

    public void checkCollisions() {

        Rectangle r3 = craft.getBounds();

        for (Alien alien : aliens) {
            Rectangle r2 = alien.getBounds();

            if (r3.intersects(r2)) {
                craft.setVisible(false);
                alien.setVisible(false);
                ingame = false;
            }
        }

        ArrayList ms = craft.getMissiles();

        for (misil m : ms) {

            Rectangle r1 = m.getBounds();

            for (Alien alien : aliens) {

                Rectangle r2 = alien.getBounds();

                if (r1.intersects(r2)) {
                    m.setVisible(false);
                    alien.setVisible(false);
                }
            }
        }
    }

    private class TAdapter extends KeyAdapter {

        @Override
        public void keyReleased(KeyEvent e) {
            craft.keyReleased(e);
        }

        @Override
        public void keyPressed(KeyEvent e) {
            craft.keyPressed(e);
        }
    }
}

ya teniendo las clases vamos a cargar los sprites los recorte uno por uno aqui se los dejo:




y finalmente por fin :P les dejo la arquitectura de las clases:



sábado, 1 de agosto de 2015 0 comentarios

juego de asteroides ó aliens en java 2D

bueno empezamos con un juego clasico de los 80 en estos dias he estado asi realizando varios juegos en java por ejemplo el pacman que es de codigo abierto y lo modifique por que estaba abandonado pero subi los sprites, igual que este juego al cual estoy realizando o desarrolando con un poco de ayuda web online voy a hacer la primera parte luego lo terminare en otra entrada en este blog , el juego quedara como la siguiente imagen:


vamos a tener 3 clases y el sprite del avion, yo cree un pakete llamado aviones pero le pueden poner como quieran aqui imagen de la arquitectura:

la 1 clasela llmaremos avion en esta clase colocaremos el siguiente codigo:










import java.awt.Image;
import java.awt.event.KeyEvent;
import javax.swing.ImageIcon;

public class avion {

    private int dx;
    private int dy;
    private int x;
    private int y;
    private Image image;

    public avion() {
        
        initCraft();
    }
    
    private void initCraft() {
      Image ii = new ImageIcon(getClass().getResource("avion.png")).getImage();
    //    ImageIcon ii = new ImageIcon("craft.png");
        image = ii;
        x = 40;
        y = 60;        
    }


    public void move() {
        x += dx;
        y += dy;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public Image getImage() {
        return image;
    }

    public void keyPressed(KeyEvent e) {
      
        int key = e.getKeyCode();
          System.out.println(""+key);

        if (key == KeyEvent.VK_LEFT) {
            dx = -1;
        }

        if (key == KeyEvent.VK_RIGHT) {
            dx = 1;
        }

        if (key == KeyEvent.VK_UP) {
            dy = -1;
        }

        if (key == KeyEvent.VK_DOWN) {
            dy = 1;
        }
    }

    public void keyReleased(KeyEvent e) {
        System.out.println("");
        int key = e.getKeyCode();

        if (key == KeyEvent.VK_LEFT) {
            dx = 0;
        }

        if (key == KeyEvent.VK_RIGHT) {
            dx = 0;
        }

        if (key == KeyEvent.VK_UP) {
            dy = 0;
        }

        if (key == KeyEvent.VK_DOWN) {
            dy = 0;
        }
    }
}

luego creamos una nueva clase y la llmaremos mueveimagen pondremos el siguiente codigo:

import java.awt.EventQueue;
import javax.swing.JFrame;

public class mueveimagen extends JFrame {

    public mueveimagen() {
        super("http://javayotros.blogspot.com/");
        initUI();
    }
    
    private void initUI() {
        
        add(new tablero());
        
        setSize(400, 300);
        setResizable(false);
        
        setTitle("http://javayotros.blogspot.com/");
        setLocationRelativeTo(null);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                
                mueveimagen ex = new mueveimagen();
                ex.setVisible(true);
            }
        });
    }
}

agremos otra clase llamada tablero quese va a encargar de dibujar todo:

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.JPanel;
import javax.swing.Timer;


public class tablero extends JPanel implements ActionListener {

    private Timer timer;
    private avion craft;
    private final int DELAY = 10;

    public tablero() {

        initBoard();
    }
    
    private void initBoard() {
        
        addKeyListener(new TAdapter());
        setFocusable(true);
        setBackground(Color.BLACK);

        craft = new avion();

        timer = new Timer(DELAY, this);
        timer.start();        
    }


    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        doDrawing(g);

        Toolkit.getDefaultToolkit().sync();
    }

    private void doDrawing(Graphics g) {
        
        Graphics2D g2d = (Graphics2D) g;
        g2d.drawImage(craft.getImage(), craft.getX(), craft.getY(), this);        
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        
        craft.move();
        repaint();  
    }

    private class TAdapter extends KeyAdapter {

        @Override
        public void keyReleased(KeyEvent e) {
            craft.keyReleased(e);
        }

        @Override
        public void keyPressed(KeyEvent e) {
            craft.keyPressed(e);
        }
    }
}

finalmente el sprite de la imagen del avion

lo descargan y lo colocan al lado para que funcione
el mueve hacia los lados obviamente faltan los misiles y los asteroides o extraterrestres eso lo realizare en la segunda parte en otra entrada :)


 
;