import java.awt.*;
　　import java.awt.event.*;
　　import javax.swing.*;
　　import java.util.*;
　　
　　public class greedsnake implements keylistener{
　　　jframe mainframe;
　　　canvas paintcanvas;
　　　jlabel labelscore;
　　　snakemodel snakemodel = null;
　　
　　　public static final int canvaswidth = 200;
　　　public static final int canvasheight = 300;
　　
　　　public static final int nodewidth = 10;
　　　public static final int nodeheight = 10;
　　
　　　public greedsnake() {
　　　　mainframe = new jframe("greedsnake");
　　
　　　　container cp = mainframe.getcontentpane();
　　　
　　　　labelscore = new jlabel("score:");
　　　　cp.add(labelscore, borderlayout.north);
　　
　　　　paintcanvas = new canvas();
　　　　paintcanvas.setsize(canvaswidth+1,canvasheight+1);
　　　　paintcanvas.addkeylistener(this);
　　　　cp.add(paintcanvas, borderlayout.center);
　　
　　　　jpanel panelbuttom = new jpanel();
　　　　panelbuttom.setlayout(new borderlayout());
　　　　jlabel labelhelp;
　　　　labelhelp = new jlabel("pageup, pagedown for speed;", jlabel.center);
　　　　panelbuttom.add(labelhelp, borderlayout.north);
　　　　labelhelp = new jlabel("enter or r or s for start;", jlabel.center);
　　　　panelbuttom.add(labelhelp, borderlayout.center);
　　　　labelhelp = new jlabel("space or p for pause",jlabel.center);
　　　　panelbuttom.add(labelhelp, borderlayout.south);
　　　　cp.add(panelbuttom,borderlayout.south);
　　
　　　　mainframe.addkeylistener(this);
　　　　mainframe.pack();
　　　　mainframe.setresizable(false);
　　　　mainframe.setdefaultcloseoperation(jframe.exit_on_close);
　　　　mainframe.setvisible(true);
　　　　begin();
　　　}
　　
　　　public void keypressed(keyevent e){
　　　　int keycode = e.getkeycode();
　　　　if (snakemodel.running)
　　　　　switch(keycode){
　　　　　　case keyevent.vk_up:
　　　　　　　snakemodel.changedirection(snakemodel.up);
　　　　　　　break;
　　　　　　case keyevent.vk_down:
　　　　　　　snakemodel.changedirection(snakemodel.down);
　　　　　　　break;
　　　　　　case keyevent.vk_left:
　　　　　　　snakemodel.changedirection(snakemodel.left);
　　　　　　　break;
　　　　　　case keyevent.vk_right:
　　　　　　　snakemodel.changedirection(snakemodel.right);
　　　　　　　break;
　　　　　　case keyevent.vk_add:
　　　　　　case keyevent.vk_page_up:
　　　　　　　snakemodel.speedup();
　　　　　　　break;
　　　　　　case keyevent.vk_subtract:
　　　　　　case keyevent.vk_page_down:
　　　　　　　snakemodel.speeddown();
　　　　　　　break;
　　　　　　case keyevent.vk_space:
　　　　　　case keyevent.vk_p:
　　　　　　　snakemodel.changepausestate();
　　　　　　　break;
　　　　　　default:
　　　　　}
　　
　　　　if (keycode == keyevent.vk_r ||
　　　　　　keycode == keyevent.vk_s ||
　　　　　　keycode == keyevent.vk_enter){
　　　　　snakemodel.running = false;
　　　　　begin();
　　　　}
　　　}
　　
　　　public void keyreleased(keyevent e){
　　　}
　　
　　　public void keytyped(keyevent e){
　　　}
　　
　　
　　　void repaint(){
　　　　graphics g = paintcanvas.getgraphics();
　　
　　　　//draw background
　　　　g.setcolor(color.white);
　　　　g.fillrect(0,0,canvaswidth,canvasheight);
　　
　　　　// draw the snake
　　　　g.setcolor(color.black);
　　　　linkedlist na = snakemodel.nodearray;
　　　　iterator it = na.iterator();
　　　　while(it.hasnext()){
　　　　　node n = (node)it.next();
　　　　　drawnode(g,n);
　　　　}
　　
　　　　// draw the food
　　　　g.setcolor(color.red);
　　　　node n = snakemodel.food;
　　　　drawnode(g,n);
　　　　
　　　　updatescore();
　　　}
　　
　　　private void drawnode(graphics g, node n){
　　　　g.fillrect(n.x*nodewidth,
　　　　　　　　　 n.y*nodeheight,
　　　　　　　　　 nodewidth-1,
　　　　　　　　　 nodeheight-1);
　　　}
　　　
　　　public void updatescore(){
　　　　string s = "score: " + snakemodel.score;
　　　　labelscore.settext(s);
　　　}
　　
　　　void begin(){
　　　　if (snakemodel == null || !snakemodel.running){
　　　　　snakemodel = new snakemodel(this,
　　　　　　　　　　　　　　　　　　　canvaswidth/nodewidth,
　　　　　　　　　　　　　　　　　　　canvasheight/nodeheight);
　　　　　(new thread(snakemodel)).start();
　　　　}
　　　}
　　
　　　public static void main(string[] args){
　　　　greedsnake gs = new greedsnake();
　　　}
　　}
　　
　　///////////////////////////////////////////////////
　　// 文件2
　　///////////////////////////////////////////////////
　　
　　import java.util.*;
　　import javax.swing.*;
　　
　　class snakemodel implements runnable{
　　　greedsnake gs;
　　　boolean[][] matrix;
　　　linkedlist nodearray = new linkedlist();
　　　node food;
　　　int maxx;
　　　int maxy;
　　　int direction = 2;
　　　boolean running = false;
　　
　　　int timeinterval = 200;
　　　double speedchangerate = 0.75;
　　　boolean paused = false;
　　　
　　　int score = 0;
　　　int countmove = 0;
　　
　　　// up and down should be even
　　　// right and left should be odd
　　　public static final int up = 2;
　　　public static final int down = 4;
　　　public static final int left = 1;
　　　public static final int right = 3;
　　
　　　public snakemodel(greedsnake gs, int maxx, int maxy){
　　　　this.gs = gs;
　　　　this.maxx = maxx;
　　　　this.maxy = maxy;
　　
　　　　// initial matirx
　　　　matrix = new boolean[maxx][];
　　　　for(int i=0; i<maxx; ++i){
　　　　　matrix[i] = new boolean[maxy];
　　　　　arrays.fill(matrix[i],false);
　　　　}
　　
　　　　// initial the snake
　　　　int initarraylength = maxx > 20 ? 10 : maxx/2;
　　　　for(int i = 0; i < initarraylength; ++i){
　　　　　int x = maxx/2+i;
　　　　　int y = maxy/2;
　　　　　nodearray.addlast(new node(x, y));
　　　　　matrix[x][y] = true;
　　　　}
　　
　　　　food = createfood();
　　　　matrix[food.x][food.y] = true;
　　　}
　　
　　　public void changedirection(int newdirection){
　　　　if (direction % 2 != newdirection % 2){
　　　　　direction = newdirection;
　　　　}
　　　}
　　
　　　public boolean moveon(){
　　　　node n = (node)nodearray.getfirst();
　　　　int x = n.x;
　　　　int y = n.y;
　　
　　　　switch(direction){
　　　　　case up:
　　　　　　y--;
　　　　　　break;
　　　　　case down:
　　　　　　y++;
　　　　　　break;
　　　　　case left:
　　　　　　x--;
　　　　　　break;
　　　　　case right:
　　　　　　x++;
　　　　　　break;
　　　　}
　　
　　　　if ((0 <= x && x < maxx) && (0 <= y && y < maxy)){
　　　　　if (matrix[x][y]){
　　　　　　if(x == food.x && y == food.y){
　　　　　　　nodearray.addfirst(food);
　　　　　　　
　　　　　　　int scoreget = (10000 - 200 * countmove) / timeinterval;
　　　　　　　score += scoreget > 0? scoreget : 10;
　　　　　　　countmove = 0;
　　　　　　　
　　　　　　　food = createfood();
　　　　　　　matrix[food.x][food.y] = true;
　　　　　　　return true;
　　　　　　}
　　　　　　else
　　　　　　　return false;
　　　　　}
　　　　　else{
　　　　　　nodearray.addfirst(new node(x,y));
　　　　　　matrix[x][y] = true;
　　　　　　n = (node)nodearray.removelast();
　　　　　　matrix[n.x][n.y] = false;
　　　　　　countmove++;
　　　　　　return true;