gameframe.java

使用java语言实现的一个简单的游戏

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package SnakeGame;

import java.awt.BorderLayout;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Iterator;
import java.util.LinkedList;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JRadioButtonMenuItem;

/**
 *
 * @author Administrator
 */
public class GameFrame extends JFrame {

    private Toolkit tempKit;
    private int horizontalGrid,  verticalGrid;
    private int singleWidthX,  singleHeightY;
    private int cooPos;
    private Snake mainSnake;
    private LinkedList eatedBean;

    {
        eatedBean = new LinkedList();
    }
    private Iterator snakeSq;
    public javax.swing.Timer snakeTimer;
    private int direction = 2;
    private int score;
    private String info;
    private Point bean,  eatBean;
    {
        bean = new Point();
    }
    private boolean flag;
    private JMenuBar infoMenu;
    private JMenu[] tempMenu;
    private JMenuItem[] tempMenuItem;
    private JRadioButtonMenuItem[] levelMenuItem,  versionMenuItem;
    private JLabel scoreLabel;
    {
        scoreLabel = new JLabel();
    }
    private Graphics2D g;
    private ImageIcon snakeHead;
    {
        snakeHead = new ImageIcon("image/bb.jpg");
    }
    private ConfigMenu configMenu;
    private boolean hasStoped = true;

    public GameFrame() {
        this.tempKit = this.getToolkit();
        this.setSize(tempKit.getScreenSize());
        this.setGrid(60, 40, 5);
        this.getContentPane().setBackground(ColorGroup.COLOR_BACK);
        this.setUndecorated(true);
        this.setResizable(false);
        this.addKeyListener(new KeyHandler());
        GameFrame.this.snakeTimer = new javax.swing.Timer(80, new TimerHandler());
        this.getContentPane().add(scoreLabel, BorderLayout.SOUTH);
        this.scoreLabel.setFont(new Font("Fixedsys", Font.BOLD, 15));
        this.scoreLabel.setText("Pause[SPACE] - Exit[ESC]");
        this.configMenu = new ConfigMenu(this);
        this.setVisible(true);
    }

    public void setGrid(int temp1, int temp2, int temp3) {
        this.horizontalGrid = temp1;
        this.verticalGrid = temp2;
        this.singleWidthX = this.getWidth() / temp1;
        this.singleHeightY = this.getHeight() / temp2;
        this.cooPos = temp3;
    }

    private class KeyHandler extends KeyAdapter {

        @Override
        public void keyPressed(KeyEvent e) {
            if (e.getKeyCode() == 27) {
                snakeTimer.stop();
                if (JOptionPane.showConfirmDialog(null, "Are you sure to exit?") == 0) {
                    System.exit(0);
                }
                snakeTimer.start();
            } else if (e.getKeyCode() == 37 && mainSnake.snakeDirection != 2)//left
            {
                direction = 4;
            } else if (e.getKeyCode() == 39 && mainSnake.snakeDirection != 4)//right
            {
                direction = 2;
            } else if (e.getKeyCode() == 38 && mainSnake.snakeDirection != 3)//up
            {
                direction = 1;
            } else if (e.getKeyCode() == 40 && mainSnake.snakeDirection != 1)//down
            {
                direction = 3;
            } else if (e.getKeyCode() == 32) {
                if (!hasStoped) {
                    if (!flag) {
                        snakeTimer.stop();
                        configMenu.setVisible(true);
                        configMenu.setMenuEnable(false);
                        flag = true;
                    } else {
                        snakeTimer.start();
                       configMenu.setVisible(false);
                        configMenu.setMenuEnable(true);
                        flag = false;
                    }
                }
            }
        }
    }

    private class TimerHandler implements ActionListener {

        public synchronized void actionPerformed(ActionEvent e) {
            Point temp = (Point) mainSnake.getLast();
            snakeSq = mainSnake.iterator();
            while (snakeSq.hasNext()) {
                Point tempPoint = (Point) snakeSq.next();
                if (temp.equals(tempPoint) && snakeSq.hasNext() == true) {
                    snakeTimer.stop();
                    stopGame();
                    JOptionPane.showMessageDialog(null,
                            "Your Score is " + score + "\n\nYou Loss!");
                }
            }
            System.out.println(temp.x + " " + temp.y);
            if ((temp.x == 0 && direction == 4) ||
                    (temp.x == horizontalGrid - 1 && direction == 2) ||
                    (temp.y == 0 && direction == 1) ||
                    (temp.y == verticalGrid - 1 && direction == 3)) {
                snakeTimer.stop();
                stopGame();
                JOptionPane.showMessageDialog(null,
                        "Your Score is " + score + "\n\nYou Loss!");
            }
            if (direction != mainSnake.snakeReDirection) {
                moveSnake(direction);
            }
            mainSnake.drawSnake(getGraphics(), singleWidthX, singleHeightY, cooPos);
            drawBeanAndEBean(getGraphics());
        }
    }

    public void stopGame() {
        this.hasStoped = true;
        this.snakeTimer.stop();
       Graphics2D gg = (Graphics2D) GameFrame.this.getGraphics();
        gg.setColor(ColorGroup.COLOR_BACK);
        super.paint(gg);
        configMenu.setVisible(true);
    }

    public void resetGame() {
        System.gc();
        this.hasStoped = false;
        Graphics2D gg = (Graphics2D) GameFrame.this.getGraphics();
        gg.setColor(ColorGroup.COLOR_BACK);
        super.paint(gg);
        this.mainSnake = new Snake();
        this.createBean(bean);
        this.eatedBean.clear();
        mainSnake.drawSnake(getGraphics(), singleWidthX, singleHeightY, cooPos);
        this.snakeTimer.start();
        this.direction = 2;
        this.score = 0;
        this.scoreLabel.setText("Pause[SPACE] - Exit[ESC]");
    }

    private void moveSnake(int direction) {
        if (mainSnake.checkBeanIn(this.bean)) {
            this.score += 100;
            this.scoreLabel.setText(this.info + " Current Score:" + this.score);
            this.eatedBean.add(new Point(this.bean));
            this.createBean(this.bean);
        }
        mainSnake.changeDirection((Point) mainSnake.getLast(), direction);
        Point temp = (Point) mainSnake.getFirst();
        if (eatedBean.size() != 0) {
            if (eatedBean.getFirst().equals(temp)) {
                eatedBean.remove(0);
            } else {
                mainSnake.clearEndSnakePiece(getGraphics(), temp.x, temp.y,
                        singleWidthX, singleHeightY, cooPos);
                mainSnake.removeTail();
            }
        } else {
            mainSnake.clearEndSnakePiece(getGraphics(), temp.x, temp.y,
                    singleWidthX, singleHeightY, cooPos);
            mainSnake.removeTail();
        }
    }

    private void drawBeanAndEBean(Graphics g) {
        g.setColor(ColorGroup.COLOR_BEAN);
        this.drawPiece(g, this.bean.x, this.bean.y);
        g.setColor(ColorGroup.COLOR_EATEDBEAN);
        snakeSq = eatedBean.iterator();
        while (snakeSq.hasNext()) {
            Point tempPoint = (Point) snakeSq.next();
            this.drawPiece(g, tempPoint.x, tempPoint.y);
        }
    }

    private void drawPiece(Graphics g, int x, int y) {
        g.fillRoundRect(this.singleWidthX * x + 1,
                this.singleHeightY * y + 1,
                this.singleWidthX - 2,
                this.singleHeightY - 2,
                this.cooPos,
                this.cooPos);
    }

    private void createBean(Point temp) {
        LP:
        while (true) {
            temp.x = (int) (Math.random() * this.horizontalGrid);
            temp.y = (int) (Math.random() * this.verticalGrid);
            snakeSq = mainSnake.iterator();
            while (snakeSq.hasNext()) {
                if (snakeSq.next().equals(new Point(temp.x, temp.y))) {
                    continue LP;
                }
            }
            break;
        }
    }
}