第一阶段 16GUI贪吃蛇

//Dir.java

public enum Dir {
 L, U, R, D
}

 

//Egg.java

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.util.Random;

public class Egg {
 int row, col;
 int w = Yard.BLOCK_SIZE;
 int h = Yard.BLOCK_SIZE;
 private static Random r = new Random();
 private Color color = Color.GREEN;

 public Egg(int row, int col) {
  this.row = row;
  this.col = col;
 }
 
 public Egg() {
  this(r.nextInt(Yard.ROWS-2) + 2, r.nextInt(Yard.COLS));
 }
 
 public void reAppear() {
  this.row = r.nextInt(Yard.ROWS-2) + 2;
  this.col = r.nextInt(Yard.COLS);
 }
 
 public Rectangle getRect() {
  return new Rectangle(Yard.BLOCK_SIZE * col, Yard.BLOCK_SIZE * row, w, h);
 }
 
 public void draw(Graphics g) {
  Color c = g.getColor();
  g.setColor(color);
  g.fillOval(Yard.BLOCK_SIZE * col, Yard.BLOCK_SIZE * row, w, h);
  g.setColor(c);
  if(color == Color.GREEN) color = Color.RED;
  else color = Color.GREEN;
 }

 public int getCol() {
  return col;
 }

 public void setCol(int col) {
  this.col = col;
 }

 public int getRow() {
  return row;
 }

 public void setRow(int row) {
  this.row = row;
 }
 
}

 

//Snake.java

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;

public class Snake {
 private Node head = null;
 private Node tail = null;
 private int size = 0;
 
 private Node n = new Node(20, 30, Dir.L);
 private Yard y;
 
 public Snake(Yard y) {
  head = n;
  tail = n;
  size = 1;
  this.y = y;
 }
 
 public void addToTail() {
  Node node = null;
  switch(tail.dir) {
  case L :
   node = new Node(tail.row, tail.col + 1, tail.dir);
   break;
  case U :
   node = new Node(tail.row + 1, tail.col, tail.dir);
   break;
  case R :
   node = new Node(tail.row, tail.col - 1, tail.dir);
   break;
  case D :
   node = new Node(tail.row - 1, tail.col, tail.dir);
   break;
  }
  tail.next = node;
  node.prev = tail;
  tail = node;
  size ++;
 }
 
 public void addToHead() {
  Node node = null;
  switch(head.dir) {
  case L :
   node = new Node(head.row, head.col - 1, head.dir);
   break;
  case U :
   node = new Node(head.row - 1, head.col, head.dir);
   break;
  case R :
   node = new Node(head.row, head.col + 1, head.dir);
   break;
  case D :
   node = new Node(head.row + 1, head.col, head.dir);
   break;
  }
  node.next = head;
  head.prev = node;
  head = node;
  size ++;
 }
 
 public void draw(Graphics g) {
  if(size <= 0) return;
  move();
  for(Node n = head; n != null; n = n.next) {
   n.draw(g);
  }
 }
 
 private void move() {
  addToHead();
  deleteFromTail();
  checkDead();
 }

 private void checkDead() {
  if(head.row < 2 || head.col < 0 || head.row > Yard.ROWS || head.col > Yard.COLS)  {
   y.stop();
  }
  
  for(Node n = head.next; n != null; n = n.next) {
   if(head.row == n.row && head.col == n.col) {
    y.stop();
   }
  }
 }

 private void deleteFromTail() {
  if(size == 0) return;
  tail = tail.prev;
  tail.next = null;
  
 }

 private class Node {
  int w = Yard.BLOCK_SIZE;
  int h = Yard.BLOCK_SIZE;
  int row , col;
  Dir dir = Dir.L;
  Node next = null;
  Node prev = null;
  
  Node(int row, int col, Dir dir) {
   this.row = row;
   this.col = col;
   this.dir = dir;
  }
  
  void draw(Graphics g) {
   Color c = g.getColor();
   g.setColor(Color.BLACK);
   g.fillRect(Yard.BLOCK_SIZE * col, Yard.BLOCK_SIZE * row, w, h);
   g.setColor(c);
  }
 }
 
 public void eat(Egg e) {
  if(this.getRect().intersects(e.getRect())) {
   e.reAppear();
   this.addToHead();
   y.setScore(y.getScore() + 5);
  }
 }
 
 private Rectangle getRect() {
  return new Rectangle(Yard.BLOCK_SIZE * head.col, Yard.BLOCK_SIZE * head.row, head.w, head.h);
 }
 
 public void keyPressed(KeyEvent e) {
  int key = e.getKeyCode();
  switch(key) {
  case KeyEvent.VK_LEFT :
   if(head.dir != Dir.R)
    head.dir = Dir.L;
   break;
  case KeyEvent.VK_UP :
   if(head.dir != Dir.D)
    head.dir = Dir.U;
   break;
  case KeyEvent.VK_RIGHT :
   if(head.dir != Dir.L)
    head.dir = Dir.R;
   break;
  case KeyEvent.VK_DOWN :
   if(head.dir != Dir.U)
    head.dir = Dir.D;
   break;
  }
 }
}

 

//Yard.java

import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class Yard extends Frame {

 PaintThread paintThread = new PaintThread();
 private boolean gameOver = false; 
 public static final int ROWS = 30;
 public static final int COLS = 30;
 public static final int BLOCK_SIZE = 15;
 
 private Font fontGameOver = new Font("ËÎÌå", Font.BOLD, 50);
 
 private int score = 0;
 
 Snake s = new Snake(this);
 Egg e = new Egg();
 
 Image offScreenImage = null;
 
 public void launch() {
  this.setLocation(200, 200);
  this.setSize(COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE);
  this.addWindowListener(new WindowAdapter() {

   @Override
   public void windowClosing(WindowEvent e) {
    System.exit(0);
   }
   
  });
  this.setVisible(true);
  this.addKeyListener(new KeyMonitor());
  
  new Thread(paintThread).start();
 }
 
 public static void main(String[] args) {
  new Yard().launch();
 }
 
 public void stop() {
  gameOver = true;
 }
 
 @Override
 public void paint(Graphics g) {
  Color c = g.getColor();
  g.setColor(Color.GRAY);
  g.fillRect(0, 0, COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE);
  g.setColor(Color.DARK_GRAY);
  for(int i=1; i<ROWS; i++) {
   g.drawLine(0, BLOCK_SIZE * i, COLS * BLOCK_SIZE, BLOCK_SIZE * i);
  }
  for(int i=1; i<COLS; i++) {
   g.drawLine(BLOCK_SIZE * i, 0, BLOCK_SIZE * i, BLOCK_SIZE * ROWS);
  }
  
  g.setColor(Color.YELLOW);
  g.drawString("score:" + score, 10, 60);
  
  if(gameOver) {
   g.setFont(fontGameOver);
   g.drawString("ÓÎÏ·½áÊø", 120, 180);
   
   paintThread.pause();
  }
  
  g.setColor(c);
  
  s.eat(e);
  e.draw(g);
  s.draw(g);
  
  
 }
 
 @Override
 public void update(Graphics g) {
  if(offScreenImage == null) {
   offScreenImage = this.createImage(COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE);
  }
  Graphics gOff = offScreenImage.getGraphics();
  paint(gOff);
  g.drawImage(offScreenImage, 0, 0,  null);
 }
 
 private class PaintThread implements Runnable {
  private boolean running = true;
  private boolean pause = false;
  public void run() {
   while(running) {
    if(pause) continue;
    else repaint();
    
    try {
     Thread.sleep(100);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
   }
  }
  
  public void pause() {
   this.pause = true;
  }
  
  public void reStart() {
   this.pause = false;
   s = new Snake(Yard.this);
   gameOver = false;
  }
  
  public void gameOver() {
   running = false;
  }
  
 }
 
 private class KeyMonitor extends KeyAdapter {

  @Override
  public void keyPressed(KeyEvent e) {
   int key = e.getKeyCode();
   if(key == KeyEvent.VK_F2) {
    paintThread.reStart();
   }
   s.keyPressed(e);
  }
  
 }
 
 public int getScore() {
  return score;
 }
 
 public void setScore(int score) {
  this.score = score;
 }

}