植物大战僵尸-C语言搭建童年游戏（easyx）

游戏索引

游戏名称：植物大战僵尸

游戏介绍：

本游戏是在B站博主<程序员Rock>的视频指导下完成

想学的更详细的小伙伴可以移步到<程序员Rock>视频

语言项目：完整版植物大战僵尸！可能是B站最好的植物大战僵尸教程了！零基础手把手游戏开发

游戏效果展示：

植物大战僵尸

游戏模块：

<1>实现最开始的游戏场景
<2>实现游戏顶部的工具栏
<3>实现工具栏的植物卡牌
<4>植物卡牌的选择与拖动
<5>植物的种植
<6>植物的摇摆
<7>制作启动菜单
<10>创建随机阳光
<11>收集阳光显示阳光值
<12>创建僵尸

<13>子弹对僵尸的碰撞

<14>僵尸对植物的碰撞

<15>场景巡场

<16>状态栏下滑

<17>游戏输赢的判断

目录

游戏索引

游戏名称：植物大战僵尸

游戏介绍：

游戏效果展示：

游戏模块：

写代码前的准备工作 

 搭建项目环境easyx：

导入游戏素材 ：

 修改项目属性：

导入我们的辅助项目：

vector2.h

vector2.cpp

tools.h

tools.cpp

导入操作：

 项目所需头文件以及结构体的定义：

 游戏页面的实现：

游戏的背景初始化： 

 判断读取文件是否存在：

将图片显示在窗口上：

 游戏场景动作的实现：

游戏中的阳光操作：

​编辑

<1>创建阳光>:

<2>实现阳光旋转动作>:

<3>实现阳光收集操作>:

游戏中的僵尸操作：

 <1>创建僵尸>:

<2>实现僵尸的动作：

游戏中的豌豆子弹操作：

<1>创建豌豆子弹>:

<2>实现豌豆子弹的动作>:

游戏中植物与僵尸碰撞的实现：

<1>豌豆子弹与僵尸的碰撞检测实现>:

<2>僵尸与植物的碰撞检测实现>:

游戏场景巡场的实现： ​编辑

游戏中状态栏下滑实现 ：

 游戏输赢的判断：

用户的鼠标操作：

 main主菜单：

 代码的整体实现：

素材已上传至百度网盘：

百度网盘 请输入提取码

提取码：ABCD

写代码前的准备工作 

 搭建项目环境easyx：

要想在我们的窗口实现图片交互

应该给编译器安装 easyx 图形库

这边我用图片展示详细的安装操作

（1）我们先在网页找到官网

（2）然后点击下载

（3）将 easyx 安装到目标编译器

（4）出现安装成功就代表可以使用了

接下来我们就可以写放心写代码啦！！！

导入游戏素材 ：

在当前项目的目录下创建文件夹，并把解压好的文件拷贝进去

 修改项目属性：

<1>点击项目找到项目属性

<2>将字符集改成多字符集

这里图片操作的时候需要

<3>将编译器对SDL的检查关掉

这里检查文件是否存在的时候需要

导入我们的辅助项目：

vector2.h

#pragma once

//头文件要求
#include <cmath>

struct vector2 {
	vector2(int _x=0, int _y=0) :x(_x), y(_y) {}
	vector2(int* data) :x(data[0]), y(data[1]){}
	long long x, y;
};

//加法
vector2 operator +(vector2 x, vector2 y);

//减法
vector2 operator -(vector2 x, vector2 y);

// 乘法
vector2 operator *(vector2 x, vector2 y);
vector2 operator *(vector2, float);
vector2 operator *(float, vector2);

//叉积
long long cross(vector2 x, vector2 y);

//数量积 点积
long long dot(vector2 x, vector2 y);

//四舍五入除法
long long dv(long long a, long long b);


//模长平方
long long len(vector2 x);

//模长
long long dis(vector2 x);

//向量除法
vector2 operator /(vector2 x, vector2 y);

//向量膜
vector2 operator %(vector2 x, vector2 y);

//向量GCD 
vector2 gcd(vector2 x, vector2 y);

//贝塞尔曲线
vector2 calcBezierPoint(float t, vector2 p0, vector2 p1, vector2 p2, vector2 p3);

vector2.cpp

//头文件要求
#include <cmath>
#include "vector2.h"

//加法
vector2 operator +(vector2 x, vector2 y) { 
	return vector2(x.x + y.x, x.y + y.y ); 
}

//减法
vector2 operator -(vector2 x, vector2 y) {
	return vector2(x.x - y.x, x.y - y.y);
}

// 乘法
vector2 operator *(vector2 x, vector2 y) {
	return vector2(x.x * y.x - x.y * y.y, x.y * y.x + x.x * y.y);
}

// 乘法
vector2 operator *(vector2 y, float x) {
	return vector2(x*y.x, x*y.y);
}

vector2 operator *(float x, vector2 y) {
	return vector2(x * y.x, x * y.y);
}

//叉积
long long cross(vector2 x, vector2 y) { return x.y * y.x - x.x * y.y; }

//数量积 点积
long long dot(vector2 x, vector2 y) { return x.x * y.x + x.y * y.y; }

//四舍五入除法
long long dv(long long a, long long b) {//注意重名！！！ 
	return b < 0 ? dv(-a, -b)
		: (a < 0 ? -dv(-a, b)
			: (a + b / 2) / b);
}

//模长平方
long long len(vector2 x) { return x.x * x.x + x.y * x.y; }

//模长
long long dis(vector2 x) { return sqrt(x.x * x.x + x.y * x.y); }

//向量除法
vector2 operator /(vector2 x, vector2 y) {
	long long l = len(y);
	return vector2(dv(dot(x, y), l), dv(cross(x, y), l));
}

//向量膜
vector2 operator %(vector2 x, vector2 y) { return x - ((x / y) * y); }

//向量GCD 
vector2 gcd(vector2 x, vector2 y) { return len(y) ? gcd(y, x % y) : x; }

//贝塞尔曲线
vector2 calcBezierPoint(float t, vector2 p0, vector2 p1, vector2 p2, vector2 p3) {
	float u = 1 - t;
	float tt = t * t;
	float uu = u * u;
	float uuu = uu * u;
	float ttt = tt * t;

	vector2 p = uuu * p0;
	p = p + 3 * uu * t * p1;
	p = p + 3 * u * tt * p2;
	p = p + ttt * p3;

	return p;
}

tools.h

#pragma once
#include <graphics.h>

void putimagePNG(int  picture_x, int picture_y, IMAGE* picture);
int getDelay();

tools.cpp

#include "tools.h"

// 载入PNG图并去透明部分
void _putimagePNG(int  picture_x, int picture_y, IMAGE* picture) //x为载入图片的X坐标，y为Y坐标
{
	DWORD* dst = GetImageBuffer();    // GetImageBuffer()函数，用于获取绘图设备的显存指针，EASYX自带
	DWORD* draw = GetImageBuffer();
	DWORD* src = GetImageBuffer(picture); //获取picture的显存指针
	int picture_width = picture->getwidth(); //获取picture的宽度，EASYX自带
	int picture_height = picture->getheight(); //获取picture的高度，EASYX自带
	int graphWidth = getwidth();       //获取绘图区的宽度，EASYX自带
	int graphHeight = getheight();     //获取绘图区的高度，EASYX自带
	int dstX = 0;    //在显存里像素的角标

	// 实现透明贴图 公式： Cp=αp*FP+(1-αp)*BP ， 贝叶斯定理来进行点颜色的概率计算
	for (int iy = 0; iy < picture_height; iy++)
	{
		for (int ix = 0; ix < picture_width; ix++)
		{
			int srcX = ix + iy * picture_width; //在显存里像素的角标
			int sa = ((src[srcX] & 0xff000000) >> 24); //0xAArrggbb;AA是透明度
			int sr = ((src[srcX] & 0xff0000) >> 16); //获取RGB里的R
			int sg = ((src[srcX] & 0xff00) >> 8);   //G
			int sb = src[srcX] & 0xff;              //B
			if (ix >= 0 && ix <= graphWidth && iy >= 0 && iy <= graphHeight && dstX <= graphWidth * graphHeight)
			{
				dstX = (ix + picture_x) + (iy + picture_y) * graphWidth; //在显存里像素的角标
				int dr = ((dst[dstX] & 0xff0000) >> 16);
				int dg = ((dst[dstX] & 0xff00) >> 8);
				int db = dst[dstX] & 0xff;
				draw[dstX] = ((sr * sa / 255 + dr * (255 - sa) / 255) << 16)
					| ((sg * sa / 255 + dg * (255 - sa) / 255) << 8)
					| (sb * sa / 255 + db * (255 - sa) / 255);
			}
		}
	}
}

// 适用于 y <0 以及x<0的任何情况
void putimagePNG(int x, int y, IMAGE* picture) {

	IMAGE imgTmp, imgTmp2, imgTmp3;
	int winWidth = getwidth();
	int winHeight = getheight();
	if (y < 0) {
		SetWorkingImage(picture);
		getimage(&imgTmp, 0, -y,
			picture->getwidth(), picture->getheight() + y);
		SetWorkingImage();
		y = 0;
		picture = &imgTmp;
	}
	else if (y >= getheight() || x >= getwidth()) {
		return;
	}
	else if (y + picture->getheight() > winHeight) {
		SetWorkingImage(picture);
		getimage(&imgTmp, x, y, picture->getwidth(), winHeight - y);
		SetWorkingImage();
		picture = &imgTmp;
	}

	if (x < 0) {
		SetWorkingImage(picture);
		getimage(&imgTmp2, -x, 0, picture->getwidth() + x, picture->getheight());
		SetWorkingImage();
		x = 0;
		picture = &imgTmp2;
	}

	if (x > winWidth - picture->getwidth()) {
		SetWorkingImage(picture);
		getimage(&imgTmp3, 0, 0, winWidth - x, picture->getheight());
		SetWorkingImage();
		picture = &imgTmp3;
	}


	_putimagePNG(x, y, picture);
}

int getDelay() {
	static unsigned long long lastTime = 0;
	unsigned long long currentTime = GetTickCount();
	if (lastTime == 0) {
		lastTime = currentTime;
		return 0;
	}
	else {
		int ret = currentTime - lastTime;
		lastTime = currentTime;
		return ret;
	}
}

导入操作：

<1>点击项目添加现有项

<2>选定我们要添加的辅助项目选择添加就好啦

 项目所需头文件以及结构体的定义：

#include<stdio.h>
#include<graphics.h>
#include"tools.h"
#include<ctime>
#include<time.h>
#include<math.h>
#include"vector2.h"	            //向量工具包
#include<mmsystem.h>	        //音乐
#pragma comment(lib,"winmm.lib")//导入静态库 
enum { WAN_DAO, XIANG_RI_KUI, JIAN_GUO, ZHI_WU_COUNT };	//植物枚举
enum { SUNSHINE_DOWN, SUNSHINE_GROUND, SUNSHINE_COLLECT, SUNSHINE_PRODUCT };  //阳光球状态枚举
enum { GOING, WIN, FAIL };

IMAGE imgBg;	                     //游戏背景图
IMAGE imgBar;	                     //状态栏，放植物的背景板
IMAGE imgCards[ZHI_WU_COUNT];	     //植物卡牌数组
IMAGE* imgZhiWu[ZHI_WU_COUNT][20];	 //植物数组 

int curX, curY;	//当前选中植物在移动中的坐标
int curZhiWu;	//当前选中的植物	

int killZmCount;	//杀掉的僵尸总数
int zmCount;		//生成的僵尸数量
int gameStatus;		//游戏的状态


#define	WIN_WIDTH 900   //定义背景宽度
#define	WIN_HEIGHT 600  //定义背景高度
#define ZM_MAX 10	    //僵尸总数

//植物结构体
struct zhiWu {	
	int type;		
	int frameIndex;	//序列帧的序号
	int shootTimer;	//植物攻击时间间隔
	bool catched;	//植物是否被僵尸捕获
	int deadTimer;	//植物被吃时的死亡倒计时

	int x, y;
	int timer;	//用于向日葵生成阳光的计时器
};
//阳光球结构体
struct sunShineBall {	
	int	x, y;       //阳光球的x、y坐标
	int	frameIndex;	//阳光球序列帧的序号
	int	destY;	    //阳光球停止的y坐标
	bool used;	    //阳光球是否在使用
	int timer;	    //计时器，用来限制阳光球最后的停留时间

	int xoff;	//阳光球归位的x坐标
	int yoff;	//阳光球归位的y坐标
 
	float t;	
	vector2 p1, p2, p3, p4;
	vector2	pCur;	//当前时刻阳光球的位置
	float	speed;
	int	status;    	//阳光球的状态
};

struct sunShineBall	balls[10];	//阳光球池，用来事先存储阳光
IMAGE	imgSunShineBall[29];	//阳光序列帧总数	
//僵尸结构体
struct zm {			
	int x, y;
	int row;
	int frameIndex;
	bool used;
	int speed;	    //僵尸前行速度
	int blood;	    //僵尸血量
	bool dead;	    //僵尸是否死亡
	bool eating;	//僵尸是否在吃植物
};

struct zm zms[10];	//僵尸池,用来事先存储僵尸
IMAGE	imgZm[22];
IMAGE	imgZmDead[20];
IMAGE	imgZmEat[21];
IMAGE	imgZmStand[11];


//豌豆子弹结构体
struct bullet {	
	int x, y, row, speed;
	bool used;
	bool blast;	    //判断是否爆炸
	int frameIndex;	//爆炸帧序号
};
//豌豆子弹池
struct bullet bullets[30];	
IMAGE imgBulletNormal;
IMAGE imgBulletBlast[4];

int ballMax = sizeof(balls) / sizeof(balls[0]);	

int zmMax = sizeof(zms) / sizeof(zms[0]);	             //僵尸池中僵尸的总数

int bulletMax = sizeof(bullets) / sizeof(bullets[0]);  	//豌豆子弹池的总数

struct zhiWu map[3][9];	//地图数组，方便存储植物

int sunShine;	        //阳光值

 游戏页面的实现：

void startUI() {
	mciSendString("play res/audio/bg.mp3", 0, 0, 0);
	IMAGE imgMenu, imgMenu1, imgMenu2;
	int	flag = 0;
	loadimage(&imgMenu, "res/menu.png");	//加载开始背景图
	loadimage(&imgMenu1, "res/menu1.png");
	loadimage(&imgMenu2, "res/menu2.png");

	while (1) {
		BeginBatchDraw();           //开始绘图
		putimage(0, 0, &imgMenu);	//渲染开始背景图到窗口上
		putimagePNG(474, 75, flag == 0 ? &imgMenu1 : &imgMenu2);

		ExMessage	msg;
		if (peekmessage(&msg)) {
			if (msg.message == WM_LBUTTONDOWN &&	//鼠标左键落下	
				msg.x > 474 && msg.x < 774 && msg.y>75 && msg.y < 215) {
				flag = 1;
				mciSendString("play res/audio/awooga.mp3", 0, 0, 0);
			}
		}
		else if (msg.message == WM_LBUTTONUP && flag == 1) {	//鼠标左键抬起
			mciSendString("close res/audio/bg.mp3", 0, 0, 0);
			EndBatchDraw();
			return;
		}
		EndBatchDraw();              //结束绘图
	}
}

双缓冲绘图：

BeginBatchDraw() - 开始双缓冲

EndBatchDraw()    - 结束双缓冲

双缓冲区：打印一个的同时显示另一个，不断重复这个过程，避免了屏幕闪耀问题

游戏的背景初始化： 

void gameInit() {
	//设置随机种子
	srand(time(NULL));
	//加载游戏背景图片
	loadimage(&imgBg, "res/bg.jpg");
	//加载状态栏
	loadimage(&imgBar, "res/bar5.png");
	killZmCount = 0;
	zmCount = 0;
	gameStatus = GOING;
	memset(imgZhiWu, 0, sizeof(imgZhiWu));	//给指针赋空值
	memset(map, 0, sizeof(map));         	//初始化地图数组
	memset(balls, 0, sizeof(balls));    	//初始化阳光池
	memset(zms, 0, sizeof(zms));	        //初始化僵尸池
	memset(bullets, 0, sizeof(bullets));	//初始化豌豆子弹池
	//加载植物卡牌
	char name[64];
	for (int i = 0; i < ZHI_WU_COUNT; i++) {
		//生成植物卡牌的文件名
		sprintf_s(name, sizeof(name), "res/Cards/card_%d.png", i + 1);
		loadimage(&imgCards[i], name);
		for (int j = 0; j < 20; j++) {	
			sprintf_s(name, sizeof(name), "res/zhiwu/%d/%d.png", i, j + 1);
			//判断文件读取是否存在
			if (fileExist(name)) {
				imgZhiWu[i][j] = new IMAGE;
				loadimage(imgZhiWu[i][j], name);
			}
			else {
				break;
			}
		}
	}
	//初始化选中植物
	curZhiWu = 0;
	//初始化阳光值
	sunShine = 50;
	//加载阳光
	for (int i = 0; i < 29; i++) {	 
		sprintf_s(name, sizeof(name), "res/sunshine/%d.png", i + 1);
		loadimage(&imgSunShineBall[i], name);
	}
	//加载僵尸图片
	for (int i = 0; i < 22; i++) {
		sprintf_s(name, sizeof(name), "res/zm/%d.png", i + 1);
		loadimage(&imgZm[i], name);
	}
	//加载僵尸死亡图片
	for (int i = 0; i < 20; i++) {
		sprintf_s(name, sizeof(name), "res/zm_dead/%d.png", i + 1);
		loadimage(&imgZmDead[i], name);
	}
	//加载僵尸吃植物图片
	for (int i = 0; i < 21; i++) {
		sprintf_s(name, sizeof(name), "res/zm_eat/%d.png", i + 1);
		loadimage(&imgZmEat[i], name);
	}
	//加载巡场僵尸图片
	for (int i = 0; i < 11; i++) {
		sprintf_s(name, sizeof(name), "res/zm_stand/%d.png", i + 1);
		loadimage(&imgZmStand[i], name);
	}
	//加载豌豆子弹图片
	loadimage(&imgBulletNormal, "res/bullets/bullet_normal.png");

	//加载豌豆子弹爆炸图片
	loadimage(&imgBulletBlast[3], "res/bullets/bullet_blast.png");
	for (int i = 0; i < 3; i++) {
		float	k = (i + 2) * 0.2;
		loadimage(&imgBulletBlast[i], "res/bullets/bullet_blast.png",
			imgBulletBlast[3].getwidth() * k, imgBulletBlast[3].getheight() * k, true);
	}
	//创建游戏窗口
	initgraph(WIN_WIDTH, WIN_HEIGHT);	
	//设置字体
	LOGFONT	f;
	gettextstyle(&f);
	f.lfHeight = 30;
	f.lfWeight = 15;
	strcpy(f.lfFaceName, "Segoe UI Black");	//设置字体效果
	f.lfQuality = ANTIALIASED_QUALITY;		//抗锯齿
	settextstyle(&f);
	setbkmode(TRANSPARENT);					//字体模式：背景透明
	setcolor(BLACK);						//字体颜色：黑色

}

 判断读取文件是否存在：

bool fileExist(const char* name) {
	FILE* fp = fopen(name, "r");
	if (fp == NULL) {
		return false;
	}
	else {
		fclose(fp);
		return true;
	}
}

将图片显示在窗口上：

void updateWindow() {
	BeginBatchDraw();
	putimage(-112, 0, &imgBg);	    //加载背景板
	putimagePNG(255, 0, &imgBar);	//加载状态栏
	for (int i = 0; i < ZHI_WU_COUNT; i++) {	//加载植物卡牌
		int x = 343 + i * 65;
		int y = 6;
		putimagePNG(x, y, &imgCards[i]);
	}
	//在地图上加载植物
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 9; j++) {
			if (map[i][j].type > 0) {
				int zhiWuType = map[i][j].type - 1;
				int index = map[i][j].frameIndex;
				putimagePNG(map[i][j].x, map[i][j].y, imgZhiWu[zhiWuType][index]);
			}
		}
	}
	//加载拖动的植物
	if (curZhiWu > 0) {
		IMAGE* img = imgZhiWu[curZhiWu - 1][0];
		putimagePNG(curX - img->getwidth() / 2, curY - img->getheight() / 2, img);
	}
	//加载阳光值
	char scoreText[8];
	sprintf_s(scoreText, sizeof(scoreText), "%d", sunShine);	//把阳光值转换成字符类型
	outtextxy(283, 67, scoreText);				
	//加载僵尸
	for (int i = 0; i < zmMax; i++) {
		if (zms[i].used) {
			IMAGE* img = NULL;
			if (zms[i].eating) {
				img = imgZmEat;
			}
			else if (zms[i].dead) {
				img = imgZmDead;
			}
			else {
				img = imgZm;
			}

			img += zms[i].frameIndex;
			putimagePNG(zms[i].x, zms[i].y - img->getheight(), img);
		}
	}
	//加载豌豆子弹
	for (int i = 0; i < bulletMax; i++) {
		if (bullets[i].used) {
			if (bullets[i].blast) {	//豌豆子弹碰撞渲染
				IMAGE* img = &imgBulletBlast[bullets[i].frameIndex];
			 
				putimagePNG(bullets[i].x, bullets[i].y, img);
				FlushBatchDraw();
			}
			else {	 
				putimagePNG(bullets[i].x, bullets[i].y, &imgBulletNormal);
			}
		}
	}
	//加载阳光
	for (int i = 0; i < ballMax; i++) {
		if (balls[i].used ) {
			IMAGE* img = &imgSunShineBall[balls[i].frameIndex];
			putimagePNG(balls[i].pCur.x, balls[i].pCur.y, img);
		}
	}

	EndBatchDraw();
}

 游戏场景动作的实现：

void updateGame() {
	//更新植物动作
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 9; j++) {
			if (map[i][j].type > 0) {
				map[i][j].frameIndex++;
				int	zhiWuType = map[i][j].type - 1;
				int	index = map[i][j].frameIndex;
				if (imgZhiWu[zhiWuType][index] == NULL) {
					map[i][j].frameIndex = 0;
				}
			}
		}
	}
	//创建僵尸
	createZm();
	//更新僵尸动作
	updateZm();
	//创建阳光
	createSunShine();
	//更新阳光动作
	updateSunShine();
	//创建豌豆子弹
	createBullets();	
	//更新豌豆子弹动作
	updateBullets();
	//豌豆子弹与僵尸碰撞
	collisionCheck();
}

游戏中的阳光操作：

<1>创建阳光>:

void createSunShine() {
	static	int	count = 0;
	static	int	fre = 200;
	count++;
	if (count >= fre) {	            //限制阳光生成的速度
		fre = 100 + rand() % 150;	//第二次生成阳光的时间随机
		count = 0;
		int i;
		//从阳光池中取出可用的阳光
		for (i = 0; i < ballMax && balls[i].used; i++);	
		if (i >= ballMax)return;
		balls[i].used = true;
		balls[i].frameIndex = 0;
		balls[i].timer = 0;
		balls[i].status = SUNSHINE_DOWN;
		balls[i].t = 0;
		balls[i].p1 = vector2(260 - 112 + rand() % (900 - 320 + 112), 60);
		balls[i].p4 = vector2(balls[i].p1.x, 200 + (rand() % 4) * 90);
		int off = 2;
		float distance = balls[i].p4.y - balls[i].p1.y;
		balls[i].speed = 1.0 / (distance / off);
	}
	//向日葵生产阳光
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 9; j++) {
			if (map[i][j].type == XIANG_RI_KUI + 1) {
				map[i][j].timer++;
				if (map[i][j].timer > 200) {
					map[i][j].timer = 0;
					int k;
					for (k = 0; k < ballMax && balls[k].used; k++);
					if (k >= ballMax)return;
					balls[k].used = true;
					balls[k].p1 = vector2(map[i][j].x, map[i][j].y);	//设置贝塞尔曲线的参数
					int w = (50 + rand() % 51) * (rand() % 2 ? 1 : -1);
					balls[k].p4 = vector2(map[i][j].x + w, map[i][j].y + imgZhiWu[XIANG_RI_KUI][0]->getheight()
						- imgSunShineBall->getheight());
					balls[k].p2 = vector2(balls[k].p1.x + w * 0.3, balls[k].p1.y - 100);
					balls[k].p3 = vector2(balls[k].p1.x + w * 0.7, balls[k].p1.y - 150);

					balls[k].status = SUNSHINE_PRODUCT;
					balls[k].speed = 0.05;
					balls[k].t = 0;
				}
			}
		}
	}
}

<2>实现阳光旋转动作>:

void updateSunShine() {
	for (int i = 0; i < ballMax; i++) {
		if (balls[i].used) {
			balls[i].frameIndex = (balls[i].frameIndex + 1) % 29;	//更新序列帧

			if (balls[i].status == SUNSHINE_DOWN) {
				struct sunShineBall* sun = &balls[i];
				sun->t += sun->speed;
				sun->pCur = sun->p1 + sun->t * (sun->p4 - sun->p1);
				if (sun->t >= 1) {
					sun->status = SUNSHINE_GROUND;
					sun->t = 0;
					sun->timer = 0;
				}
			}
			else if (balls[i].status == SUNSHINE_GROUND) {
				balls[i].timer++;
				if (balls[i].timer > 100) {
					balls[i].used = false;
					balls[i].timer = 0;
				}
			}
			else if (balls[i].status == SUNSHINE_COLLECT) {
				struct sunShineBall* sun = &balls[i];
				sun->t += sun->speed;
				sun->pCur = sun->p1 + sun->t * (sun->p4 - sun->p1);
				if (sun->t > 1) {
					sunShine += 25;
					sun->used = false;
					sun->t = 0;
				}
			}
			else if (balls[i].status == SUNSHINE_PRODUCT) {
				struct sunShineBall* sun = &balls[i];
				sun->t += sun->speed;
				sun->pCur = calcBezierPoint(sun->t, sun->p1, sun->p2, sun->p3, sun->p4);
				if (sun->t > 1) {
					sun->status = SUNSHINE_GROUND;
					sun->t = 0;
					sun->timer = 0;
				}
			}
		}
	}
}

<3>实现阳光收集操作>:

void collectSunshine(ExMessage* msg) {
	int w = imgSunShineBall[0].getwidth();	    //单个阳光球的宽度
	int h = imgSunShineBall[0].getheight();	    //单个阳光球的高度
	for (int i = 0; i < ballMax; i++) {
		if (balls[i].used) {	                //阳光球被使用了才进行操作
			int x = balls[i].pCur.x;
			int y = balls[i].pCur.y;
			if (msg->x > x && msg->x<x + w &&	//只有当光标在阳光范围内才进行操作
				msg->y>y && msg->y < y + h) {
				balls[i].status = SUNSHINE_COLLECT;
				mciSendString("play res/sunshine.mp3", 0, 0, 0);
				balls[i].p1 = balls[i].pCur;
				balls[i].p4 = vector2(262, 0);
				balls[i].t = 0;
				float distance = dis(balls[i].p1 - balls[i].p4);
				float off = 8;
				balls[i].speed = 1.0 / (distance / off);
				break;
			}
		}
	}
}

游戏中的僵尸操作：

 <1>创建僵尸>:

void createZm() 
{
	if (zmCount >= ZM_MAX) {
		return;
	}
	static	int	count = 0;
	static	int	zmFre = 500;
	count++;
	if (count >= zmFre) {	        //限制僵尸生成的速度

		zmFre = 300 + rand() % 200;	//第二次生成僵尸的时间随机
		count = 0;
		int i;
		//从僵尸池中取出可用的僵尸
		for (i = 0; i < zmMax && zms[i].used; i++);	//别问，问就是一种新定义方式，跟{}一个样，就是&&!xx
		if (i >= zmMax)return;
		zms[i].used = true;
		zms[i].x = WIN_WIDTH;
		zms[i].row = rand() % 3;
		zms[i].y = 172 + (zms[i].row + 1) * 100;
		zms[i].speed = 1;
		zms[i].blood = 200;
		zms[i].dead = false;
		zms[i].eating = false;

		zmCount++;
	}
}

<2>实现僵尸的动作：

void updateZm() {
	//更新僵尸位置
	static int count = 0;
	count++;
	if (count > 2) {	//限制僵尸前进速度
		count = 0;
		for (int i = 0; i < zmMax; i++) {
			if (zms[i].used) {
				zms[i].x -= zms[i].speed;
				if (zms[i].x < 48) {
					//结束游戏
					gameStatus = FAIL;
				}
			}
		}
	}
	//更新僵尸动作
	static int count2 = 0;
	count2++;
	if (count2 > 4) {	
		count2 = 0;
		for (int i = 0; i < zmMax; i++) {
			if (zms[i].used) {
				if (zms[i].dead) {
					zms[i].frameIndex++;
					if (zms[i].frameIndex >= 20) {
						zms[i].used = false;
						killZmCount++;
						if (killZmCount == ZM_MAX) {
							gameStatus = WIN;
						}
					}
				}
				else if (zms[i].eating) {
					zms[i].frameIndex = (zms[i].frameIndex + 1) % 20;
				}
				else
				{
					zms[i].frameIndex = (zms[i].frameIndex + 1) % 21;	
				}
			}
		}
	}
}

游戏中的豌豆子弹操作：

<1>创建豌豆子弹>:

void createBullets() {
	int lines[3] = { 0 };
	int	dangerX = WIN_WIDTH - imgZm[0].getwidth() + 50;	//定义开始射击距离
	for (int i = 0; i < zmMax; i++) {
		if (zms[i].used && zms[i].x < dangerX) {
			lines[zms[i].row] = 1;	
		
		}
	}
	for (int i = 0; i < 3; i++) {	
		for (int j = 0; j < 9; j++) {
			if (lines[i] && map[i][j].type == 1) {	//有豌豆且僵尸走到打击范围
				map[i][j].shootTimer++;
				if (map[i][j].shootTimer > 20) {
					map[i][j].shootTimer = 0;
					int k;
					PlaySound("res/audio/shootpea1.wav", NULL, SND_FILENAME | SND_ASYNC);
					for (k = 0; k < bulletMax && bullets[k].used; k++);
					if (k >= bulletMax) return;
					bullets[k].used = true;		
					bullets[k].row = i;
					bullets[k].speed = 5;
					bullets[k].blast = false;
					bullets[k].frameIndex = 0;

					int zwX = 256 - 112 + j * 81;
					int zwY = 179 + i * 102 + 14;
					bullets[k].x = zwX + imgZhiWu[0][0]->getwidth() - 10;
					bullets[k].y = zwY + 5;
					lines[i] = 0;
				}
			}
		}
	}
}

<2>实现豌豆子弹的动作>:

void updateBullets() {
	for (int i = 0; i < bulletMax; i++) {
		if (bullets[i].used) {
			bullets[i].x += bullets[i].speed;
			if (bullets[i].x > WIN_WIDTH) {
				bullets[i].used = false;
			}
			//碰撞播放完就消失
			if (bullets[i].blast) {
				bullets[i].frameIndex++;
				if (bullets[i].frameIndex > 3) {
					bullets[i].used = false;
				}
			}
		}
	}
}

游戏中植物与僵尸碰撞的实现：

<1>豌豆子弹与僵尸的碰撞检测实现>:

void checkBullettoZm() {
	for (int i = 0; i < bulletMax; i++) {
		if (bullets[i].used == false || bullets[i].blast)continue;	//如果豌豆子弹没使用或者已经开始碰撞，就跳过
		for (int j = 0; j < zmMax; j++) {
			if (zms[j].used == false)continue;
			int x1 = zms[j].x + 80;
			int x2 = zms[j].x + 110;
			int x = bullets[i].x;
			if (zms[j].dead == false && bullets[i].row == zms[j].row && x > x1 && x < x2) {	//豌豆子弹与僵尸碰撞后
				PlaySound("res/audio/peacrush1.wav", NULL, SND_FILENAME | SND_ASYNC);
				zms[j].blood -= 10;
				bullets[i].blast = true;
				bullets[i].speed = 0;

				if (zms[j].blood <= 0) {
					zms[j].dead = true;
					zms[j].speed = 0;
					zms[j].frameIndex = 0;
				}
				break;
			}
		}
	}
}

<2>僵尸与植物的碰撞检测实现>:

void checkZmtoZhiWu() {
	for (int i = 0; i < zmMax; i++) {
		if (zms[i].dead)continue;
		int row = zms[i].row;
		for (int k = 0; k < 9; k++) {
			if (map[row][k].type == 0)continue;
			int zhiWuX = 256 - 112 + k * 81;	    
			//定义僵尸开吃范围
			int x1 = zhiWuX + 10;
			int x2 = zhiWuX + 60;
			int x3 = zms[i].x + 80;

			if (x3 > x1 && x3 < x2) {
				if (map[row][k].catched == true) {	
					//僵尸吃的过程中的一些配置
					map[row][k].deadTimer++;
					mciSendString("play res/audio/zmeat.mp3", 0, 0, 0);
					if (map[row][k].deadTimer > 100) {
						mciSendString("play res/audio/plantDead.mp3", 0, 0, 0);
						map[row][k].deadTimer = 0;
						map[row][k].type = 0;
						zms[i].eating = false;
						zms[i].frameIndex = 0;
						zms[i].speed = 1;
					}
				}
				else {
					map[row][k].catched = true;
					map[row][k].deadTimer = 0;
					zms[i].eating = true;
					zms[i].speed = 0;
					zms[i].frameIndex = 0;
				}
			}
		}
	}
}

游戏场景巡场的实现： 

void viewScence() {
	int xMin = WIN_WIDTH - imgBg.getwidth();
	vector2 points[9] = { {550,80},{530,160},{630,170},{530,200},{525,270},		
		{565,370},{605,340},{705,280},{690,340} };
	int index[9];
	for (int i = 0; i < 9; i++) {
		index[i] = rand() % 11;
	}
	int count = 0;
	for (int x = 0; x >= xMin; x -= 4) {
		BeginBatchDraw();
		putimage(x, 0, &imgBg);
		count++;
		for (int k = 0; k < 9; k++) {
			putimagePNG(points[k].x - xMin + x, points[k].y, &imgZmStand[index[k]]);
			if (count >= 10) {
				index[k] = (index[k] + 1) % 11;
			}
		}
		if (count >= 10)count = 0;

		EndBatchDraw();
		Sleep(5);
	}
	for (int i = 0; i < 100; i++) {
		BeginBatchDraw();
		putimage(xMin, 0, &imgBg);
		for (int j = 0; j < 9; j++) {
			putimagePNG(points[j].x, points[j].y, &imgZmStand[index[j]]);
			index[j] = (index[j] + 1) % 11;
		}
		EndBatchDraw();
		Sleep(20);
	}
	for (int x = xMin; x <= -112; x += 4) {	
		BeginBatchDraw();
		putimage(x, 0, &imgBg);
		count++;
		for (int k = 0; k < 9; k++) {
			putimagePNG(points[k].x - xMin + x, points[k].y, &imgZmStand[index[k]]);
			if (count >= 10) {
				index[k] = (index[k] + 1) % 11;
			}
			if (count >= 10)count = 0;
		}
		EndBatchDraw();
		Sleep(5);
	}
}

游戏中状态栏下滑实现 ：

void barsDown() {
	IMAGE imgMenu, imgDaiFu1;
	int height = imgBar.getheight();
	for (int y = -height; y <= 0; y++) {
		BeginBatchDraw();

		putimage(-112, 0, &imgBg);

		putimagePNG(250, y, &imgBar);

		for (int i = 0; i < ZHI_WU_COUNT; i++) {
			int x = 338 + i * 65;
			putimagePNG(x, 6 + y, &imgCards[i]);
		}

		EndBatchDraw();
		Sleep(9);
	}
	loadimage(&imgMenu, "res/Maculk.png");
	loadimage(&imgDaiFu1, "res/a.png");
	putimagePNG(180, 117, &imgMenu);
	putimagePNG(0, 100, &imgDaiFu1);
	mciSendString("play res/audio/crazydaveshort2.mp3", 0, 0, 0);
	Sleep(2000);
	mciSendString("play res/audio/crazydavelong1.mp3", 0, 0, 0);
	Sleep(3000);
}

 游戏输赢的判断：

bool checkOver() {
	BeginBatchDraw();

	bool ret = false;

	if (gameStatus == WIN) {
		Sleep(100);
		mciSendString("close res/audio/Mountains.mp3 ", 0, 0, 0);
		loadimage(0, "res/gameWin.png");
		mciSendString("play res/win.mp3", 0, 0, 0);
		ret = true;
	}
	else if (gameStatus == FAIL) {
		Sleep(100);
		mciSendString("close res/audio/Mountains.mp3 ", 0, 0, 0);
		loadimage(0, "res/gameFail.png");
		mciSendString("play res/lose.mp3", 0, 0, 0);
		ret = true;
	}
	EndBatchDraw();
	return ret;
}

用户的鼠标操作：

左键点击移动目标植物到指定位置

点击右键进行种植

void userClick() {
	static	int status = 0;
	ExMessage	msg;
	if (peekmessage(&msg)) {	                //判断用户是否有操作
		if (msg.message == WM_LBUTTONDOWN) {	//鼠标左键按下
			if (msg.x > 343 && msg.x < 343 + 65 * ZHI_WU_COUNT && msg.y < 96) {	
				int index = (msg.x - 343) / 65;

				//判断阳光值是否足够购买植物
				if (index == XIANG_RI_KUI) {
					if (sunShine >= 50) {
						status = 1;
						curZhiWu = index + 1;
						curX = msg.x;
						curY = msg.y;
						sunShine -= 50;
					}
				}
				else if (index == WAN_DAO) {
					if (sunShine >= 100) {
						status = 1;
						curZhiWu = index + 1;
						curX = msg.x;
						curY = msg.y;
						sunShine -= 100;
					}
				}
				else if (index == JIAN_GUO) {
					if (sunShine >= 50) {
						status = 1;
						curZhiWu = index + 1;
						curX = msg.x;
						curY = msg.y;
						sunShine -= 50;
					}
				}
			}
			else {	                          //收集阳光事件
				collectSunshine(&msg);
			}
		}
		else if (msg.message == WM_MOUSEMOVE && status == 1) {	//鼠标移动
			curX = msg.x;
			curY = msg.y;
		}
		else if (msg.message == WM_RBUTTONDOWN && status == 1) {	//鼠标右键按下种植
			if (msg.x > 256 - 112 && msg.x < 900 - 30 && msg.y > 179 && msg.y < 489) {
				mciSendString("play res/audio/plantdown.mp3", 0, 0, 0);
				int	row = (msg.y - 179) / 102;	    //获取行
				int	col = (msg.x - 256 + 112) / 81;	//获取列
				if (map[row][col].type == 0) {
					map[row][col].type = curZhiWu;	//给鼠标当前行种下植物
					map[row][col].frameIndex = 0;	//渲染植物第一帧
					map[row][col].shootTimer = 0;	//初始化发射时间

					map[row][col].x = 256 - 112 + col * 81;	//植物坐标
					map[row][col].y = 179 + row * 102 + 14;
				}
			}
			//使植物释放消失
			curZhiWu = 0;
			status = 0;
		}
	}
}

 main主菜单：

int main(void) {

	gameInit();  	//游戏初始化

	startUI();	    //加载游戏开始界面

	viewScence();	//场景巡场
	mciSendString("play res/audio/Mountains.mp3", 0, 0, 0);
	barsDown();  	//状态栏下滑


	int timer = 0;
	bool flag = true;

	while (1)
	{
		userClick();	        //获取用户点击事件

		timer += getDelay();	//获取间隔时间
		if (timer > 20) {	    //用来限制植物渲染时间
			timer = 0;
			flag = true;
		}
		if (flag) {

			flag = false;

			updateWindow();	        //更新游戏窗口

			updateGame();	        //更新动作

			if (checkOver())break;	//检查游戏是否结束
		}
	}
	system("pause");
}

 代码的整体实现：

#include<stdio.h>
#include<graphics.h>
#include"tools.h"
#include<ctime>
#include<time.h>
#include<math.h>
#include"vector2.h"	            
#include<mmsystem.h>	       
#pragma comment(lib,"winmm.lib")
enum { WAN_DAO, XIANG_RI_KUI, JIAN_GUO, ZHI_WU_COUNT };	
enum { SUNSHINE_DOWN, SUNSHINE_GROUND, SUNSHINE_COLLECT, SUNSHINE_PRODUCT };  
enum { GOING, WIN, FAIL };

IMAGE imgBg;	                   
IMAGE imgBar;	                     
IMAGE imgCards[ZHI_WU_COUNT];	    
IMAGE* imgZhiWu[ZHI_WU_COUNT][20];	

int curX, curY;	
int curZhiWu;	

int killZmCount;	
int zmCount;		
int gameStatus;		


#define	WIN_WIDTH 900   
#define	WIN_HEIGHT 600  
#define ZM_MAX 10	   


struct zhiWu {	
	int type;		
	int frameIndex;
	int shootTimer;	
	bool catched;	
	int deadTimer;	

	int x, y;
	int timer;	
};

struct sunShineBall {	
	int	x, y;      
	int	frameIndex;	
	int	destY;	    
	bool used;	  
	int timer;	   

	int xoff;	
	int yoff;	
 
	float t;	
	vector2 p1, p2, p3, p4;
	vector2	pCur;	
	float	speed;
	int	status;   
};

struct sunShineBall	balls[10];
IMAGE	imgSunShineBall[29];	

struct zm {			
	int x, y;
	int row;
	int frameIndex;
	bool used;
	int speed;	    
	int blood;	    
	bool dead;	   
	bool eating;	
};

struct zm zms[10];	
IMAGE	imgZm[22];
IMAGE	imgZmDead[20];
IMAGE	imgZmEat[21];
IMAGE	imgZmStand[11];



struct bullet {	
	int x, y, row, speed;
	bool used;
	bool blast;	    
	int frameIndex;	
};

struct bullet bullets[30];	
IMAGE imgBulletNormal;
IMAGE imgBulletBlast[4];

int ballMax = sizeof(balls) / sizeof(balls[0]);	

int zmMax = sizeof(zms) / sizeof(zms[0]);	             

int bulletMax = sizeof(bullets) / sizeof(bullets[0]);  

struct zhiWu map[3][9];	
int sunShine;	       

void gameInit();

void startUI();

void viewScence();

void barsDown();

void updateWindow();

void userClick();


bool fileExist(const char* name);


void updateGame();


bool checkOver();

void createSunShine();

void updateSunShine();

void collectSunshine(ExMessage* msg);

void createZm();

void updateZm();

void createBullets();

void updateBullets();

void collisionCheck();

void checkBullettoZm();

void checkZmtoZhiWu();

int main(void) {
	gameInit();  
	startUI();	   
	viewScence();	
	mciSendString("play res/audio/Mountains.mp3", 0, 0, 0);
	barsDown();  
	int timer = 0;
	bool flag = true;
	while (1)
	{
		userClick();	       
		timer += getDelay();	
		if (timer > 20) {	    
			timer = 0;
			flag = true;
		}
		if (flag) {

			flag = false;

			updateWindow();	      

			updateGame();	       

			if (checkOver())break;	
		}
	}
	system("pause");
}

void gameInit() {
	srand(time(NULL));
	loadimage(&imgBg, "res/bg.jpg");
	loadimage(&imgBar, "res/bar5.png");
	killZmCount = 0;
	zmCount = 0;
	gameStatus = GOING;
	memset(imgZhiWu, 0, sizeof(imgZhiWu));
	memset(map, 0, sizeof(map));         	
	memset(balls, 0, sizeof(balls));    	
	memset(zms, 0, sizeof(zms));	       
	memset(bullets, 0, sizeof(bullets));	
	char name[64];
	for (int i = 0; i < ZHI_WU_COUNT; i++) 
	{
		
		sprintf_s(name, sizeof(name), "res/Cards/card_%d.png", i + 1);
		loadimage(&imgCards[i], name);
		for (int j = 0; j < 20; j++) {	
			sprintf_s(name, sizeof(name), "res/zhiwu/%d/%d.png", i, j + 1);
			if (fileExist(name)) {
				imgZhiWu[i][j] = new IMAGE;
				loadimage(imgZhiWu[i][j], name);
			}
			else {
				break;
			}
		}
	}
	curZhiWu = 0;
	sunShine = 50;
	for (int i = 0; i < 29; i++) {	 
		sprintf_s(name, sizeof(name), "res/sunshine/%d.png", i + 1);
		loadimage(&imgSunShineBall[i], name);
	}
	for (int i = 0; i < 22; i++) {
		sprintf_s(name, sizeof(name), "res/zm/%d.png", i + 1);
		loadimage(&imgZm[i], name);
	}
	for (int i = 0; i < 20; i++) {
		sprintf_s(name, sizeof(name), "res/zm_dead/%d.png", i + 1);
		loadimage(&imgZmDead[i], name);
	}
	 	for (int i = 0; i < 21; i++) {
		sprintf_s(name, sizeof(name), "res/zm_eat/%d.png", i + 1);
		loadimage(&imgZmEat[i], name);
	}
	for (int i = 0; i < 11; i++) {
		sprintf_s(name, sizeof(name), "res/zm_stand/%d.png", i + 1);
		loadimage(&imgZmStand[i], name);
	}
	loadimage(&imgBulletNormal, "res/bullets/bullet_normal.png");

	loadimage(&imgBulletBlast[3], "res/bullets/bullet_blast.png");
	for (int i = 0; i < 3; i++) {
		float	k = (i + 2) * 0.2;
		loadimage(&imgBulletBlast[i], "res/bullets/bullet_blast.png",
			imgBulletBlast[3].getwidth() * k, imgBulletBlast[3].getheight() * k, true);
	}
	initgraph(WIN_WIDTH, WIN_HEIGHT);	
	LOGFONT	f;
	gettextstyle(&f);
	f.lfHeight = 30;
	f.lfWeight = 15;
	strcpy(f.lfFaceName, "Segoe UI Black");
	f.lfQuality = ANTIALIASED_QUALITY;		
	settextstyle(&f);
	setbkmode(TRANSPARENT);					
	setcolor(BLACK);						

}


void startUI() {
	mciSendString("play res/audio/bg.mp3", 0, 0, 0);
	IMAGE imgMenu, imgMenu1, imgMenu2;
	int	flag = 0;
	loadimage(&imgMenu, "res/menu.png");	
	loadimage(&imgMenu1, "res/menu1.png");
	loadimage(&imgMenu2, "res/menu2.png");

	while (1) {
		BeginBatchDraw();
		putimage(0, 0, &imgMenu);	
		putimagePNG(474, 75, flag == 0 ? &imgMenu1 : &imgMenu2);

		ExMessage	msg;
		if (peekmessage(&msg)) {
			if (msg.message == WM_LBUTTONDOWN &&	
				msg.x > 474 && msg.x < 774 && msg.y>75 && msg.y < 215) {
				flag = 1;
				mciSendString("play res/audio/awooga.mp3", 0, 0, 0);
			}
		}
		else if (msg.message == WM_LBUTTONUP && flag == 1) {	
			mciSendString("close res/audio/bg.mp3", 0, 0, 0);
			EndBatchDraw();
			return;
		}
		EndBatchDraw();
	}
}

void viewScence() {
	int xMin = WIN_WIDTH - imgBg.getwidth();
	vector2 points[9] = { {550,80},{530,160},{630,170},{530,200},{525,270},		
		{565,370},{605,340},{705,280},{690,340} };
	int index[9];
	for (int i = 0; i < 9; i++) {
		index[i] = rand() % 11;
	}
	int count = 0;
	for (int x = 0; x >= xMin; x -= 4) {
		BeginBatchDraw();
		putimage(x, 0, &imgBg);
		count++;
		for (int k = 0; k < 9; k++) {
			putimagePNG(points[k].x - xMin + x, points[k].y, &imgZmStand[index[k]]);
			if (count >= 10) {
				index[k] = (index[k] + 1) % 11;
			}
		}
		if (count >= 10)count = 0;

		EndBatchDraw();
		Sleep(5);
	}
	for (int i = 0; i < 100; i++) {
		BeginBatchDraw();
		putimage(xMin, 0, &imgBg);
		for (int j = 0; j < 9; j++) {
			putimagePNG(points[j].x, points[j].y, &imgZmStand[index[j]]);
			index[j] = (index[j] + 1) % 11;
		}
		EndBatchDraw();
		Sleep(20);
	}
	for (int x = xMin; x <= -112; x += 4) {	
		BeginBatchDraw();
		putimage(x, 0, &imgBg);
		count++;
		for (int k = 0; k < 9; k++) {
			putimagePNG(points[k].x - xMin + x, points[k].y, &imgZmStand[index[k]]);
			if (count >= 10) {
				index[k] = (index[k] + 1) % 11;
			}
			if (count >= 10)count = 0;
		}
		EndBatchDraw();
		Sleep(5);
	}
}


void barsDown() {
	IMAGE imgMenu, imgDaiFu1;
	int height = imgBar.getheight();
	for (int y = -height; y <= 0; y++) {
		BeginBatchDraw();

		putimage(-112, 0, &imgBg);

		putimagePNG(250, y, &imgBar);

		for (int i = 0; i < ZHI_WU_COUNT; i++) {
			int x = 338 + i * 65;
			putimagePNG(x, 6 + y, &imgCards[i]);
		}

		EndBatchDraw();
		Sleep(9);
	}
	loadimage(&imgMenu, "res/Maculk.png");
	loadimage(&imgDaiFu1, "res/a.png");
	putimagePNG(180, 117, &imgMenu);
	putimagePNG(0, 100, &imgDaiFu1);
	mciSendString("play res/audio/crazydaveshort2.mp3", 0, 0, 0);
	Sleep(2000);
	mciSendString("play res/audio/crazydavelong1.mp3", 0, 0, 0);
	Sleep(3000);
}

void updateWindow() {
	BeginBatchDraw();
	putimage(-112, 0, &imgBg);	    
	putimagePNG(255, 0, &imgBar);	
	for (int i = 0; i < ZHI_WU_COUNT; i++) {	
		int x = 343 + i * 65;
		int y = 6;
		putimagePNG(x, y, &imgCards[i]);
	}
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 9; j++) {
			if (map[i][j].type > 0) {
				int zhiWuType = map[i][j].type - 1;
				int index = map[i][j].frameIndex;
				putimagePNG(map[i][j].x, map[i][j].y, imgZhiWu[zhiWuType][index]);
			}
		}
	}
	if (curZhiWu > 0) {
		IMAGE* img = imgZhiWu[curZhiWu - 1][0];
		putimagePNG(curX - img->getwidth() / 2, curY - img->getheight() / 2, img);
	}
	char scoreText[8];
	sprintf_s(scoreText, sizeof(scoreText), "%d", sunShine);	
	outtextxy(283, 67, scoreText);				
	for (int i = 0; i < zmMax; i++) {
		if (zms[i].used) {
			IMAGE* img = NULL;
			if (zms[i].eating) {
				img = imgZmEat;
			}
			else if (zms[i].dead) {
				img = imgZmDead;
			}
			else {
				img = imgZm;
			}

			img += zms[i].frameIndex;
			putimagePNG(zms[i].x, zms[i].y - img->getheight(), img);
		}
	}
	for (int i = 0; i < bulletMax; i++) {
		if (bullets[i].used) {
			if (bullets[i].blast) {	
				IMAGE* img = &imgBulletBlast[bullets[i].frameIndex];
			 
				putimagePNG(bullets[i].x, bullets[i].y, img);
				FlushBatchDraw();
			}
			else {	 
				putimagePNG(bullets[i].x, bullets[i].y, &imgBulletNormal);
			}
		}
	}
	
	for (int i = 0; i < ballMax; i++) {
		if (balls[i].used ) {
			IMAGE* img = &imgSunShineBall[balls[i].frameIndex];
			putimagePNG(balls[i].pCur.x, balls[i].pCur.y, img);
		}
	}

	EndBatchDraw();
}

void userClick() {
	static	int status = 0;
	ExMessage	msg;
	if (peekmessage(&msg)) {	                
		if (msg.message == WM_LBUTTONDOWN) {	
			if (msg.x > 343 && msg.x < 343 + 65 * ZHI_WU_COUNT && msg.y < 96) {	
				int index = (msg.x - 343) / 65;

				
				if (index == XIANG_RI_KUI) {
					if (sunShine >= 50) {
						status = 1;
						curZhiWu = index + 1;
						curX = msg.x;
						curY = msg.y;
						sunShine -= 50;
					}
				}
				else if (index == WAN_DAO) {
					if (sunShine >= 100) {
						status = 1;
						curZhiWu = index + 1;
						curX = msg.x;
						curY = msg.y;
						sunShine -= 100;
					}
				}
				else if (index == JIAN_GUO) {
					if (sunShine >= 50) {
						status = 1;
						curZhiWu = index + 1;
						curX = msg.x;
						curY = msg.y;
						sunShine -= 50;
					}
				}
			}
			else {	                         
				collectSunshine(&msg);
			}
		}
		else if (msg.message == WM_MOUSEMOVE && status == 1) {	
			curX = msg.x;
			curY = msg.y;
		}
		else if (msg.message == WM_RBUTTONDOWN && status == 1) {	
			if (msg.x > 256 - 112 && msg.x < 900 - 30 && msg.y > 179 && msg.y < 489) {
				mciSendString("play res/audio/plantdown.mp3", 0, 0, 0);
				int	row = (msg.y - 179) / 102;	    
				int	col = (msg.x - 256 + 112) / 81;	
				if (map[row][col].type == 0) {
					map[row][col].type = curZhiWu;	
					map[row][col].frameIndex = 0;	
					map[row][col].shootTimer = 0;	

					map[row][col].x = 256 - 112 + col * 81;	
					map[row][col].y = 179 + row * 102 + 14;
				}
			}
			curZhiWu = 0;
			status = 0;
		}
	}
}

bool fileExist(const char* name) {
	FILE* fp = fopen(name, "r");
	if (fp == NULL) {
		return false;
	}
	else {
		fclose(fp);
		return true;
	}
}

  
void updateGame() {
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 9; j++) {
			if (map[i][j].type > 0) {
				map[i][j].frameIndex++;
				int	zhiWuType = map[i][j].type - 1;
				int	index = map[i][j].frameIndex;
				if (imgZhiWu[zhiWuType][index] == NULL) {
					map[i][j].frameIndex = 0;
				}
			}
		}
	}
	createZm();
	updateZm();
	createSunShine();
	updateSunShine();
	createBullets();	
	updateBullets();
	collisionCheck();
}

bool checkOver() {
	BeginBatchDraw();

	bool ret = false;

	if (gameStatus == WIN) {
		Sleep(100);
		mciSendString("close res/audio/Mountains.mp3 ", 0, 0, 0);
		loadimage(0, "res/gameWin.png");
		mciSendString("play res/win.mp3", 0, 0, 0);
		ret = true;
	}
	else if (gameStatus == FAIL) {
		Sleep(100);
		mciSendString("close res/audio/Mountains.mp3 ", 0, 0, 0);
		loadimage(0, "res/gameFail.png");
		mciSendString("play res/lose.mp3", 0, 0, 0);
		ret = true;
	}
	EndBatchDraw();
	return ret;
}

void createSunShine() {
	static	int	count = 0;
	static	int	fre = 200;
	count++;
	if (count >= fre) {	            
		fre = 100 + rand() % 150;
		count = 0;
		int i;
		for (i = 0; i < ballMax && balls[i].used; i++);	
		if (i >= ballMax)return;
		balls[i].used = true;
		balls[i].frameIndex = 0;
		balls[i].timer = 0;
		balls[i].status = SUNSHINE_DOWN;
		balls[i].t = 0;
		balls[i].p1 = vector2(260 - 112 + rand() % (900 - 320 + 112), 60);
		balls[i].p4 = vector2(balls[i].p1.x, 200 + (rand() % 4) * 90);
		int off = 2;
		float distance = balls[i].p4.y - balls[i].p1.y;
		balls[i].speed = 1.0 / (distance / off);
	}
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 9; j++) {
			if (map[i][j].type == XIANG_RI_KUI + 1) {
				map[i][j].timer++;
				if (map[i][j].timer > 200) {
					map[i][j].timer = 0;
					int k;
					for (k = 0; k < ballMax && balls[k].used; k++);
					if (k >= ballMax)return;
					balls[k].used = true;
					balls[k].p1 = vector2(map[i][j].x, map[i][j].y);	
					int w = (50 + rand() % 51) * (rand() % 2 ? 1 : -1);
					balls[k].p4 = vector2(map[i][j].x + w, map[i][j].y + imgZhiWu[XIANG_RI_KUI][0]->getheight()
						- imgSunShineBall->getheight());
					balls[k].p2 = vector2(balls[k].p1.x + w * 0.3, balls[k].p1.y - 100);
					balls[k].p3 = vector2(balls[k].p1.x + w * 0.7, balls[k].p1.y - 150);

					balls[k].status = SUNSHINE_PRODUCT;
					balls[k].speed = 0.05;
					balls[k].t = 0;
				}
			}
		}
	}
}

void updateSunShine() {
	for (int i = 0; i < ballMax; i++) {
		if (balls[i].used) {
			balls[i].frameIndex = (balls[i].frameIndex + 1) % 29;	

			if (balls[i].status == SUNSHINE_DOWN) {
				struct sunShineBall* sun = &balls[i];
				sun->t += sun->speed;
				sun->pCur = sun->p1 + sun->t * (sun->p4 - sun->p1);
				if (sun->t >= 1) {
					sun->status = SUNSHINE_GROUND;
					sun->t = 0;
					sun->timer = 0;
				}
			}
			else if (balls[i].status == SUNSHINE_GROUND) {
				balls[i].timer++;
				if (balls[i].timer > 100) {
					balls[i].used = false;
					balls[i].timer = 0;
				}
			}
			else if (balls[i].status == SUNSHINE_COLLECT) {
				struct sunShineBall* sun = &balls[i];
				sun->t += sun->speed;
				sun->pCur = sun->p1 + sun->t * (sun->p4 - sun->p1);
				if (sun->t > 1) {
					sunShine += 25;
					sun->used = false;
					sun->t = 0;
				}
			}
			else if (balls[i].status == SUNSHINE_PRODUCT) {
				struct sunShineBall* sun = &balls[i];
				sun->t += sun->speed;
				sun->pCur = calcBezierPoint(sun->t, sun->p1, sun->p2, sun->p3, sun->p4);
				if (sun->t > 1) {
					sun->status = SUNSHINE_GROUND;
					sun->t = 0;
					sun->timer = 0;
				}
			}
		}
	}
}


void collectSunshine(ExMessage* msg) {
	int w = imgSunShineBall[0].getwidth();	   
	int h = imgSunShineBall[0].getheight();	    
	for (int i = 0; i < ballMax; i++) {
		if (balls[i].used) {	               
			int x = balls[i].pCur.x;
			int y = balls[i].pCur.y;
			if (msg->x > x && msg->x<x + w &&	
				msg->y>y && msg->y < y + h) {
				balls[i].status = SUNSHINE_COLLECT;
				mciSendString("play res/sunshine.mp3", 0, 0, 0);
				balls[i].p1 = balls[i].pCur;
				balls[i].p4 = vector2(262, 0);
				balls[i].t = 0;
				float distance = dis(balls[i].p1 - balls[i].p4);
				float off = 8;
				balls[i].speed = 1.0 / (distance / off);
				break;
			}
		}
	}
}

void createZm() 
{
	if (zmCount >= ZM_MAX) {
		return;
	}
	static	int	count = 0;
	static	int	zmFre = 500;
	count++;
	if (count >= zmFre) {	       

		zmFre = 300 + rand() % 200;	
		count = 0;
		int i;
		for (i = 0; i < zmMax && zms[i].used; i++);	
		if (i >= zmMax)return;
		zms[i].used = true;
		zms[i].x = WIN_WIDTH;
		zms[i].row = rand() % 3;
		zms[i].y = 172 + (zms[i].row + 1) * 100;
		zms[i].speed = 1;
		zms[i].blood = 200;
		zms[i].dead = false;
		zms[i].eating = false;

		zmCount++;
	}
}

void updateZm() {

	static int count = 0;
	count++;
	if (count > 2) {	
		count = 0;
		for (int i = 0; i < zmMax; i++) {
			if (zms[i].used) {
				zms[i].x -= zms[i].speed;
				if (zms[i].x < 48) {
				
					gameStatus = FAIL;
				}
			}
		}
	}

	static int count2 = 0;
	count2++;
	if (count2 > 4) {	
		count2 = 0;
		for (int i = 0; i < zmMax; i++) {
			if (zms[i].used) {
				if (zms[i].dead) {
					zms[i].frameIndex++;
					if (zms[i].frameIndex >= 20) {
						zms[i].used = false;
						killZmCount++;
						if (killZmCount == ZM_MAX) {
							gameStatus = WIN;
						}
					}
				}
				else if (zms[i].eating) {
					zms[i].frameIndex = (zms[i].frameIndex + 1) % 20;
				}
				else
				{
					zms[i].frameIndex = (zms[i].frameIndex + 1) % 21;	
				}
			}
		}
	}
}


void createBullets() {
	int lines[3] = { 0 };
	int	dangerX = WIN_WIDTH - imgZm[0].getwidth() + 50;	
	for (int i = 0; i < zmMax; i++) {
		if (zms[i].used && zms[i].x < dangerX) {
			lines[zms[i].row] = 1;	
		
		}
	}
	for (int i = 0; i < 3; i++) {	
		for (int j = 0; j < 9; j++) {
			if (lines[i] && map[i][j].type == 1) {	
				map[i][j].shootTimer++;
				if (map[i][j].shootTimer > 20) {
					map[i][j].shootTimer = 0;
					int k;
					PlaySound("res/audio/shootpea1.wav", NULL, SND_FILENAME | SND_ASYNC);
					for (k = 0; k < bulletMax && bullets[k].used; k++);
					if (k >= bulletMax) return;
					bullets[k].used = true;		
					bullets[k].row = i;
					bullets[k].speed = 5;
					bullets[k].blast = false;
					bullets[k].frameIndex = 0;

					int zwX = 256 - 112 + j * 81;
					int zwY = 179 + i * 102 + 14;
					bullets[k].x = zwX + imgZhiWu[0][0]->getwidth() - 10;
					bullets[k].y = zwY + 5;
					lines[i] = 0;
				}
			}
		}
	}
}

void updateBullets() {
	for (int i = 0; i < bulletMax; i++) {
		if (bullets[i].used) {
			bullets[i].x += bullets[i].speed;
			if (bullets[i].x > WIN_WIDTH) {
				bullets[i].used = false;
			}
			
			if (bullets[i].blast) {
				bullets[i].frameIndex++;
				if (bullets[i].frameIndex > 3) {
					bullets[i].used = false;
				}
			}
		}
	}
}


void collisionCheck() {

	
	checkBullettoZm();

	
	checkZmtoZhiWu();
}
void checkBullettoZm() {
	for (int i = 0; i < bulletMax; i++) {
		if (bullets[i].used == false || bullets[i].blast)continue;	
		for (int j = 0; j < zmMax; j++) {
			if (zms[j].used == false)continue;
			int x1 = zms[j].x + 80;
			int x2 = zms[j].x + 110;
			int x = bullets[i].x;
			if (zms[j].dead == false && bullets[i].row == zms[j].row && x > x1 && x < x2) {	
				PlaySound("res/audio/peacrush1.wav", NULL, SND_FILENAME | SND_ASYNC);
				zms[j].blood -= 10;
				bullets[i].blast = true;
				bullets[i].speed = 0;

				if (zms[j].blood <= 0) {
					zms[j].dead = true;
					zms[j].speed = 0;
					zms[j].frameIndex = 0;
				}
				break;
			}
		}
	}
}

void checkZmtoZhiWu() {
	for (int i = 0; i < zmMax; i++) {
		if (zms[i].dead)continue;
		int row = zms[i].row;
		for (int k = 0; k < 9; k++) {
			if (map[row][k].type == 0)continue;
			int zhiWuX = 256 - 112 + k * 81;	    
			int x1 = zhiWuX + 10;
			int x2 = zhiWuX + 60;
			int x3 = zms[i].x + 80;

			if (x3 > x1 && x3 < x2) {
				if (map[row][k].catched == true) {
					map[row][k].deadTimer++;
					mciSendString("play res/audio/zmeat.mp3", 0, 0, 0);
					if (map[row][k].deadTimer > 100) {
						mciSendString("play res/audio/plantDead.mp3", 0, 0, 0);
						map[row][k].deadTimer = 0;
						map[row][k].type = 0;
						zms[i].eating = false;
						zms[i].frameIndex = 0;
						zms[i].speed = 1;
					}
				}
				else {
					map[row][k].catched = true;
					map[row][k].deadTimer = 0;
					zms[i].eating = true;
					zms[i].speed = 0;
					zms[i].frameIndex = 0;
				}
			}
		}
	}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/311755.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【高等数学之不定积分】

【高等数学之不定积分】

一、什么是不定积分? 我们可以简单地从英文层面来基础剖析一下&#xff0c;什么是不定积分? 1.1、基本概念 小tips: 二、不定积分运算法则 三、常用积分公式 四、第一类换元积分法 4.1、定义 4.2、常用凑微分公式 4.3、小calculate 五、第二类换元积分法 5.1、定义 …
阅读更多...
2024年云服务器配置推荐，看看哪家便宜？

2024年云服务器配置推荐，看看哪家便宜？

作为多年站长使市面上大多数的云厂商的云服务器都使用过&#xff0c;很多特价云服务器都是新用户专享的&#xff0c;本文有老用户特价云服务器&#xff0c;阿腾云atengyun.com有多个网站、小程序等&#xff0c;国内头部云厂商阿里云、腾讯云、华为云、UCloud、京东云都有用过&a…
阅读更多...
如何使用宝塔面板部署Inis博客并实现无公网ip环境远程访问

如何使用宝塔面板部署Inis博客并实现无公网ip环境远程访问

文章目录 前言1. Inis博客网站搭建1.1. Inis博客网站下载和安装1.2 Inis博客网站测试1.3 cpolar的安装和注册 2. 本地网页发布2.1 Cpolar临时数据隧道2.2 Cpolar稳定隧道&#xff08;云端设置&#xff09;2.3.Cpolar稳定隧道&#xff08;本地设置&#xff09; 3. 公网访问测试总…
阅读更多...
面试题-DAG 有向无环图

面试题-DAG 有向无环图

有向无环图用于解决前后依赖问题&#xff0c;在Apollo中用于各个组件的依赖管理。 在算法面试中&#xff0c;有很多相关题目 比如排课问题&#xff0c;有先修课比如启动问题&#xff0c;需要先启动1&#xff0c;才能启动2 概念 顶点&#xff1a; 图中的一个点&#xff0c;比…
阅读更多...
shell exit和return的区别

shell exit和return的区别

exit和return的区别 exit 可放在shell脚本中任意位置。表示随时结束运行程序的这个进程&#xff0c;并删除进程使用的内存空间&#xff0c;同时把错误信息返回给父进程。 return 是调用堆栈的返回&#xff0c;返回函数值并退出函数&#xff0c;一般用在函数方法体内。 [Ref]…
阅读更多...
编译原理-2022期末考试解析

编译原理-2022期末考试解析

【前言】 这是2022年的期末考试卷&#xff0c;题目还是比较正的&#xff0c;涵盖了词法分析&#xff0c;语法分析&#xff0c;语法制导翻译&#xff0c;优化。从这一年开始&#xff0c;优化的部分分值开始提高&#xff08;这是最后学的部分&#xff09;。 一、词法分析&#xf…
阅读更多...
数学经典教材有什么？

数学经典教材有什么？

有本书叫做《自然哲学的数学原理》&#xff0c;是牛顿写的&#xff0c;读完之后你就会感叹牛顿的厉害之处! 原文完整版PDF&#xff1a;https://pan.quark.cn/s/5d5eac2e56af 那玩意真的是人写出来的么… 现代教材把牛顿力学简化成三定律&#xff0c;当然觉得很简单。只有读了原…
阅读更多...
GNSS最终、快速、超快速星历下载地址汇总

GNSS最终、快速、超快速星历下载地址汇总

GNSS最终、快速、超快速星历下载地址汇总 igs综合产品 ftp://cddis.gsfc.nasa.gov/pub/gps/products GPS单系统 igs 最终产品 igr 快速产品&#xff08;rapid&#xff09; igu 超快速产品&#xff08;Ultra Rapid&#xff09; ftp://cddis.gsfc.nasa.gov/pub/glonass/produc…
阅读更多...
从学习投研流程的角度学习Qlib

从学习投研流程的角度学习Qlib

许多同学只是把Qlib当做一个简单的工具来学习。其实Qlib隐含了一套正规的投研流程&#xff0c;从投研流程的视角去学习Qlib,则不仅能加深对Qlib的理解&#xff0c;而且能够掌握正确的投研流程&#xff0c;哪怕以后不使用Qlib而是使用其他系统了&#xff0c;这套流程还是适用的。…
阅读更多...
React之自定义路由组件

React之自定义路由组件

开篇 react router功能很强大&#xff0c;可以根据路径配置对应容器组件。做到组件的局部刷新&#xff0c;接下来我会基于react实现一个简单的路由组件。 代码 自定义路由组件 import {useEffect, useState} from "react"; import React from react // 路由配置 e…
阅读更多...
基于Springboot的课程答疑系统（有报告）。Javaee项目，springboot项目。

基于Springboot的课程答疑系统（有报告）。Javaee项目，springboot项目。

演示视频&#xff1a; 基于Springboot的课程答疑系统&#xff08;有报告&#xff09;。Javaee项目&#xff0c;springboot项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构&…
阅读更多...
（25）Linux IPC 进程间通信系统调用:pipe接口

（25）Linux IPC 进程间通信系统调用:pipe接口

一、进程间通信&#xff08;IPC&#xff09; 1、为什么要进程间通信&#xff1f; 我们在之前讲过 "进程之间是具有独立性" 的&#xff0c;如果进程间想交互数据&#xff0c;成本会非常高&#xff01; 因为独立性之本质即 "封闭"&#xff0c;进程们你封闭…
阅读更多...
极客时间-读多写少型缓存设计

极客时间-读多写少型缓存设计

背景 内容是极客时间-徐长龙老师的高并发系统实战课的个人学习笔记&#xff0c;欢迎大家学习&#xff01;https://time.geekbang.org/column/article/596644 总览内容如下&#xff1a; 缓存性价比 一般来说&#xff0c;只有热点数据放到缓存才更有价值 数据量查询频率命中…
阅读更多...
2000-2021年全国各省环境相关指标数据（890+指标）

2000-2021年全国各省环境相关指标数据（890+指标）

2000-2021年全国各省环境相关指标数据&#xff08;890指标&#xff09; 1、指标时间&#xff1a;2000-2021年 2、范围&#xff1a;31省市 3、来源&#xff1a;2001-2022年环境统计年鉴 4、指标&#xff1a;工业废水排放总量、工业废水排放达标量、工业废水处理量、化学需氧…
阅读更多...
golang 生成一年的周数

golang 生成一年的周数

// GetWeekTimeCycleForGBT74082005 获取星期周期 中华人民共和国国家标准 GB/T 7408-2005 // 参数 year 年份 GB/T 7408-2005 func GetWeekTimeCycleForGBT74082005(year int) (*[]TimeCycle, error) {var yearstart time.Time //当年最开始一天var yearend time.Time //当年…
阅读更多...
Python知识点（史上最全）

Python知识点（史上最全）

Python期末考试知识点&#xff08;史上最全&#xff09; python简介 Python是一种解释型语言 Python使用缩进对齐组织代码执行&#xff0c;所以没有缩进的代码&#xff0c;都会在载入时自动执行 数据类型&#xff1a;整形 int 无限大 浮点型 float…
阅读更多...
Javaweb之SpringBootWeb案例开发规范的详细解析

Javaweb之SpringBootWeb案例开发规范的详细解析

1.2 开发规范 了解完需求也完成了环境搭建了&#xff0c;我们下面开始学习开发的一些规范。 开发规范我们主要从以下几方面介绍&#xff1a; 1、开发规范-REST 我们的案例是基于当前最为主流的前后端分离模式进行开发。 在前后端分离的开发模式中&#xff0c;前后端开发人员…
阅读更多...
Vue3 父事件覆盖子事件，Vue2 的 v-on=“$listeners“ 的替代方案

Vue3 父事件覆盖子事件，Vue2 的 v-on=“$listeners“ 的替代方案

在 Vue3 中&#xff0c;$listeners 被删除 子组件代码&#xff0c;需要特别注意的是事件名为 on 开头&#xff0c;例如 onBack。不确定的可以通过给父组件传递 事件或属性&#xff0c;再打印子组件的 attrs useAttrs()&#xff0c;来确定传值 // template v-bind"newA…
阅读更多...
Netty-Netty组件了解

Netty-Netty组件了解

EventLoop 和 EventLoopGroup 回想一下我们在 NIO 中是如何处理我们关心的事件的&#xff1f;在一个 while 循环中 select 出事 件&#xff0c;然后依次处理每种事件。我们可以把它称为事件循环&#xff0c;这就是 EventLoop 。 interface io.netty.channel. EventLoo…
阅读更多...
【自学笔记】01Java基础-08Java常用API：04包装类

【自学笔记】01Java基础-08Java常用API：04包装类

记录Java基础-常用API-有关时间日期的类。 1 包装类 其实就是8种基本数据类型对应的引用类型&#xff0c;因为基本数据类型不能直接参与面向对象编程。具有将基本数据类型转换为对象的功能&#xff0c;并且实现了多种接口&#xff0c;支持集合框架和泛型。 包装类的主要特点和…
阅读更多...
最新文章

Copyright @ 2022~2023