Space Invaders

Otro juego popular "ochentoso". Vamos a clonarlo, consistira basicamente en una nave que podemos controlar, la cual se mueve solo horizontalmente, y muchas naves enemigas que van bajando y moviendose, si destruimos todas antes que llegen al piso, ganamos, de lo contrario, perdemos x)
En este caso las naves enemigas seran llamados Aliens. Para descargar las imagenes que vamos a utilizar, clickea aca.
Muy bien, empezamos como veniamos hasta ahora, creamos un nuevo proyecto en netbeans, en este caso lo llame Space Invaders, y el package spaceinvaders. En la clase principal heredamos JFrame y hacemos la ventana.

package spaceinvaders;

import javax.swing.JFrame;

/**
*
* @author fede
*/
public class Main extends JFrame {

  public Main(){
      add(new Board());
      setTitle("JSpace Invaders");
      setDefaultCloseOperation(EXIT_ON_CLOSE);
      setSize(300,300);
      setLocationRelativeTo(null);
      setVisible(true);
      setResizable(false);
  }

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

}

Nada nuevo hasta ahora, y de hecho no deberia haber nada nuevo en las otras clases tampoco, solo logica.
Veamos ahora la clase Ship. Esta clase es nuestra nave principal, la cual movemos y es capaz de disparar.
Realmente no tiene cosas nuevas ninguna de estas clases, pero si no sabes ArrayList por ejemplo, recomendaria leer la documentacion a parte.
Aca tenemos la clase Ship.

package spaceinvaders;

import javax.swing.ImageIcon;

import java.awt.Image;
import java.awt.event.KeyEvent;
import java.awt.Rectangle;

import java.util.ArrayList;

/**
*
* @author fede
*/
public class Ship {
  private Image image;
  private int x,y,dx;
  private final int SPEED = 2;
  private ArrayList lasers;
  private boolean shot;
  public Ship(){
      ImageIcon ii = new ImageIcon(this.getClass().getResource("images/ship.png"));
      image = ii.getImage();
      y = 250;
      x = 150-image.getWidth(null)/2;
      dx = 0;
      lasers = new ArrayList();
      shot = true;
  }

  public int getX(){
      return x;
  }

  public int getY(){
      return y;
  }

  public Image getImage(){
      return image;
  }

  public ArrayList getLasers(){
      return lasers;
  }

  public void logic(){ // Toda la logica la pondre aca
      if((x>0 && dx<0)>0))
          x += dx;
  }

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

      if(key == KeyEvent.VK_RIGHT)
          dx = SPEED;
      if(key == KeyEvent.VK_LEFT)
          dx = SPEED * -1;
      if(key == KeyEvent.VK_SPACE && shot)
      {
          lasers.add(new Laser(x + image.getWidth(null)/2, y));
          shot = false;
      }
  }

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

      if(key == KeyEvent.VK_LEFT && dx < dx =" 0;" key ="="> 0)
          dx = 0;
      if(key == KeyEvent.VK_SPACE)
          shot = true;
  }

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

Como veran, la mayoria son variables, algunos sets y gets, logica y teclas, no es mucho realmente, lo que resaltaria de aca es cuando apretamos la barra espaciadora, vemos que agregamos un nuevo objeto Laser (que sera otra clase) a una ArrayList, la idea es luego devolver esa lista y asi manipular todos los lasers en un bucle.
Ahora, veamos la clase Laser, esta es bastante simple, solo se necesita la imagen, y algo de logica

package spaceinvaders;

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

/**
*
* @author fede
*/
public class Laser {
  protected Image image;
  protected int x,y;
  private final int SPEED = 5;
  private boolean visible;

  public Laser(int x, int y){
      ImageIcon ii = new ImageIcon(this.getClass().getResource("images/laser.png"));
      image = ii.getImage();
      visible = true;
      this.x = x;
      this.y = y;
  }

  public int getX(){
      return x;
  }

  public int getY(){
      return y;
  }

  public Image getImage(){
      return image;
  }


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

  public boolean isVisible(){
      return visible;
  }

  public void setVisible(boolean visible){
      this.visible = visible;
  }

  public void update(){
      y -= SPEED;
      if(y<0) visible =" false;">

Vemos que en el constructor ponemos las coordenadas iniciales, es importante ya que queremos los lasers en las mismas coordenadas que nuestra nave. Como veran solo tenemos cinco variables, image, x, y, SPEED y visible.
Son bastante descriptivas por si mismas, visible quizas sea mas complicada que las demas ahora, simplemente dice si debemos dibujar y considerar este objeto para colision, cuando esta como no visible, es como si no existiera y luego es borrado.
Los aliens de nuestro juego tambien pueden tirar bombas, son muy similares a los lasers, la unica diferencia es que caen, envez de subir, ya que los aliens estan arriba y van bajando, dejan caer bombas. La clase Bomb especifica estas bombas, ya que son tan similares a los lasers, heredamos de esta clase y cambiamos solo lo necesario.

package spaceinvaders;

/**
*
* @author fede
*/
public class Bomb extends Laser {
  public Bomb(int x, int y){
      super(x, y);
  }

  @Override
  public void update(){
      y++;
  }
}

Ahora, la clase Alien, despues de la principal (Board) creo que es la mas complicada, asi que intentare explicarla mas a fondo.

package spaceinvaders;

import java.awt.Image;
import java.awt.Rectangle;
import javax.swing.ImageIcon;
import java.util.Random;
import java.util.ArrayList;

/**
 *
 * @author fede
 */
public class Alien {
    private Image image;
    private int x, y, speed, direction, movedX, movedY, wentDown, bombChance;
    private final int RANGE;
    private boolean visible, goDown;
    private Random random;
    private ArrayList bombs;
    public Alien(int x, int y){
        ImageIcon ii = new ImageIcon(this.getClass().getResource("images/alien.png"));
        image = ii.getImage();
        this.x = x;
        this.y = y;
        speed = 1;
        RANGE = 100;
        movedX = 0;
        direction = 1; // 1 = derecha, -1 = izquierda
        visible = true;
        goDown = false;
        movedY = 0;
        wentDown = 0;
        random = new Random();
        bombChance = 700; // 1 in 40
        bombs = new ArrayList();
    }

    public int getX(){
        return x;
    }

    public int getY(){
        return y;
    }

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

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

    public Image getImage(){
        return image;
    }

    public int getSpeed(){
        return speed;
    }

    public void setSpeed(int speed){
        this.speed = speed;
    }

    public void setVisible(boolean visible){
        this.visible = visible;
    }
    
    public boolean isVisible(){
        return visible;
    }

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

    public void update(){
        if(movedX>RANGE){
            movedX = 0;
            goDown = true;
            direction*=-1;
        }

        if(goDown){
            y++;
            movedY++;
            if(movedY > image.getHeight(null))
            {
                goDown = false;
                movedY = 0;
                wentDown++;
                if(wentDown%2==0)
                    speed++;
            }
        } else {
            x += speed * direction;
            movedX+= speed;
        }

        if(random.nextInt()%bombChance==1 && y < 150)
            bombs.add(new Bomb(x, y));
    }

    public ArrayList getBombs(){
        return bombs;
    }
}

A primera vista, notamos muchas variables, la mayoria son faciles de deducir que hacen pero las demas las ire explicando a medida que explique que hacen los aliens.
Para poder explicar esta clase es necesario que entiendas como se mueven los aliens. Los aliens tienen un rango, se mueven hacia la derecha ese rango, luego bajan, y se mueven hacia la izquierda, el mismo rango, y repiten. Ese movimiento lo hacemos en el update, para eso necesitamos muchas variables, creo la mayoria son de esa logica. Otra cosa que hacemos es un random para tirar las bombas, constantemente genera numeros aleatorios hasta que tira una bomba cuando es igual a uno que pidamos dentro del rango. Lo puse en 700, es decir, tenes una chance en 700 de que tire la bomba, pero con todos los aliens y la velocidad que se actualiza, es bastante seguido. Tiene un metodo getBombs, similar al de ship para los lasers, y el resto son puros sets y gets.

Finalmente, llegamos a la clase Board, la que junta todas las demas clases, aca esta

package spaceinvaders;

import javax.swing.JPanel;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Color;

// timer
import javax.swing.Timer;
import java.awt.Toolkit;

// teclas y timer
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

// teclas
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

import java.util.ArrayList;

import java.awt.Font;

/**
 *
 * @author fede
 */
public class Board extends JPanel implements ActionListener {
    private Timer timer;
    private Ship ship;
    private Alien alien[][];
    private final int ALIENFILES, ALIENROWS, ALIEN_STARTX, ALIEN_STARTY, ALIEN_PADDING;
    private Font font;
    private String msg;
    private int aliensLeft;
    private boolean gameEnded;
    public Board(){
        setDoubleBuffered(true);
        setBackground(Color.white);
        setFocusable(true);
        addKeyListener(new Listener());
        
        ship = new Ship();
        
        // Aliens
        ALIENFILES = 6;
        ALIENROWS = 3;
        ALIEN_STARTX = 20;
        ALIEN_STARTY = 20;
        ALIEN_PADDING = 3;
        alien = new Alien[ALIENFILES][ALIENROWS];
        for(int i = 0; i < ALIENFILES; i++)
            for(int j = 0; j < ALIENROWS; j++){
                alien[i][j] = new Alien(ALIEN_STARTX, ALIEN_STARTY);
                alien[i][j].setX(ALIEN_STARTX + i*alien[i][j].getImage().getWidth(null) + i*ALIEN_PADDING);
                alien[i][j].setY(ALIEN_STARTY + j*alien[i][j].getImage().getHeight(null) + j*ALIEN_PADDING);
            }

        aliensLeft = ALIENFILES * ALIENROWS;
        font = new Font("Verdana", Font.PLAIN, 12);
        msg = "Aliens left: " + aliensLeft;

        gameEnded = false;

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

    public void paint(Graphics g){
        super.paint(g);
        Graphics2D g2d = (Graphics2D)g;

        // Draw
        g2d.drawImage(ship.getImage(), ship.getX(), ship.getY(), this);

        // Draw Lasers
        ArrayList lasers = ship.getLasers();
        for(int i = 0; i < lasers.size(); i++){
            Laser l = lasers.get(i);
            g2d.drawImage(l.getImage(), l.getX(), l.getY(), this);
        }

        // Draw aliens
        for(int i = 0; i < ALIENFILES; i++)
            for(int j = 0; j < ALIENROWS; j++){
                if(alien[i][j].isVisible())
                    g2d.drawImage(alien[i][j].getImage(), alien[i][j].getX(),
                            alien[i][j].getY(), this);
                ArrayList bombs = alien[i][j].getBombs();
                for(int k=0; k < bombs.size(); k++){
                    Bomb bomb = bombs.get(k);
                    g2d.drawImage(bomb.getImage(), bomb.getX(), bomb.getY(), this);
                }
            }

        
        // Draw text
        g2d.setColor(Color.black);
        g2d.setFont(font);
        g2d.drawString(msg, 3, 12);

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

    public void actionPerformed(ActionEvent e){
        // Updates
        ship.logic();
        
        // Lasers
        ArrayList lasers = ship.getLasers();
        for(int i = 0; i < lasers.size(); i++){
            Laser l = lasers.get(i);
            if(l.isVisible())
                l.update();
            else
                lasers.remove(i);
        }

        // Aliens
        for(int i = 0; i < ALIENFILES; i++){
            for(int j = 0; j < ALIENROWS; j++){
                alien[i][j].update();
                if(alien[i][j].getY() >= 250)
                    gameOver(0); // 0 = lose, 1 = win

                // Aliens Bombs
                ArrayList bombs = alien[i][j].getBombs();
                for(int k=0; k < bombs.size(); k++){
                    Bomb bomb = bombs.get(k);
                    if(bomb.isVisible())
                        bomb.update();
                    else
                        bombs.remove(k);

                    if(bomb.getBounds().intersects(ship.getBounds()))
                    {
                        bomb.setVisible(false);
                        gameOver(0);
                    }
                }

                //Hit Test
                for(int li = 0; li < lasers.size(); li++){
                    Laser l = lasers.get(li);
                    if(l.getBounds().intersects(alien[i][j].getBounds()) && l.isVisible() && alien[i][j].isVisible()){
                        alien[i][j].setVisible(false);
                        l.setVisible(false);
                        aliensLeft--;
                        if(aliensLeft <= 0)
                            gameOver(1);
                    }
                }
            }
        }

        if(!gameEnded)
            msg = "Aliens left: " + aliensLeft;

        repaint();
    }

    private class Listener extends KeyAdapter{
        @Override
        public void keyPressed(KeyEvent e){
            ship.keyPressed(e);
            if(e.getKeyCode() == KeyEvent.VK_ENTER){
                if(gameEnded){
                    for(int i = 0; i < ALIENFILES; i++)
                        for(int j = 0; j < ALIENROWS; j++){
                            alien[i][j] = null;
                            alien[i][j] = new Alien(ALIEN_STARTX, ALIEN_STARTY);
                            alien[i][j].setX(ALIEN_STARTX + i*alien[i][j].getImage().getWidth(null) + i*ALIEN_PADDING);
                            alien[i][j].setY(ALIEN_STARTY + j*alien[i][j].getImage().getHeight(null) + j*ALIEN_PADDING);
                        }
                    gameEnded = false;
                    aliensLeft = ALIENFILES * ALIENROWS;
                    timer.start();
                }
            }
        }

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

    public void gameOver(int status){
        gameEnded = true;
        if(status == 0)
            msg = "You lose!";
        else
            msg = "You won!";
        msg += " - Press [ENTER] to play again.";
        timer.stop();
    }
}

Bueno, la clase mas larga, Board, los conceptos estan todos explicados creo yo, si hay algo sin explicar por favor contactenme asi lo arreglo.

Ciertamente hay cosas que los pueden confundir pero seria puro Java. Uso una array bidimensional para los aliens, asi que especifico la cantidad de filas y columnas que quiero. Los bucles mas complicados serian los de deteccion de colision, que tenemos que comparar todos los lasers con todos los aliens, quizas sea eso lo que mas confunda pero es bastante simple, solo prestar atencion a como se hace. Recomiendo ver el pong, y todos los conceptos, si practicaron con eso, no deberia haber mayores inconvenientes con esto.

Para cualquier duda o sugerencia contactenme!

Descargar: de mediafire

Pong

Muy bien! Suficiente teoria, es hora de hacer algo, como primer juego, me gusta hacer un Pong, me parece el mas simple de todos, y engloba bien hit test, input y animacion, que es lo que vimos hasta ahora.
Creamos un nuevo proyecto, yo lo llame Pong, y el package "pong".
Veamos la clas Main, la "principal" del proyecto, esta solo tendra la ventana y creara un nuevo Board.

package pong;

import javax.swing.JFrame;

/**
*
* @author fede
*/
public class Main extends JFrame {
  public Main(){
      add(new Board());
      setTitle("Basic JPong");
      setDefaultCloseOperation(EXIT_ON_CLOSE);
      setSize(300,280);
      setLocationRelativeTo(null);
      setVisible(true);
      setResizable(false);
  }

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

Como veran es bastante parecido a lo que veniamos haciendo, solo cambie el tamaño y el titulo.
Veamos ahora la clase Player, esa clase es la encargada de las "barritas" que seran los jugadores, en este caso usaremos dos, para hacerlo de dos jugadores, aunque podrias hacer otra clase para el jugador dos, que sea inteligencia artificial y juege solo, asi seria de un jugador. En este ejemplo lo haremos de dos jugadores.
Primero, las librerias que importamos, ellas son

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

// Para tener las constantes de las teclas y el tipo KeyEvent, despues se manda por argumento bien
import java.awt.event.KeyEvent;

Ahora hacemos las variables que usaremos (esto yo lo hize antes, por eso se todas las variables que usare, por lo general esto lo modifico mucho, al igual que los 'imports')

private Image image;
private int x,y,dy,upKey,downKey,width,height,score;

private final int SPEED = 4;

En el constructor iniciamos los valores necesarios, y luego es mayormente get's y set's. Aca les dejo la clase Player

package pong;

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

import java.awt.event.KeyEvent;

/**
*
* @author fede
*/
public class Player {
  private Image image;
  private int x,y,dy,upKey,downKey,width,height,score;

  private final int SPEED = 4;

  public Player(int x, int y, String img, int upKey, int downKey){
      ImageIcon ii = new ImageIcon(this.getClass().getResource(img));
      image = ii.getImage();
      this.x = x; // Es irrelevante para getear, solo se mueve arriba y abajo la barra
      this.y = y;
      dy = 0;
      this.upKey = upKey;
      this.downKey = downKey;
      width = image.getWidth(null);
      height = image.getHeight(null);
      score = 0;
  }

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

  public Image getImage(){
      return image;
  }

  public int getY(){
      return y;
  }

  public int getX(){
      return x;
  }

  public int getScore(){
      return score;
  }

  public void setScore(int score){
      this.score = score;
  }

  public void move(){
      if((y > 0 && dy <> 0))
          y += dy;
  }

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

      if(key == upKey)
          dy = SPEED * -1;
      else if(key == downKey)
          dy = SPEED;
  }

  public void keyReleased(KeyEvent e){
      dy = 0;
  }
}

La funcion keyPressed se llamara cuando en board se presione alguna tecla, y mandamos la tecla por argumento, asi podemos evaluar bien que hacer con ella en nuestra clase, lo imsmo para keyReleased. La funcion move se llama en el update (en este caso, cada 5ms) y en ella actualizamos la posicion del sprite.
Ahora Ball.java. Esta clase es bastante parecida a la anterior por lo que no explicare mucho.

package pong;

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

import javax.swing.ImageIcon;


/**
*
* @author fede
*/
public class Ball {
  private Image image;
  private int x,y,dx,dy,width,height;
  private final int SPEED = 2;
  public Ball(){
      ImageIcon ii = new ImageIcon(this.getClass().getResource("ball.png"));
      image = ii.getImage();
      x = y = 30;
      dy = dx = SPEED;
      width = image.getWidth(null);
      height = image.getHeight(null);
  }

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

  public Image getImage(){
      return image;
  }

  public int getX(){
      return x;
  }

  public int getY(){
      return y;
  }

  public int getDy(){
      return dy;
  }

  public int getDx(){
      return dx;
  }

  public void setDx(int dx){
      this.dx = dx;
  }

  public void setDy(int dy){
      this.dy = dy;
  }

  public void setPosition(int x, int y, boolean invert){
      this.x = x;
      this.y = y;
      if(invert){
          dy*=-1;
          dx*=-1;
      }
  }

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

Como veran solo importamos lo necesario para usar la imagen y rectangles. La mayoria de las funciones son get's y set's, setPosition se usa para resetear facimente la posicion de la pelota, move actualiza la posicion, igual que en Player, el resto es solo iniciar variables en el constructor.
Finalmente veremos la clase Board. Es muy importante que hallan seguido el blog hasta ahora ya que utiliza todo lo que vimos hasta ahora.

package pong;

import javax.swing.JPanel;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Color;
import java.awt.Rectangle; // Para collision detection

// Timer
import java.awt.Toolkit;
import javax.swing.Timer;

// Para leer las teclas
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener; // interface con un metodo, actionPerformed
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

// Para escribir
import java.awt.Font;
import java.awt.FontMetrics;

/**
*
* @author fede
*/
public class Board extends JPanel implements ActionListener {
  private Player player1, player2;
  private Timer timer;
  private Ball ball;
  private Font small;
  private String msg;

  private static final int MAX_SCORE = 10;

  public Board(){
      setDoubleBuffered(true);
      setBackground(Color.white);
      setFocusable(true);
      addKeyListener(new TAdapter());

      player1 = new Player(3,100,"bar.png", KeyEvent.VK_UP, KeyEvent.VK_DOWN);
      player2 = new Player(285,100, "bar.png", KeyEvent.VK_W, KeyEvent.VK_S);
      ball = new Ball();

      // font
      small = new Font("Verdana", Font.PLAIN, 12);
      FontMetrics mtr = this.getFontMetrics(small);

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

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

      Graphics2D g2d = (Graphics2D)g;

      // Paint
      g2d.drawImage(player1.getImage(), player1.getX(), player1.getY(), this);
      g2d.drawImage(player2.getImage(), player2.getX(), player2.getY(), this);
      g2d.drawImage(ball.getImage(), ball.getX(), ball.getY(), this);

      // Write
      g2d.setColor(Color.black);
      g2d.setFont(small);
      if(isGameOver()==0)
          msg = "P1: "+player1.getScore()+" - P2: "+player2.getScore();
      g2d.drawString(msg, 10, 13);

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

  public void actionPerformed(ActionEvent e){ // Esto updatea el timer
      // Logic
      player1.move();
      player2.move();
      ball.move();

      // Collision Detection
      Rectangle br = ball.getBounds();
      Rectangle p1r = player1.getBounds();
      Rectangle p2r = player2.getBounds();

      if(ball.getX() <>290 || br.intersects(p1r) || br.intersects(p2r))
          ball.setDx(ball.getDx()*-1);
      if(ball.getY() <>250)
          ball.setDy(ball.getDy()*-1);

      // Aver score
      if(ball.getX() <= 0){
            player2.setScore(player2.getScore()+1);
            ball.setPosition(150,100, true);
        }
        if(ball.getX() >= 285){
            player1.setScore(player1.getScore()+1);
            ball.setPosition(150,100, true);
        }
      if(isGameOver()>0){
              msg = "Player " + isGameOver() + " wins - Press any key to play again";
              ball.setDx(0);
              ball.setDy(0);
      }
   
      repaint();
  }

  private int isGameOver(){
      if(player1.getScore() >= MAX_SCORE || player2.getScore() >= MAX_SCORE){
          if(player1.getScore()>player2.getScore())
              return 1;
          else
              return 2;
      }
      else
          return 0;
  }

  private class TAdapter extends KeyAdapter {
      public void keyPressed(KeyEvent e){
          player1.keyPressed(e);
          player2.keyPressed(e);
          if(isGameOver()>0){
              player1.setScore(0);
              player2.setScore(0);
              ball = new Ball();
          }
      }
      public void keyReleased(KeyEvent e){
         player1.keyReleased(e);
         player2.keyReleased(e);
      }
  }
}

Primero que nada vemos que usamos muchas librerias, de las cuales todas estan "explicadas" y usadas anteriormente, excepto las que usamos para escribir, ellas son

import java.awt.Font;
import java.awt.FontMetrics;

Para escribir, en el draw simplemente hacemos

g2d.setColor(Color.black);
g2d.setFont(small);
if(isGameOver()==0)
  msg = "P1: "+player1.getScore()+" - P2: "+player2.getScore();
g2d.drawString(msg, 10, 13);

setColor es en el color que vamos a escribir, en este caso como el fondo es blanco, usaremos negro. setFont usa una font que definimos en el constructor, finalmente drawString escribe la string msg en las coordenadas 10, 13.
Para hacer una font, en el constructor pusimos esto

small = new Font("Verdana", Font.PLAIN, 12);
FontMetrics mtr = this.getFontMetrics(small);

Luego tenemos nuestro metodo paint, ahi dibujamos los players, la pelota y escribimos.
En actionPerformed hacemos las actualizaciones move() de los players y de la pelota, ademas nos fijamos por colisiones y por si el juego acabo.
Finalmente en keyAdapter, mandamos las teclas apretadas a que se procesen en los objetos player.
Si venian siguiendo el blog hasta ahora, espero este claro todo lo que hize, cualquier duda pueden contactarme :)



Eso fue Pong.
Codigo Fuente: de 4shared