Moving Objects and Sprite Manager - Part 10

This is part 10 of the series. You are suggested to read the whole series from the beginning. You may find the whole series in the Featured page.

The Game of Space Invader

Attribution

"Space Ship Shooter Pixel Art Assets" by ansimuz / CC0
You may download the file space_shooter_pack.zip at opengameart.org.

Compile and Run

You will need Scroller.java, Sprite.java, ShipSprite.java, EnemySprite.java, FireboltSprite.java, ExplosionSprite.java, LaserSprite.java and space_shooter_pack.zip Place everything in the same folder and type:

javac *.java
java Scroller

Scroller.java

/****************************************************************************** * File : Scroller.java * Author : Ivan Macteki @ http://java.macteki.com/ * Description : * A simplified version of the game of Space Invader * required space_shooter_pack.zip, Sprite.java, ShipSprite.java, * EnemySprite.java, FireboltSprite.java, ExplosionSprite.java, LaserSprite.java * Compile and Run : * javac *.java * java Scroller * Tested with : OpenJDK 1.8 * Attribution : * "Space Ship Shooter Pixel Art Assets" by ansimuz / CC0 * http://opengameart.org/content/space-ship-shooter-pixel-art-assets ******************************************************************************/ import java.awt.image.BufferedImage; import java.util.ArrayList; import java.awt.event.KeyListener; import javax.swing.SwingUtilities; class Scroller extends javax.swing.JPanel implements KeyListener { // image object for double buffering private BufferedImage drawingBoard; BufferedImage backgroundImage; ShipSprite ship; ArrayList<EnemySprite> enemyList=new ArrayList<>(); BufferedImage laserImage; ArrayList<LaserSprite> laserList=new ArrayList<>(); BufferedImage explosionImage; ArrayList<ExplosionSprite> explosionList=new ArrayList<>(); ArrayList<FireboltSprite> boltList=new ArrayList<>(); double scale=2; // the original artwork is a bit small, scale it up public Scroller() throws Exception { // read background image, the traditional way // String jpeg_file="background.jpg"; // backgroundImage = javax.imageio.ImageIO.read(new java.io.File(jpeg_file)); // read background image from a zip file backgroundImage = readZipImage("space_shooter_pack.zip", "space_shooter_pack/backgrounds/desert-backgorund-looped.png"); // set panel size to dimension of background image int w=backgroundImage.getWidth(this); int h=backgroundImage.getHeight(this)/2; int sw=(int)(w*scale); int sh=(int)(h*scale); setPreferredSize(new java.awt.Dimension(sw,sh)); // resize the drawing board to fit the background drawingBoard=new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB); } // Read a image from the zip file. // e.g. zipFileName="space_shooter_pack.zip"; // imageFileName="space_shooter_pack/backgrounds/desert-backgorund-looped.png" BufferedImage readZipImage(String zipFileName, String imageFileName) throws Exception { java.awt.Image image=null; java.util.zip.ZipInputStream zip = new java.util.zip.ZipInputStream(new java.io.FileInputStream( zipFileName)); java.util.zip.ZipEntry file; while ((file = zip.getNextEntry()) != null) { if (file.getName().equals(imageFileName)) { image = javax.imageio.ImageIO.read(zip); } } // copy the image to a BufferedImage so that we can directly access its pixel array // see scrollImage() for details int w=image.getWidth(null); int h=image.getHeight(null); int type=BufferedImage.TYPE_INT_ARGB; BufferedImage bufImage=new BufferedImage(w, h, type); bufImage.getGraphics().drawImage(image,0,0,null); return bufImage; } // repaint the panel, everything is scaled up here @Override // JPanel public void paintComponent(java.awt.Graphics gr) { int w=drawingBoard.getWidth(null); int h=drawingBoard.getHeight(null); int sw=(int)(w*scale); int sh=(int)(h*scale); gr.drawImage(drawingBoard,0,0,sw,sh,0,0,w,h,this); } public void scrollImage(BufferedImage image) { int w=image.getWidth(null); int h=image.getHeight(null); int[] pixels = ((java.awt.image.DataBufferInt) image.getRaster().getDataBuffer()).getData(); // save the bottomRow of the image before scrolling down int[] bottomRow = new int[w]; System.arraycopy(pixels, (h-1)*w, bottomRow, 0, w); // scrolling down by one row System.arraycopy(pixels, 0, pixels, w, w*(h-1)); // copy the bottom row to the top row System.arraycopy(bottomRow, 0, pixels, 0, w); } int MAX_FIRE=1; int lastFire=0; boolean autoFire=false; boolean readyToFire() { if (ship==null) return false; if (!autoFire) return laserList.size()<MAX_FIRE; else { return ((lastFire++%10)==0); } } void fire() { LaserSprite laser=new LaserSprite(laserImage); laser.x=ship.x; laser.y=ship.y; laserList.add(laser); } java.util.Random random=new java.util.Random(); boolean readyToFire(EnemySprite enemy) { // for example, if one enemy left, the probability of fire is 1/5 // if 3 enemies left, the probability of fire is 1/20 int[] probability=new int[] {0,5,10,20,40,80,160,320,640,1000, 1000,1000,1000,1000,1000,1000,1000}; return (random.nextInt(probability[enemyList.size()])==0); } void fire(EnemySprite enemy) { FireboltSprite bolt=new FireboltSprite(laserImage); bolt.x=enemy.x+10; bolt.y=enemy.y+8; boltList.add(bolt); } void explode(int x, int y) { ExplosionSprite explosion=new ExplosionSprite(explosionImage); explosion.x=x; explosion.y=y; explosionList.add(explosion); } boolean hitEnemy(LaserSprite laser) { for (int i=0;i<enemyList.size();i++) { EnemySprite enemy=enemyList.get(i); if (laser.hit(enemy)) { explode(laser.x,laser.y); enemyList.remove(i); return true; } } return false; } boolean hitShip(FireboltSprite bolt) { if (ship!=null) { if (bolt.hit(ship)) { explode(bolt.x,bolt.y); ship = null; return true; } } return false; } private void animateFrame() { control(); // player control java.awt.Graphics2D gr=(java.awt.Graphics2D) drawingBoard.getGraphics(); gr.drawImage(backgroundImage,0,0,this); scrollImage(backgroundImage); // note: we must draw the background before drawing any sprite if (ship!=null) { ship.animate(); ship.draw(gr); } else gr.drawString("GAME OVER",90,150); for (EnemySprite enemy:enemyList) { enemy.animate(); enemy.draw(gr); if (readyToFire(enemy)) fire(enemy); } if (enemyList.size()==0 && ship!=null) { gr.drawString(" CLEAR ",90,150); } // we cannot call remove() in a for each loop just like the enemyList above // hence we use and index for loop for (int i=0;i<laserList.size();i++) { LaserSprite laser=laserList.get(i); laser.animate(); laser.draw(gr); if (hitEnemy(laser) || // destroy enemy laser.y<5) // reach screen top { laserList.remove(i); } } for (int i=0;i<boltList.size();i++) { FireboltSprite bolt=boltList.get(i); bolt.animate(); bolt.draw(gr); if (hitShip(bolt) || // destroy ship bolt.y>drawingBoard.getHeight(null)) // reach screen bottom { boltList.remove(i); } } for (int i=0;i<explosionList.size();i++) { ExplosionSprite explosion=explosionList.get(i); explosion.animate(); explosion.draw(gr); if (explosion.gesture==4) explosionList.remove(i); } repaint(); } public void start() throws Exception { ship = new ShipSprite(readZipImage("space_shooter_pack.zip", "space_shooter_pack/spritesheets/ship.png")); ship.x=drawingBoard.getWidth(null)/2-10; ship.y=drawingBoard.getHeight(null)-30; BufferedImage enemyImage=readZipImage("space_shooter_pack.zip", "space_shooter_pack/spritesheets/enemy-medium.png"); laserImage=readZipImage("space_shooter_pack.zip", "space_shooter_pack/spritesheets/laser-bolts.png"); explosionImage=readZipImage("space_shooter_pack.zip", "space_shooter_pack/spritesheets/explosion.png"); // add first row of enemy for (int i=0;i<5;i++) { EnemySprite enemy = new EnemySprite(enemyImage); enemy.x=30+40*i; enemy.y=30; enemy.direction=0; // LEFT enemyList.add(enemy); } // add second row of enemy for (int i=0;i<6;i++) { EnemySprite enemy = new EnemySprite(enemyImage); enemy.x=16+40*i; enemy.y=60; enemy.direction=0; // LEFT enemyList.add(enemy); } // add third row of enemy for (int i=0;i<5;i++) { EnemySprite enemy = new EnemySprite(enemyImage); enemy.x=30+40*i; enemy.y=90; enemy.direction=0; // LEFT enemyList.add(enemy); } this.addKeyListener(this); // call animateFrame() for every 30ms javax.swing.Timer timer=new javax.swing.Timer(30, (e)->animateFrame()); timer.start(); } boolean spacePressed=false; boolean leftPressed=false; boolean rightPressed=false; @Override // KeyListener public void keyPressed(java.awt.event.KeyEvent e) { if (e.getKeyCode()==32) spacePressed=true; if (e.getKeyCode()==37) leftPressed=true; if (e.getKeyCode()==39) rightPressed=true; //System.out.println(e); } @Override // KeyListener public void keyReleased(java.awt.event.KeyEvent e) { //System.out.println(e); if (e.getKeyCode()==32) spacePressed=false; if (e.getKeyCode()==37) leftPressed=false; if (e.getKeyCode()==39) rightPressed=false; } @Override // KeyListener public void keyTyped(java.awt.event.KeyEvent e) { //System.out.println(e); } void control() { if (ship==null) return; // already GAME OVER int w=backgroundImage.getWidth(null); if (leftPressed && ship.x>0) ship.setDirection(ship.LEFT); else if (rightPressed && ship.x<w-16) ship.setDirection(ship.RIGHT); else ship.setDirection(ship.UP); if (spacePressed && readyToFire()) fire(); } private void _init() throws Exception { javax.swing.JFrame window=new javax.swing.JFrame(); window.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE); window.setTitle("Macteki Scroller Demonstration"); Scroller scroller=this; window.add(scroller); window.pack(); window.setLocation(0,0); window.setVisible(true); window.addKeyListener(scroller); scroller.start(); } public void init() { try { _init(); } catch (Exception e) { e.printStackTrace(); } } public static void main(String[] args) throws Exception { Scroller scroller=new Scroller(); SwingUtilities.invokeLater( ()->scroller.init() ); } } // end Scroller.java

EnemySprite.java

/****************************************************************************** * File : EnemySprite.java * Author : Ivan Macteki @ http://java.macteki.com/ * Description : * A Sprite object for the Enemy Ship * Tested with : OpenJDK 1.8 ******************************************************************************/ class EnemySprite extends Sprite { public static final int LEFT=0,RIGHT=1,DOWN=2,UP=3; // pre-defined source regions private int[][][] frameRect = // [direction][gesture][x,y,w,h] { {{ 0, 0,32,16}, {32,0,32,16} }, // left {{ 0, 0,32,16}, {32,0,32,16} }, // right {{ 0, 0,32,16}, {32,0,32,16} }, // down {{ 0, 0,32,16}, {32,0,32,16} } // up }; int animationFrame; int animationWait=20; int gesture; @Override // Sprite public int[] getImageBound(int direction, int gesture) { return frameRect[direction][gesture]; } public EnemySprite(java.awt.image.BufferedImage img) { super(img); } // all enemies are moving in the same direction, hence use a "static" variable static int direction=LEFT; public void animate() { animationFrame++; if (animationFrame % animationWait==0) // control when to do self animation { gesture=(gesture+1)% frameRect[0].length; } // if any one of the enemy hit the left hand side, all enemies start moving right if (x<=0) direction=RIGHT; // if any one of the enemy hit the right hand side, all enemies start moving left if (x>=225) direction=LEFT; // The hardcode of 225 is ugly, but it works for this simple demonstration. // A better idea is to pass the viewport dimension in the constructor of EnemySprite. // This is so simple that I would leave it as an exercise for readers. if ((animationFrame % 4)==0) { if (direction==0) x--; // LEFT if (direction==1) x++; // RIGHT } } int getPixel(int x,int y) { int[] srcBounds = this.getImageBound(direction,gesture); int sx=srcBounds[0], sy=srcBounds[1]; return image.getRGB(sx+x,sy+y); } public void draw(java.awt.Graphics2D gr) { // draw sprite at new position int[] srcBounds=getImageBound(direction,gesture); int w=srcBounds[2], h=srcBounds[3]; int dx2=x+w; int dy2=y+h; int sx1=srcBounds[0], sy1=srcBounds[1], sx2=sx1+w, sy2=sy1+h; gr.drawImage(image,x,y,dx2,dy2,sx1,sy1,sx2,sy2,null); } } // end EnemySprite.java

FireboltSprite.java

/****************************************************************************** * File : FireboltSprite.java * Author : Ivan Macteki @ http://java.macteki.com/ * Description : * A Sprite object for the Enemy firebolt * Tested with : OpenJDK 1.8 ******************************************************************************/ class FireboltSprite extends Sprite { public static final int LEFT=0,RIGHT=1,DOWN=2,UP=3; // pre-defined source regions private int[][][] frameRect = // [direction][gesture][x,y,w,h] { {{ 0, 0,16,16}, {14,0,16,16} }, // left {{ 0, 0,16,16}, {14,0,16,16} }, // right {{ 0, 0,16,16}, {14,0,16,16} }, // down {{ 0, 0,16,16}, {14,0,16,16} } // up }; int animationFrame; int animationWait=20; int moveWait=1; int gesture; @Override // Sprite public int[] getImageBound(int direction, int gesture) { return frameRect[direction][gesture]; } public FireboltSprite(java.awt.image.BufferedImage img) { super(img); } int direction=DOWN; public void animate() { animationFrame++; if (animationFrame % animationWait==0) // control when to do self animation { gesture=(gesture+1)% frameRect[0].length; } if (animationFrame % moveWait==0) // control when to move { y+=2; } } public void draw(java.awt.Graphics2D gr) { // draw sprite at new position int[] srcBounds=getImageBound(direction,gesture); int w=srcBounds[2], h=srcBounds[3]; int dx2=x+w; int dy2=y+h; int sx1=srcBounds[0], sy1=srcBounds[1], sx2=sx1+w, sy2=sy1+h; gr.drawImage(image,x,y,dx2,dy2,sx1,sy1,sx2,sy2,null); } int getPixel(int x,int y) { int[] srcBounds = this.getImageBound(direction,gesture); int sx=srcBounds[0], sy=srcBounds[1]; return image.getRGB(sx+x,sy+y); } boolean hit(ShipSprite sprite) { int[] sourceBounds = this.getImageBound(0,0); int[] targetBounds = sprite.getImageBound(0,0); int w1=sourceBounds[2]; int h1=sourceBounds[3]; int w2=targetBounds[2]; int h2=targetBounds[3]; // For non-overlapping bounding rect, just return false if (this.x+w1 < sprite.x) return false; if (this.x > sprite.x+w2) return false; if (this.y+h1 < sprite.y) return false; if (this.y > sprite.y+h2) return false; // bounding rectange overlap, we may compare pixel by pixel for exact match // or just return true for a coarse match boolean coarse=false; if (coarse) return true; // do pixel by pixel comparison in the overlap region // find overlapped region with respect to the source sprite (this) int ulx=0,uly=0; int ow=w1, oh=h1; // overlapped width, overlapped height if (this.x<=sprite.x) ulx=sprite.x-this.x; if (this.y<=sprite.y) uly=sprite.y-this.y; if (this.x+w1>=sprite.x+w2) ow=sprite.x+w2-this.x; if (this.y+h1>=sprite.y+h2) oh=sprite.y+h2-this.y; ow-=ulx; oh-=uly; // find overlapped region with respect to the target sprite int ulx2=0,uly2=0; if (sprite.x<=this.x) ulx2=this.x-sprite.x; if (sprite.y<=this.y) uly2=this.y-sprite.y; for (int r=0;r<oh;r++) { for (int c=0;c<ow;c++) if (getPixel(ulx+c,uly+r)!=0 && sprite.getPixel(ulx2+c,uly2+r)!=0) { return true; } } return false; } } // end FireboltSprite.java

ExplosionSprite.java

/****************************************************************************** * File : ExplosionSprite.java * Author : Ivan Macteki @ http://java.macteki.com/ * Description : * A Sprite object for the explosion animation * Tested with : OpenJDK 1.8 ******************************************************************************/ class ExplosionSprite extends Sprite { public static final int LEFT=0,RIGHT=1,DOWN=2,UP=3; // pre-defined source regions private int[][][] frameRect = // [direction][gesture][x,y,w,h] { {{ 0, 0,16,16}, {16,0,16,16},{32,0,16,16},{48,0,16,16},{64,0,16,16} }, // left {{ 0, 0,16,16}, {16,0,16,16},{32,0,16,16},{48,0,16,16},{64,0,16,16} }, // right {{ 0, 0,16,16}, {16,0,16,16},{32,0,16,16},{48,0,16,16},{64,0,16,16} }, // down {{ 0, 0,16,16}, {16,0,16,16},{32,0,16,16},{48,0,16,16},{64,0,16,16} } // up }; int animationFrame; int animationWait=4; int moveWait=1; int gesture; @Override // Sprite public int[] getImageBound(int direction, int gesture) { return frameRect[direction][gesture]; } public ExplosionSprite(java.awt.image.BufferedImage img) { super(img); } int direction=UP; public void animate() { animationFrame++; if (animationFrame % animationWait==0) // control when to do self animation { gesture=(gesture+1)% frameRect[0].length; } } public void draw(java.awt.Graphics2D gr) { // draw sprite at new position int[] srcBounds=getImageBound(direction,gesture); int w=srcBounds[2], h=srcBounds[3]; int dx2=x+w; int dy2=y+h; int sx1=srcBounds[0], sy1=srcBounds[1], sx2=sx1+w, sy2=sy1+h; gr.drawImage(image,x,y,dx2,dy2,sx1,sy1,sx2,sy2,null); } } // end ExplosionSprite.java

LaserSprite.java

/****************************************************************************** * File : LaserSprite.java * Author : Ivan Macteki @ http://java.macteki.com/ * Description : * A Sprite object for the laser bolt * Tested with : OpenJDK 1.8 ******************************************************************************/ class LaserSprite extends Sprite { public static final int LEFT=0,RIGHT=1,DOWN=2,UP=3; // pre-defined source regions private int[][][] frameRect = // [direction][gesture][x,y,w,h] { {{ 0, 16,16,16}, {14,16,16,16} }, // left {{ 0, 16,16,16}, {14,16,16,16} }, // right {{ 0, 16,16,16}, {14,16,16,16} }, // down {{ 0, 16,16,16}, {14,16,16,16} } // up }; int animationFrame; int animationWait=4+16; int moveWait=1; int gesture; @Override // Sprite public int[] getImageBound(int direction, int gesture) { return frameRect[direction][gesture]; } public LaserSprite(java.awt.image.BufferedImage img) { super(img); } int direction=UP; public void animate() { animationFrame++; if (animationFrame % animationWait==0) // control when to do self animation { gesture=(gesture+1)% frameRect[0].length; } if (animationFrame % moveWait==0) // control when to move { y-=2; } } public void draw(java.awt.Graphics2D gr) { // draw sprite at new position int[] srcBounds=getImageBound(direction,gesture); int w=srcBounds[2], h=srcBounds[3]; int dx2=x+w; int dy2=y+h; int sx1=srcBounds[0], sy1=srcBounds[1], sx2=sx1+w, sy2=sy1+h; gr.drawImage(image,x,y,dx2,dy2,sx1,sy1,sx2,sy2,null); } int getPixel(int x,int y) { int[] srcBounds = this.getImageBound(direction,gesture); int sx=srcBounds[0], sy=srcBounds[1]; return image.getRGB(sx+x,sy+y); } boolean hit(EnemySprite sprite) { int[] sourceBounds = this.getImageBound(0,0); int[] targetBounds = sprite.getImageBound(0,0); int w1=sourceBounds[2]; int h1=sourceBounds[3]; int w2=targetBounds[2]; int h2=targetBounds[3]; // For non-overlapping bounding rect, just return false if (this.x+w1 < sprite.x) return false; if (this.x > sprite.x+w2) return false; if (this.y+h1 < sprite.y) return false; if (this.y > sprite.y+h2) return false; // bounding rectange overlap, we may compare pixel by pixel for exact match // or just return true for a coarse match boolean coarse=false; if (coarse) return true; // do pixel by pixel comparison in the overlap region // find overlapped region with respect to the source sprite (this) int ulx=0,uly=0, ow=w1, oh=h1; if (this.x<=sprite.x) ulx=sprite.x-this.x; if (this.y<=sprite.y) uly=sprite.y-this.y; if (this.x+w1>=sprite.x+w2) ow=sprite.x+w2-this.x; if (this.y+h1>=sprite.y+h2) oh=sprite.y+h2-this.y; ow-=ulx; oh-=uly; // find overlapped region with respect to the target sprite int ulx2=0,uly2=0; if (sprite.x<=this.x) ulx2=this.x-sprite.x; if (sprite.y<=this.y) uly2=this.y-sprite.y; for (int r=0;r<oh;r++) { for (int c=0;c<ow;c++) if (getPixel(ulx+c,uly+r)!=0 && sprite.getPixel(ulx2+c,uly2+r)!=0) { return true; } } return false; } } // end LaserSprite.java

ShipSprite.java

/****************************************************************************** * File : ShipSprite.java * Author : Ivan Macteki @ http://java.macteki.com/ * Description : * A Sprite object for the Space Ship * Tested with : OpenJDK 1.8 ******************************************************************************/ class ShipSprite extends Sprite { public static final int LEFT=0,RIGHT=1,DOWN=2,UP=3; // pre-defined source regions private int[][][] frameRect = // [direction][gesture][x,y,w,h] { {{16, 0,16,24}, {16,24,16,24}, { 0, 0,16,24}, { 0,24,16,24} }, // left {{48, 0,16,24}, {48,24,16,24}, {64, 0,16,24}, {64,24,16,24} }, // right { { 32, 0,16,24}, {32,24,16,24} }, // down { { 32, 0,16,24}, {32,24,16,24} } // up }; int animationFrame; int animationWait=8; // change "gesture" on every 8 frames int gesture; @Override // Sprite public int[] getImageBound(int direction, int gesture) { return frameRect[direction][gesture]; } public ShipSprite(java.awt.image.BufferedImage img) { super(img); } int direction=UP; public void animate() { animationFrame++; if (animationFrame % animationWait==0) // control when to do self animation { gesture=(gesture+1)% frameRect[direction].length; // if moving up, use the animation sequence {0,1,0,1,0,1,0,1,0,1,...} if (direction==LEFT || direction==RIGHT) { // otherwise, use the animation sequence {0,1,2,3,2,3,2,3,2,3,...} if (gesture==3) gesture=2; } } if (direction==LEFT) x--; if (direction==RIGHT) x++; } void setDirection(int d) { if (d!=direction) { direction=d; gesture=0; } } int getPixel(int x,int y) { int[] srcBounds = this.getImageBound(direction,gesture); int sx=srcBounds[0], sy=srcBounds[1]; return image.getRGB(sx+x,sy+y); } public void draw(java.awt.Graphics2D gr) { // draw sprite at new position int[] srcBounds=getImageBound(direction,gesture); int w=srcBounds[2], h=srcBounds[3]; int dx2=x+w; int dy2=y+h; int sx1=srcBounds[0], sy1=srcBounds[1], sx2=sx1+w, sy2=sy1+h; gr.drawImage(image,x,y,dx2,dy2,sx1,sy1,sx2,sy2,null); } } // end ShipSprite.java

Sprite.java

/****************************************************************************** * File : Sprite.java * Author : http://java.macteki.com/ * Description : * The sprite object * Tested with : OpenJDK 1.8 ******************************************************************************/ import java.awt.image.BufferedImage; class Sprite { public BufferedImage image=null; // image of the sprite // initial coordinates and velocity of the sprite public int x=50, y=250; private int xv=2; private int yv=0; private int animationFrame=0; // incremented for every frame. private int gesture=0; // animation gesture (0-3) public int relativeSpeed=2; // update position at every 2 frames (moving half slower) public int gestureWait=8; // update animation gesture at every 8 frames java.util.Random random=new java.util.Random(); // pre-defined source regions private int[][][] frameRect = // [direction][gesture][x,y,w,h] { {{ 0, 0,32,32}, {32, 0,32,32}, {64, 0,32,32}, {96, 0,32,32} }, // left {{ 0,32,32,32}, {32,32,32,32}, {64,32,32,32}, {96,32,32,32} }, // right {{ 0,64,32,32}, {32,64,32,32}, {64,64,32,32}, {96,64,32,32} }, // down {{ 0,96,32,32}, {32,96,32,32}, {64,96,32,32}, {96,96,32,32} } // up }; public Sprite(BufferedImage img) { this.image = makeTransparent(img); } public BufferedImage makeTransparent(BufferedImage tmpImage) { int h=tmpImage.getHeight(null); int w=tmpImage.getWidth(null); BufferedImage resultImage=new BufferedImage(w,h,BufferedImage.TYPE_INT_ARGB); // assume the upperleft corner of the original image is a transparent pixel int transparentColor=tmpImage.getRGB(0,0); for (int y=0;y<h;y++) for (int x=0;x<w;x++) { int color=tmpImage.getRGB(x,y); if (color==transparentColor) color=color & 0x00FFFFFF; // clear the alpha flag resultImage.setRGB(x,y,color); } return resultImage; } // activeRegion is defined by corners coordinates (x1,y1) and (x2,y2) public int[] getActiveRegion() { // upperLeft corner(x,y), lowerRight corner(x,y) return new int[]{ 0,250,750,440}; // lower area of the screen. } public void move() { animationFrame++; if (animationFrame % relativeSpeed==0) // control when to update the position { int bored=random.nextInt(200); if (bored==1) // the sprite is bored for 0.5% of the time { // if it feels bored, it changes direction int[] xvTable={-2,2,0,0}; int[] yvTable={0,0,2,-2}; int dir = random.nextInt(4); xv=xvTable[dir]; yv=yvTable[dir]; } // move sprite to new position x+=xv; y+=yv; // get Sprite dimension int w=frameRect[0][0][2]; // 32 int h=frameRect[0][0][3]; // 32 int rightBound=getActiveRegion()[2]; int leftBound=getActiveRegion()[0]; int upperBound=getActiveRegion()[1]; int lowerBound=getActiveRegion()[3]; if (x>rightBound-w || x<leftBound) // hit border { x-=xv; // undo movement xv=-xv; // change direction of velocity } if (y>lowerBound-h || y<upperBound) // don't move too high or too low { y-=yv; // undo movement yv=-yv; // change direction of velocity } } if (animationFrame % gestureWait==0) // control when to update gesture { gesture=(gesture+1)%4; } } public int[] getImageBound(int direction, int gesture) { return frameRect[direction][gesture]; } public void draw(java.awt.Graphics2D gr) { // draw sprite at new position int direction=0; if (xv>0) direction=1; else if (xv<0) direction=0; if (yv>0) direction=2; else if (yv<0) direction=3; int[] srcBounds=getImageBound(direction,gesture); int w=srcBounds[2], h=srcBounds[3]; int dx2=x+w; int dy2=y+h; int sx1=srcBounds[0], sy1=srcBounds[1], sx2=sx1+w, sy2=sy1+h; gr.drawImage(image,x,y,dx2,dy2,sx1,sy1,sx2,sy2,null); } } // end Sprite.java