Curso - Programación de un Space Invaders en Java

1     /**
2      * Curso Básico de desarrollo de Juegos en Java - Invaders
3      * 
4      * (c) 2004 Planetalia S.L. - Todos los derechos reservados. Prohibida su reproducción
5      * 
6      * http://www.planetalia.com
7      * 
8      */
9     package version13;
10    
11    import java.awt.image.BufferedImage;
12    import java.net.URL;
13    import java.util.HashMap;
14    
15    import javax.imageio.ImageIO;
16    
17    public class SpriteCache {
18      private HashMap sprites;
19      
20      public SpriteCache() {
21        sprites = new HashMap();
22      }
23      
24      private BufferedImage loadImage(String nombre) {
25        URL url=null;
26        try {
27          url = getClass().getClassLoader().getResource(nombre);
28          return ImageIO.read(url);
29        } catch (Exception e) {
30          System.out.println("No se pudo cargar la imagen " + nombre +" de "+url);
31          System.out.println("El error fue : "+e.getClass().getName()+" "+e.getMessage());
32          System.exit(0);
33          return null;
34        }
35      }
36      
37      public BufferedImage getSprite(String nombre) {
38        BufferedImage img = (BufferedImage)sprites.get(nombre);
39        if (img == null) {
40          img = loadImage("res/"+nombre);
41          sprites.put(nombre,img);
42        }
43        return img;
44      }
45    }
46    

1     /**
2      * Curso Básico de desarrollo de Juegos en Java - Invaders
3      * 
4      * (c) 2004 Planetalia S.L. - Todos los derechos reservados. Prohibida su reproducción
5      * 
6      * http://www.planetalia.com
7      * 
8      */
9     package version13;
10    
11    import java.awt.image.ImageObserver;
12    
13    public interface Stage extends ImageObserver {
14      public static final int WIDTH=640;
15      public static final int HEIGHT=480;
16      public static final int SPEED=10;
17      public SpriteCache getSpriteCache();
18    
19    }
20    

1     /**
2      * Curso Básico de desarrollo de Juegos en Java - Invaders
3      * 
4      * (c) 2004 Planetalia S.L. - Todos los derechos reservados. Prohibida su reproducción
5      * 
6      * http://www.planetalia.com
7      * 
8      */
9     package version13;
10    
11    import java.awt.Graphics2D;
12    import java.awt.image.BufferedImage;
13    
14    public class Actor {
15      protected int x,y;
16      protected int width, height;
17      protected String spriteName;
18      protected Stage stage;
19      protected SpriteCache spriteCache;
20      
21      public Actor(Stage stage) {
22        this.stage = stage;
23        spriteCache = stage.getSpriteCache();
24      }
25      
26      public void paint(Graphics2D g){
27        g.drawImage( spriteCache.getSprite(spriteName), x,y, stage );
28      }
29      
30      public int getX()  { return x; }
31      public void setX(int i) { x = i; }
32    
33      public int getY() { return y; }
34      public void setY(int i) { y = i; }
35      
36      public String getSpriteName() { return spriteName; }
37      public void setSpriteName(String string) { 
38        spriteName = string;
39        BufferedImage image = spriteCache.getSprite(spriteName);
40        height = image.getHeight();
41        width = image.getWidth();
42      }     
43      
44      public int getHeight() { return height; }
45      public int getWidth() { return width; }
46      public void setHeight(int i) {height = i; }
47      public void setWidth(int i) { width = i;  }
48    
49      public void act() { }
50    }
51    

1     /**
2      * Curso Básico de desarrollo de Juegos en Java - Space Invaders
3      * 
4      * (c) 2004 Planetalia S.L. - Todos los derechos reservados. Prohibida su reproducción
5      * 
6      * http://www.planetalia.com
7      * 
8      */
9     
10    package version13;
11    public class Monster extends Actor {
12      protected int vx;
13      
14      public Monster(Stage stage) {
15        super(stage);
16        setSpriteName("bicho.gif");
17      }
18      
19      public void act() {
20        x+=vx;
21        if (x < 0 || x > Stage.WIDTH)
22          vx = -vx;
23      }
24    
25      public int getVx() { return vx; }
26      public void setVx(int i) {vx = i; }
27    
28    }
29    

1     package version13;
2     /**
3      * Curso Básico de desarrollo de Juegos en Java - Invaders
4      * 
5      * (c) 2004 Planetalia S.L. - Todos los derechos reservados. Prohibida su reproducción
6      * 
7      * http://www.planetalia.com
8      * 
9      */
10    
11    import java.awt.Canvas;
12    import java.awt.Color;
13    import java.awt.Dimension;
14    import java.awt.Graphics2D;
15    import java.awt.event.WindowAdapter;
16    import java.awt.event.WindowEvent;
17    import java.awt.image.BufferStrategy;
18    import java.util.ArrayList;
19    
20    import javax.swing.JFrame;
21    import javax.swing.JPanel;
22    
23    public class Invaders extends Canvas implements Stage {
24      
25      private BufferStrategy strategy;
26      private long usedTime;
27      
28      private SpriteCache spriteCache;
29      private ArrayList actors; 
30      
31      public Invaders() {
32        spriteCache = new SpriteCache();
33    
34        JFrame ventana = new JFrame("Invaders");
35        JPanel panel = (JPanel)ventana.getContentPane();
36        setBounds(0,0,Stage.WIDTH,Stage.HEIGHT);
37        panel.setPreferredSize(new Dimension(Stage.WIDTH,Stage.HEIGHT));
38        panel.setLayout(null);
39        panel.add(this);
40        ventana.setBounds(0,0,Stage.WIDTH,Stage.HEIGHT);
41        ventana.setVisible(true);
42        ventana.addWindowListener( new WindowAdapter() {
43          public void windowClosing(WindowEvent e) {
44            System.exit(0);
45          }
46        });
47        ventana.setResizable(false);
48        createBufferStrategy(2);
49        strategy = getBufferStrategy();
50        requestFocus();
51      }
52      
53      public void initWorld() {
54        actors = new ArrayList();
55        for (int i = 0; i < 10; i++){
56          Monster m = new Monster(this);
57          m.setX( (int)(Math.random()*Stage.WIDTH) );
58          m.setY( i*20 );
59          m.setVx( (int)(Math.random()*20-10) );
60          actors.add(m);
61        }
62      }
63      
64      public void updateWorld() {
65        for (int i = 0; i < actors.size(); i++) {
66          Actor m = (Actor)actors.get(i);
67          m.act();
68        }
69      }
70      
71      public void paintWorld() {
72        Graphics2D g = (Graphics2D)strategy.getDrawGraphics();
73        g.setColor(Color.black);
74        g.fillRect(0,0,getWidth(),getHeight());
75        for (int i = 0; i < actors.size(); i++) {
76          Actor m = (Actor)actors.get(i);
77          m.paint(g);
78        }
79    
80        g.setColor(Color.white);
81        if (usedTime > 0)
82          g.drawString(String.valueOf(1000/usedTime)+" fps",0,Stage.HEIGHT-50);
83        else
84          g.drawString("--- fps",0,Stage.HEIGHT-50);
85        strategy.show();
86      }
87      
88      public SpriteCache getSpriteCache() {
89        return spriteCache;
90      }
91      
92      public void game() {
93        usedTime=1000;
94        initWorld();
95        while (isVisible()) {
96          long startTime = System.currentTimeMillis();
97          updateWorld();
98          paintWorld();
99          usedTime = System.currentTimeMillis()-startTime;
100         try { 
101            Thread.sleep(SPEED);
102         } catch (InterruptedException e) {}
103       }
104     }
105     
106     public static void main(String[] args) {
107       Invaders inv = new Invaders();
108       inv.game();
109     }
110   }
111