Sunday, April 5, 2015

Simple Wave File Player

Introduction

This post presents a simple Wave File Player written in Java, using the sampled sound API. Since we are not using JavaFX, it will not support the mp3 format.

Import

We will be using API from the javax.sound.sampled package. Hence we make the following imports at the beginning of the program.

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;

Progress bar

We will use a JSlider as a progress bar. The scale are from 0 to 10000, which is simple to represent 0 to 100% with two decimal place. To update the progress, the following method will be invoked by a Swing Timer on every 30ms.

Sample Wave File

  epic_loop.wav : Orchestral Adventure by RevampedPRO, CC BY 3.0 license 
                  http://opengameart.org/content/orchestral-adventure 

  twoTone2.wav : "63 Digital sound effects" by Kenney, CC0 license, 
    http://opengameart.org/content/63-digital-sound-effects-lasers-phasers-space-etc

The wave files are inside a github project. Follow the following link to download the project as a zip file.
https://github.com/macteki/WavePlayer

Source Code

Saturday, February 28, 2015

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

Moving Objects and Sprite Manager - Part 9

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

A sprite in a scrolling background

Compile and Run

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

javac *.java
java Scroller

You may download the file space_shooter_pack.zip at opengameart.org.

The Java source file are listed below.

Scroller.java


/******************************************************************************
* File : Scroller.java
* Author : Ivan Macteki @ http://java.macteki.com/
* Description :
*   Scroller demonstration with a ship sprite
*   required space_shooter_pack.zip, Sprite.java, ShipSprite.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 javax.swing.SwingUtilities;
  
class Scroller extends javax.swing.JPanel
{
  
  // image object for double buffering
  private BufferedImage drawingBoard;
  
  BufferedImage backgroundImage;

  ShipSprite ship;

  double scale=2; // the original artwork is a bit small, scale it up
  
  public Scroller() throws Exception
  {
  
    // 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);

  }


  
  private void animateFrame()
  {
    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 the sprite
    ship.animate();
    ship.draw(gr);

    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;

    // call animateFrame() for every 30ms
    javax.swing.Timer timer=new javax.swing.Timer(30, (e)->animateFrame());
    timer.start();
  }
  

  public void init()
  {
    try {
      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.setVisible(true);

      scroller.start();
    } catch (Exception e)
    {
      e.printStackTrace();
    }
  }

  public static void main(String[] args) throws Exception
  {
    Scroller scroller=new Scroller();
    SwingUtilities.invokeLater( ()->scroller.init() );
  }
   
} // end Scroller.java

ShipSprite.java


/******************************************************************************
* File : ShipSprite.java
* Author : Ivan Macteki @ http://java.macteki.com/
* Description :
*   A Sprite object for the spaceship
* 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[] directionLoop=new int[]{UP,LEFT,UP,RIGHT,UP,RIGHT,UP,LEFT}; 
  int directionIndex=0;
  int direction=directionLoop[directionIndex];


  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 (animationFrame % 80==0) // change direction on every 80 frame
    {
      direction=directionLoop[directionIndex];
      directionIndex=(directionIndex+1) % directionLoop.length;
      gesture=0;
    }


    if (direction==LEFT) x--; 
    if (direction==RIGHT) x++; 
    
  }



  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

This is the same as the file Sprite.java in "Moving Objects and Sprite Manager Part 6".


/******************************************************************************
* File : Sprite.java
* Author : Ivan Macteki @ 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

Friday, February 27, 2015

Moving Objects and Sprite Manager - Part 8

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

Scrolling Background

We will use a looping background created by ansimuz.

You may find the original collection at :
http://opengameart.org/content/space-ship-shooter-pixel-art-assets

The author release the file under the CC0 license. In summary, the license allow you to use it in your own game, even for commercial purpose.

You may download the file space_shooter_pack.zip

We will use the file desert-backgorund-looped.png inside the zip file.

This is a looping background. That means if we cut the bottom row of the image, and then paste it to the top, we still have a continuous image. Hence the scrolling is as simple as: Note that we are using the same technique in Optimized flood filler to access the pixel array of the image. This is much faster than the getPixel() and setPixel() API.

Reading image from zip file

We will read directly from the zip file so that we don't need to uncompress the file to the harddrive. The source code for reading zip file is defined in readZipImage() in the demonstration. The reason to read directly from zip file is that we may redistribute other people artwork in an unmodified form. This typically fulfill most of the license requirement in http://opengameart.org.

Important
There are many free artworks available in opengameart.org. However, you must read the license of the individual entry before using it. Not every entry is released under CC0. Different authors may submit their work under different licenses. For example, many licenses require you to attribute the original author. Just like what I am doing below :

"Space Ship Shooter Pixel Art Assets" by ansimuz / CC0

You may have a look at Best Practices for attribution

Demonstration

You will need Scroller.java and space_shhoter_pack.zip in the same folder.

Compile and run

javac Scroller.java
java Scroller

/******************************************************************************
* File : Scroller.java
* Author : Ivan Macteki @http://java.macteki.com/
* Description :
*   Scroller demonstration.
*   required space_shooter_pack.zip
* Tested with : OpenJDK 1.8
******************************************************************************/
  
import java.awt.image.BufferedImage;
import javax.swing.SwingUtilities;
  
class Scroller extends javax.swing.JPanel
{
  
  // image object for double buffering
  private BufferedImage drawingBoard;
  
  BufferedImage backgroundImage;
  
  public Scroller() throws Exception
  {
  
  // you may read the background image in the traditional way:
  //   String jpeg_file="background.jpg";
  //   backgroundImage = javax.imageio.ImageIO.read(new java.io.File(jpeg_file));
  // However, since our background is stored inside a zip file, we will
  // use our own function readZipImage()

    // 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;
    setPreferredSize(new java.awt.Dimension(w,h));
  
    // create a drawing board with the same size of the panel.
    // this is used in paintComponent() below
    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.BufferedImage 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);
      }
    }

    // the image in the original zip file is a bit small
    double scale=2;  // hence we scale it up by a factor of 2
    int w=image.getWidth(null);
    int h=image.getHeight(null);
    int bigW=(int) (scale*w);
    int bigH=(int) (scale*h);
    int type=BufferedImage.TYPE_INT_ARGB;
    BufferedImage bigImage=new BufferedImage(bigW, bigH, type);
    bigImage.getGraphics().drawImage(image,0,0,bigW, bigH, 0, 0, w, h, null);
    
    return bigImage;
  }
  
  @Override // JPanel
  public void paintComponent(java.awt.Graphics gr)
  {
    gr.drawImage(drawingBoard,0,0,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);

  }
  
  private void animateFrame()
  {
    java.awt.Graphics2D gr=(java.awt.Graphics2D) drawingBoard.getGraphics();
    gr.drawImage(backgroundImage,0,0,this);

    scrollImage(backgroundImage);
    repaint();    
  }
    
  

  void init() 
  {
    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.setVisible(true);

    // call animateFrame() for every 10ms
    javax.swing.Timer timer=new javax.swing.Timer(10, (e)->animateFrame());
    timer.start();
  
  }  
  
  public static void main(String[] args) throws Exception
  {
    Scroller scroller=new Scroller();
    SwingUtilities.invokeLater( ()->scroller.init() );
  }
   
} // end Scroller.java

Friday, February 20, 2015

The Game of Klotski

Introduction

Klotski is a sliding block puzzle.

Compile and Run

javac *.java
java Main

You will need Block.java, BlockList.java, Board.java, Cell.java and Main.java in the same folder.

Source Code


/******************************************************************************
* File : Board.java
* Author : Ivan Macteki @ http://java.macteki.com/
* Description :
*   Define the board size of the game of Klotski
* Tested with : OpenJDK 1.8
******************************************************************************/
class Board
{
  // define a board with WxH cells
  public static final int W=4; 
  public static final int H=5; 
} // end Board.java

/******************************************************************************
* File : Cell.java
* Author : Ivan Macteki @ http://java.macteki.com/
* Description :
*   Define the width and height of a cell in pixels
* Tested with : OpenJDK 1.8
******************************************************************************/
class Cell
{
  static final int W=50;
  static final int H=50;
} // end Cell.java

/******************************************************************************
* File : BlockList.java
* Author : Ivan Macteki @ http://java.macteki.com/
* Description :
*   Define the initial layout of the game of Klotski
* Tested with : OpenJDK 1.8
******************************************************************************/

import java.awt.Color;
import java.awt.Rectangle;

class BlockList
{
    static Block[] blocks = new Block[] {
      new Block(1,0,2,2,Color.RED),
      new Block(0,0,1,2,Color.GREEN),
      new Block(0,2,1,2,Color.GREEN),
      new Block(3,0,1,2,Color.GREEN),
      new Block(3,2,1,2,Color.GREEN),
      new Block(1,2,2,1,Color.YELLOW),
      new Block(1,3,1,1,Color.CYAN),
      new Block(2,3,1,1,Color.CYAN),
      new Block(0,4,1,1,Color.CYAN),
      new Block(3,4,1,1,Color.CYAN)
    };

  static boolean[][] occupied=new boolean[Board.W][Board.H];

  static void rebuildOccupancy()
  {
    for (int i=0;i<Board.W;i++)
      for (int j=0;j<Board.H;j++)
        occupied[i][j]=false;

    for (Block block:blocks)
    {
      Rectangle rect = block.getBounds();
      int ulx = rect.x / Cell.W;
      int uly = rect.y / Cell.H;
      int w = rect.width/Cell.W;
      int h = rect.height/Cell.H;
      for (int i=ulx;i<ulx+w;i++)
        for (int j=uly;j<uly+h;j++)
          occupied[i][j]=true;
    }
  }


} // end BlockList.java

/******************************************************************************
* File : Block.java
* Author : Ivan Macteki @ http://java.macteki.com/
* Description :
*   Define a block object which implements the drag and drop function
* Tested with : OpenJDK 1.8
******************************************************************************/
import javax.swing.JPanel;
import javax.swing.BorderFactory;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseEvent;
import java.awt.Point;
import java.awt.Color;

class Block extends JPanel implements MouseListener,MouseMotionListener
{
  static final int X_AXIS=0, Y_AXIS=1; // direction for moving
  int movingDirection=-1;
  Point startingPoint = new Point();
  Point previousPoint = new Point();

  public Block(int x,int y, int w, int h, Color color)
  {
    JPanel panel=this;
    panel.setBackground(color);
    panel.setBorder(BorderFactory.createRaisedBevelBorder());
    panel.setBounds(x*Cell.W,y*Cell.H,w*Cell.W,h*Cell.H);

    panel.addMouseListener(this);
    panel.addMouseMotionListener(this);
  }

  @Override // MouseListener
  public void mouseExited(MouseEvent e) {}

  @Override // MouseListener
  public void mouseEntered(MouseEvent e) {}

  @Override // MouseListener
  public void mouseReleased(MouseEvent e) 
  {
    int x=this.getX();
    int y=this.getY();
    double xRound = Math.round(x/(double)(Cell.W));
    double yRound = Math.round(y/(double)(Cell.H));
    x = (int) (xRound*Cell.W);
    y = (int) (yRound*Cell.H);

    this.setLocation(x,y);
    BlockList.rebuildOccupancy();

    if (this.getWidth()==Cell.W*2 && this.getHeight()==Cell.H*2
       && this.getX()==Cell.W && this.getY()==Cell.H*3)
    {
      for (Block block:BlockList.blocks) 
      {
        block.removeMouseListener(block);
        block.removeMouseMotionListener(block);
      }
      String message="Congratulations ! Puzzle solved !";
      javax.swing.JOptionPane.showMessageDialog(this, message);
    }

  }

  @Override // MouseListener
  public void mousePressed(MouseEvent e) 
  {
    startingPoint = e.getPoint();
    previousPoint = e.getPoint();
    movingDirection=-1;

    // remove myself from the occupancy array
      java.awt.Rectangle rect = this.getBounds();
      int ulx = rect.x / Cell.W;
      int uly = rect.y / Cell.H;
      int w = rect.width/Cell.W;
      int h = rect.height/Cell.H;
      for (int i=ulx;i<ulx+w;i++)
        for (int j=uly;j<uly+h;j++)
          BlockList.occupied[i][j]=false;


  }

  @Override // MouseListener
  public void mouseClicked(MouseEvent e) {}

  @Override // MouseMotionListener
  public void mouseMoved(MouseEvent e) {}

  @Override // MouseMotionListener
  public void mouseDragged(MouseEvent e) 
  { 
    int dx=e.getX()-previousPoint.x;
    int dy=e.getX()-previousPoint.y;
    previousPoint = e.getPoint();
 
    dx=e.getX()-startingPoint.x;
    dy=e.getY()-startingPoint.y;

    int x=this.getX();
    int y=this.getY();

    // make sure the movement is big enough for determining the moving axis
    if (Math.abs(dx)<5 && Math.abs(dy)<5) return;

    // once you are moving along a certain axis, you can only move along
    // the same axis until the mouse is released
    if (Math.abs(dx)>Math.abs(dy) && movingDirection!=Y_AXIS) 
    {
      for (int i=0;i<Math.abs(dx);i++)
        if (movable(dx/Math.abs(dx),0))
        {
          x += dx/Math.abs(dx); //x += 1 or x += -1
          movingDirection=X_AXIS;
          this.setLocation(x,y);
        }
    }
    if (Math.abs(dy)>Math.abs(dx) && movingDirection!=X_AXIS) 
    {
      for (int i=0;i<Math.abs(dy);i++)
        if (movable(0,dy/Math.abs(dy)))
        {
          y += dy/Math.abs(dy);
          movingDirection=Y_AXIS;
          this.setLocation(x,y);
        }
    }

    // allow to turn 
    if (this.getX() % Cell.W==0 &&
        this.getY() % Cell.H==0) {
      movingDirection=-1;
    }

  }

  boolean movable(int dx, int dy)
  {
    int x=this.getX();
    int y=this.getY();
    int row=this.getHeight()/Cell.H;
    int column=this.getWidth()/Cell.W;

    x+=dx; 
    y+=dy;

    double xRound = Math.round(x/(double)(Cell.W));
    double yRound = Math.round(y/(double)(Cell.H));

    double xFloor = Math.floor(x/(double)(Cell.W));
    double yFloor = Math.floor(y/(double)(Cell.H));

    double xCeil = Math.ceil(x/(double)(Cell.W));
    double yCeil = Math.ceil(y/(double)(Cell.H));

    // (m,n) is the new position in the (5x4) board.
    // depending on the direction, we adjust the position
    // with the floor or the ceiling function

    int m=(int) xRound;
    int n=(int) yRound;  

    if (dx<0) m=(int) xFloor;
    if (dx>0) m=(int) xCeil;

    if (dy<0) n=(int) yFloor;
    if (dy>0) n=(int) yCeil;


    // boundary check
    if (m<0 || n<0) return false;
    if (m+column-1>=Board.W || n+row-1 >= Board.H) return false;

    // if the block is released right here
    // make sure its position is not already occupied
    for (int i=0;i<column;i++)
      for (int j=0;j<row;j++)
        if (BlockList.occupied[m+i][n+j]) return false;

    return true; 
  }
} // end Block.java


/******************************************************************************
* File : Main.java
* Author : Ivan Macteki @ http://java.macteki.com/
* Description :
*   Program entry point of the game of Klotski
* Tested with : OpenJDK 1.8
******************************************************************************/
import javax.swing.SwingUtilities;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.BorderFactory;
import java.awt.Color;

class Main
{
  void init()
  {
    JFrame frame=new JFrame("Klotski");
    
    frame.getContentPane().setPreferredSize(
      new java.awt.Dimension(Board.W*Cell.W,Board.H*Cell.H));
    frame.getContentPane().setLayout(null);

    JPanel panel=new JPanel();   
    panel.setSize(new java.awt.Dimension(Board.W*Cell.W,Board.H*Cell.H));

    panel.setBackground(Color.GRAY);
    panel.setBorder(BorderFactory.createLoweredBevelBorder());
    frame.setLocation(50,100);
    frame.add(panel);
    frame.setResizable(false);
    frame.pack();

    panel.setLayout(null);

    for (Block block : BlockList.blocks) panel.add(block);

    BlockList.rebuildOccupancy();

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setVisible(true);
  }

  public static void main(String[] args) throws Exception
  {
    SwingUtilities.invokeLater( ()->new Main().init() );
  }
} // end Main.java

Simple Drag and Drop

Introduction

We are going to implement a simple drag and drop function. The program will display a red block on the screen and you may drag and drop it to anywhere inside the window.

Mouse Event

For a simple implementation, we just need to implement two functions. One is known as mousePressed and the other is known as mouseDragged. These two functions are defined in two different interfaces. Hence we need to implement both interfaces.

class DragDropTest implements java.awt.event.MouseListener,
                       java.awt.event.MouseMotionListener
{
}

Though we are only interested in two functions, we still need to provide empty implementation for every function defined in MouseListener and MouseMotionListener

  @Override // MouseListener
  public void mouseExited(MouseEvent e) {}

  @Override // MouseListener
  public void mouseEntered(MouseEvent e) {}

  @Override // MouseListener
  public void mouseReleased(MouseEvent e)   {}

  @Override // MouseListener
  public void mouseClicked(MouseEvent e) {}

  @Override // MouseMotionListener
  public void mouseMoved(MouseEvent e) {}

Basic Flow of Drag and Drop

Remember the mouse position when the mouse is pressed. This is the starting point.
When the mouseDragged event is received, calculate a displacement vector from the starting point to the current mouse position.
Add the displacement vector to the position of the object.

The following is the implementation of step 1. All we have to do is just remembering the starting position when mouse is pressed. @Override // MouseListener public void mousePressed(MouseEvent e) { startingPoint.x = e.getX(); startingPoint.y = e.getY(); }

The following is the implementation of step 2 and 3. @Override // MouseMotionListener public void mouseDragged(MouseEvent e) { // compute displacement vector int dx=e.getX()-startingPoint.x; int dy=e.getY()-startingPoint.y; // get position of object int x=redPanel.getX(); int y=redPanel.getY(); // add the displacement vector to the object x += dx; y += dy; redPanel.setLocation(x,y); }

Demonstration

For a full demonstration, compile and run the following source code.

/******************************************************************************
* File : DragDropTest.java
* Author : Ivan Macteki @ http://java.macteki.com/
* Description :
*   A simple test for drag and drop
* Tested with : OpenJDK 1.8
* Version : 1.0
* Compile and run :
*   javac DragDropTest.java
*   java DragDropTest
* Documentation :
*   http://java.macteki.com/2015/02/simple-drag-and-drop.html
******************************************************************************/
 


import javax.swing.SwingUtilities;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.event.MouseEvent;
import java.awt.Point;
import javax.swing.BorderFactory;

class DragDropTest implements java.awt.event.MouseListener,
                       java.awt.event.MouseMotionListener
{

  JPanel redPanel;
  Point startingPoint = new Point();
  
  void init()
  {
    JFrame frame=new JFrame("Drag Drop Test - by Macteki");
    JPanel panel=new JPanel();
    panel.setPreferredSize(new java.awt.Dimension(400,400));
    panel.setBackground(java.awt.Color.CYAN);
    panel.setBorder(BorderFactory.createLoweredBevelBorder());
    frame.setLocation(50,100);
    frame.add(panel);
    frame.pack();

    panel.setLayout(null);
    redPanel=new JPanel();
    redPanel.setBackground(java.awt.Color.RED);
    redPanel.setBorder(BorderFactory.createRaisedBevelBorder());
    redPanel.setBounds(50,50,50,50);
    panel.add(redPanel);

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setVisible(true);

    redPanel.addMouseListener(this);
    redPanel.addMouseMotionListener(this);
  }


  @Override // MouseListener
  public void mouseExited(MouseEvent e) {}

  @Override // MouseListener
  public void mouseEntered(MouseEvent e) {}

  @Override // MouseListener
  public void mouseReleased(MouseEvent e)   {}

  @Override // MouseListener
  public void mousePressed(MouseEvent e) 
  {
    startingPoint.x = e.getX();
    startingPoint.y = e.getY();
  }

  @Override // MouseListener
  public void mouseClicked(MouseEvent e) {}

  @Override // MouseMotionListener
  public void mouseMoved(MouseEvent e) {}

  @Override // MouseMotionListener
  public void mouseDragged(MouseEvent e) 
  { 
    // compute displacement vector
    int dx=e.getX()-startingPoint.x;
    int dy=e.getY()-startingPoint.y;

    // get position of object
    int x=redPanel.getX();
    int y=redPanel.getY();

    // add the displacement vector to the object
    x += dx;
    y += dy;

    redPanel.setLocation(x,y);

  }


  public static void main(String[] args) throws Exception
  {
    SwingUtilities.invokeLater( ()->new DragDropTest().init() );
  }
}  // end DragDropTest.java

Pages

Sunday, April 5, 2015

Simple Wave File Player

Introduction

Import

Progress bar

Sample Wave File

Source Code

Saturday, February 28, 2015

Moving Objects and Sprite Manager - Part 10

The Game of Space Invader

Attribution

Compile and Run

Scroller.java

EnemySprite.java

FireboltSprite.java

ExplosionSprite.java

LaserSprite.java

ShipSprite.java

Sprite.java

Moving Objects and Sprite Manager - Part 9

A sprite in a scrolling background

Compile and Run

Scroller.java

ShipSprite.java

Sprite.java

Friday, February 27, 2015

Moving Objects and Sprite Manager - Part 8

Scrolling Background

Reading image from zip file

Demonstration

Compile and run

Friday, February 20, 2015

The Game of Klotski

Introduction

Compile and Run

Source Code

Simple Drag and Drop

Introduction

Mouse Event

Basic Flow of Drag and Drop

Demonstration