Graphics?????

[colin shuker]

Hi people, I've written a chess program (almost), but dont have
any graphical simulation of the board, the program just gives
the move. I want to look start work on graphics, but dont know
how, I've not come acrpss them yet. Any ideas/links of where
to go to do this???

[Ilja Preuss]

Moving to Game Development...

[Craig Wood]

Of course there are a lot of ways of going about this. Here's one way to do the gui part that uses a font. You can download the font from
http://www.dafont.com/en/search.php?nq=1&q=chess+alpha
You can also use the font to make up your own set of images, either at runtime or to save as local files.

import java.awt.*;
import java.awt.event.*;
import java.awt.font.*;
import java.awt.geom.*;
import javax.swing.*;
import javax.swing.event.MouseInputAdapter;
 
public class ChessGame
{
    public ChessGame()
    {
        ChessBoard chessBoard = new ChessBoard();
        TokenMover tokenMover = new TokenMover(chessBoard);
        chessBoard.addMouseListener(tokenMover);
        chessBoard.addMouseMotionListener(tokenMover);
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(chessBoard);
        f.setSize(500,500);
        f.setLocation(200,200);
        f.setVisible(true);
    }
 
    public static void main(String[] args)
    {
        new ChessGame();
    }
}
 
class ChessBoard extends JPanel
{
    Font font;
    Dimension tokenSize;
    Token[] tokens;
    final int
        GRID_SIZE = 8,
        PAD       = 20;
 
    public ChessBoard()
    {
        font = new Font("chess alpha", Font.PLAIN, 36);
    }
 
    protected void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        double w = getWidth();
        double h = getHeight();
        double xInc = (w - 2*PAD) / GRID_SIZE;
        double yInc = (h - 2*PAD) / GRID_SIZE;
        double x1 = PAD, y1 = PAD, x2 = w - PAD, y2 = h - PAD;
        // grid lines - horizontal
        for(int j = 0; j <= GRID_SIZE; j++)
        {
            g2.draw(new Line2D.Double(x1, y1, x2, y1));
            y1 += yInc;
        }
        // vertical
        y1 = PAD;
        for(int j = 0; j <= GRID_SIZE; j++)
        {
            g2.draw(new Line2D.Double(x1, y1, x1, y2));
            x1 += xInc;
        }
        // tokens
        g2.setFont(font);
        if(tokens == null)
            initTokens(g2, xInc, yInc);
        for(int j = 0; j < tokens.length; j++)
            tokens[j].draw(g2);
    }
 
    public Token[] getTokens()
    {
        return tokens;
    }
 
    private void initTokens(Graphics2D g2, double xInc, double yInc)
    {
        String[][] key = {                               //         white  black
            { "r", "h", "b", "q", "k", "b", "h", "r" },  // pawn      p      o
            { "p", "p", "p", "p", "p", "p", "p", "p" },  // rook      r      t
            { "o", "o", "o", "o", "o", "o", "o", "o" },  // knight    h      j
            { "t", "j", "n", "w", "l", "j", "n", "t" }   // bishop    b      n
        };                                               // queen     q      w
        tokens = new Token[4 * GRID_SIZE];               // king      k      l
 
        FontRenderContext frc = g2.getFontRenderContext();
        Rectangle2D r = font.getStringBounds("k", frc);
        Dimension d = new Dimension((int)r.getWidth(), (int)r.getHeight());
        double x = PAD + (xInc - r.getWidth())/2;
        double y = PAD + (yInc + r.getHeight())/2;
        String s;
        int index, rowIndex;
        for(int row = 0; row < GRID_SIZE; row++)
        {
            for(int col = 0; col < GRID_SIZE; col++)
            {
                if(row < 2)
                    rowIndex = row;
                else if(row > 5)
                    rowIndex = row - key.length;
                else                           // tokens in rows 0, 1, 6, 7 only
                    continue;
                s = key[rowIndex][col];
                index = rowIndex * GRID_SIZE + col;
                tokens[index] = new Token(s, x, y, d);
                x += xInc;
            }
            x = PAD + (xInc - r.getWidth())/2;
            y += yInc;
        }
    }
 
    public void reset()
    {
        tokens = null;
        repaint();
    }
}
 
class TokenMover extends MouseInputAdapter
{
    ChessBoard chessBoard;
    Token selectedToken;
    Point2D.Double offset;
    boolean dragging;
 
    public TokenMover(ChessBoard cb)
    {
       chessBoard = cb;
       offset = new Point2D.Double();
       dragging = false;
    }
 
    public void mousePressed(MouseEvent e)
    {
        Point p = e.getPoint();
        Token[] tokens = chessBoard.getTokens();
        for(int j = 0; j < tokens.length; j++)
            if(tokens[j].contains(p))
            {
                selectedToken = tokens[j];
                offset.x = p.x - tokens[j].x;
                offset.y = p.y - tokens[j].y;
                dragging = true;
                break;
            }
        if(e.getClickCount() == 2)
            chessBoard.reset();
    }
 
    public void mouseReleased(MouseEvent e)
    {
        dragging = false;
        // update model state
    }
 
    public void mouseDragged(MouseEvent e)
    {
        if(dragging)
        {
            double x = e.getX() - offset.x;
            double y = e.getY() - offset.y;
            selectedToken.setLocation(x, y);
            chessBoard.repaint();
        }
    }
}
 
class Token
{
    String value;
    double x, y;
    Rectangle r;
 
    public Token(String s, double x, double y, Dimension size)
    {
        value = s;
        this.x = x;
        this.y = y;
        r = new Rectangle(size);
    }
 
    public void draw(Graphics2D g2)
    {
        g2.drawString(value, (float)x, (float)y);
    }
 
    public boolean contains(Point p)
    {
        r.setFrame(x, y - r.height, r.width, r.height);
        if(r.contains(p))
            return true;
        return false;
    }
 
    public void setLocation(double x, double y)
    {
        this.x = x;
        this.y = y;
    }
}

[colin shuker]

Thanks very very very much. It's not quite I want I want, but it's a great
start, and hopefully I can figure out how to get pictures of pieces, and then get them to move according to the String that represents the move.
I like the way the cursor works as well, Great Stuff!!!