Macteki Guide on Java Programming: 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

Macteki Guide on Java Programming

Pages

Friday, February 20, 2015

The Game of Klotski

Introduction

Compile and Run

Source Code

No comments:

Post a Comment