计算机软件实习每日学习打卡(5)20201218

实验序号：实验二
实验名称：贪吃蛇的游戏开发
实验要求：
1）实现贪吃蛇游戏基本功能，屏幕上随机出现一个“食物”，称为豆子，上下左右
控制“蛇”的移动，吃到“豆子”以后“蛇”的身体加长一点,得分增加，“蛇”碰到边界或，
蛇头与蛇身相撞，蛇死亡，游戏结束。为游戏设计初始欢迎界面，游戏界面，游戏
结束界面。

2）进行交互界面的设计，要有开始键、暂停键和停止退出的选项。对蛇吃到豆子进
行分值计算，可以设置游戏速度，游戏音乐等拓展元素。

3）选做： ① AI 贪吃蛇，结合 A
*算法和适当的策略，设计能吃满屏的贪吃蛇。
AI 贪食蛇演示视频：https://img-blog.csdn.net/20140227095522171

② 俄罗斯方块游戏的设计与开发，俄罗斯方块的基本规则是，随机生成
不同类型的方块，支持其移动，旋转和摆放，使排列成完整的一行或多行消除得分。

日志：
1.完成的部分:目前已完成符合要求的1.0版本
2.代码如下:

package experiment2;

import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Random;
import java.awt.*;

class Yard extends Frame{
	
	private boolean flag = true;
	
	private static final long serialVersionUID = 1L;
	public static final int ROWS = 20;
	public static final int COLS = 20;
	public static final int BLOCK_SIZE = 30;
	
	private int score = 0;
	
	Snake s = new Snake(this);
	Egg e = new Egg();
	
	Image offScreenImage = null;
	
	public int getScore() {
		return score;
	}

	public void setScore(int score) {
		this.score = score;
	}

	public void launch() {
		this.setLocation(500,100);
		this.setSize(60+ROWS * BLOCK_SIZE,80+COLS * BLOCK_SIZE);
		this.addWindowListener(new WindowAdapter() {
			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		this.setVisible(true);
		this.addKeyListener(new KeyMoitor());
		this.setTitle("贪吃蛇测试");
		
		new Thread(new PaintThread()).start();
	}
	
	public void stop() {
		flag = false;
	}
	
	@Override
	public void paint(Graphics g) {
		Color c =g.getColor();
		g.setColor(Color.PINK);
		g.fillRect(30,50,ROWS * BLOCK_SIZE,COLS * BLOCK_SIZE);
		g.setColor(Color.black);
		//画出横线
		for(int i=1; i<ROWS+2; i++) {
			g.drawLine(30 , 20+BLOCK_SIZE * i, 30+COLS * BLOCK_SIZE, 20+BLOCK_SIZE * i);
		}
		//画出竖线
		for(int i=1; i<COLS+2; i++) {
			g.drawLine(BLOCK_SIZE * i, 50 , BLOCK_SIZE * i, 50+COLS * BLOCK_SIZE);
		}
		g.setColor(Color.BLUE);
		g.setFont(new Font("宋体",Font.PLAIN, 20));
		g.drawString("score:"+score, 10, 50);
		g.setColor(c);
		
		s.eat(e);
		e.draw(g);
		s.draw(g);
		if(s.welcome() == true) {
			g.setColor(Color.BLUE);
			g.setFont(new Font("宋体",Font.BOLD, 50));
			g.drawString("欢迎游玩本游戏", 160, 200);
			g.setFont(new Font("宋体",Font.BOLD, 25));
			g.drawString("按方向键开始", 400, 240);
		}
		if(flag == false) {
			g.setColor(Color.BLUE);
			g.setFont(new Font("宋体",Font.BOLD, 70));
			g.drawString("游戏结束", 160, 200);
		}
	}
	
	//缓冲
	@Override
	public void update(Graphics g) {
		if(offScreenImage == null) {
			offScreenImage = this.createImage(60+ROWS*BLOCK_SIZE,80+COLS*BLOCK_SIZE);
		}
		Graphics gOff = offScreenImage.getGraphics();
		paint(gOff);
		g.drawImage(offScreenImage, 0, 0, null);
	}
	
	//线程
	private class PaintThread implements Runnable{
		
		public void run(){
			while(flag) {
				repaint();
				try {
					Thread.sleep(200);
				}
				catch(InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	private class KeyMoitor extends KeyAdapter{
		@Override
		public void keyPressed(KeyEvent e) {
			s.keyPressed(e);
		}
	}
}

class Snake {
	private Node head = null;
	private Node tail = null;
	private int size = 3;
	private Node n = new Node(9, 5, Dir.R);
	private Yard y;
	private boolean welcome = true;
	
	public Snake(Yard y) {
		Node node = null;
		head = n;
		node = new Node(head.row,head.col - 1,head.dir) ;
		head.next = node;
		node.prev = head;
		tail = new Node(head.row,head.col - 2,head.dir) ;
		node.next = tail;
		tail.prev = node;
		size = 3;
		this.y = y;
		head.dir = Dir.N;
	}

	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;
		case N:
			break;
		}
		node.next = head;
		head.prev = node;
		head = node;
	}
	
	public boolean welcome() {
		welcome = false;
		if(head.dir == Dir.N) {
			welcome = true;
		}
		return welcome;
	}
	
	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() {
		if(head.dir != Dir.N) {
			addToHead();
			deleteFromTail();
			cheakDead();
		}
	}
	
	private void cheakDead() {
		if(head.row<0 ||head.row >= Yard.ROWS||head.col<0||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() {
		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.R;
		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(30+Yard.BLOCK_SIZE * col,50+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.N)
			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;
		}
	}
}

class Egg{
	int row,col;
	int w = Yard.BLOCK_SIZE;
	int h = Yard.BLOCK_SIZE;
	private static Random r = new Random();
	
	public Egg(int row, int col) {
		this.row = row;
		this.col = col;
	}
	
	public Egg() {
		this(r.nextInt(Yard.ROWS),r.nextInt(Yard.COLS));
	}
	
	public void reAppear() {
		this.row = r.nextInt(Yard.ROWS);
		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.GREEN);
		g.fillRect(30+Yard.BLOCK_SIZE * col,50+Yard.BLOCK_SIZE * row, w, h);
		
	}
}

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

public class greedySnake {
	
	public static void main(String[] args) {
		new Yard().launch();
	}
}

3实例如下

5 .明天的目标：
1.完成实验三

学习的资料

《Java程序设计教程》机械工业出版社 程科 潘磊主编 ISBN 978-7-111-50902-8
B站视频BV1TJ411L742

20201218