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

Macteki Guide on Java Programming

Pages

Saturday, February 28, 2015

Moving Objects and Sprite Manager - Part 9

A sprite in a scrolling background

Compile and Run

Scroller.java

ShipSprite.java

Sprite.java

No comments:

Post a Comment