easyx图形库6：实现飞机大战：
飞机大战
- 一.飞机大战的基本窗体：
- 二.飞机大战的主要战斗场景元素：
-
- 一.透明图片：
- 二.精灵对象：
- 三.主游戏场景的元素：
-
- 1.英雄飞机的结构体定义：
- 2.英雄飞机的代码实现：
- 3.游戏背景的结构体定义：
- 4.游戏背景的代码实现：
- 5.子弹结构体的定义：
- 6.子弹的代码实现：
- 7.敌人飞机的共同属性定义：
- 8.敌人飞机的函数定义：
- 9.小敌机的属性定义：
- 10.小敌机的函数定义：
- 11.中敌机的属性定义：
- 12.中敌机的函数实现：
- 13.大敌机的的属性定义：
- 14.大敌机的函数定义：
- 15.音乐的属性定义：
- 16.音乐播放的相关函数：
- 四.主要游戏场景的绘制：
-
- 1.加入英雄飞机和背景到主要场景中：
- 2.使用场景（飞机+背景）的对象：
- 3.加入子弹到我们的主要场景中：
- 4.使用场景（飞机+背景+子弹）的对象：
- 5.加入大中小敌人飞机到场景中：
- 6.子弹射击到敌人飞机检查
- 7.子弹碰撞到敌人飞机的爆炸检查：
- 8.在游戏场景中加入音乐：
- 9.在对应位置播放关闭音乐和添加成绩：
- 10.一次游戏结束打印总成绩（并且等待一定的时间回到菜单：）
- 五.菜单场景：
一.飞机大战的基本窗体：
二.飞机大战的主要战斗场景元素：
一.透明图片：
image.h和image.cpp
#pragma once
#include二.精灵对象：
图片相关的准备工作完成后，我们开始想想如何用代码实现这个游戏。回忆一下之前讲过的关于面向对象风格编程的理论。我们把上述的图形元素的共性提取出来，成为一个基础对象，其他对象均继承于这个基础对象。游戏编程中，我们常常把游戏中出现的各种图形元素称作“精灵”。因此，我们把这个基础对象命名为 sprite 。
精灵它们都会在屏幕中移动，肯定需要记录当前的坐标。另外，它们所占有的大小各不相同，也就是拥有自己的宽度和高度。
除此之外，精灵都是需要被绘制到画面上的，所以精灵拥有一个名为 draw 的方法。精灵不能总是待在一个地方不动。所以，精灵还需要一个 update 方法，用于更新精灵内部的数据。后续的代码中，我们会保证每一帧都执行一次每一个精灵的 draw 方法和 update 方法。这样，我们就能保证所有精灵都被正常绘制，并且数据被及时的更新
sprite.h
struct sprite {
//函数指针保存方法：
void(*draw)(struct sprite*);
void(*updata)(struct sprite*);
//基本数据：
int x;
int y;
int width;
int hight;
};
三.主游戏场景的元素：
1.英雄飞机的结构体定义：
1.我们的父目录：
两个方法，x，y，宽和高；
2.两个图像（mask+img）的指针数组：
3.飞机的状态：
4.飞机的生命数值值：
5.飞机或者的计数器（作用：不要让飞机生成的太快：）
#pragma once
#include2.英雄飞机的代码实现：
1.写draw和updata方法：
2.对英雄飞机对象的初始化和方法：
3.英雄飞机中的图片数组初始化需要注意：
#include"image.h"
#include"hero.h"
#include3.游戏背景的结构体定义：
1.精灵的父对象：
2.图片指针：
background.h
#include4.游戏背景的代码实现：
background.cpp
#include"background.h"
void Drawbackground(struct background* b)
{
//两个背景图片的绘制：
putimage(0, b->yA, b->bk);
putimage(0, b->yB, b->bk);
}
void Updatabackground(struct background* b)
{
//1.移动图片：
b->yA = b->yA + 1;
b->yB = b->yB + 1;
//2.判断第一张图片的位置进行重置：
if (b->yB >= 0)
{
b->yA = 0;
b->yB = -750;
}
}
void backgroundInit(struct background* b)
{
b->super.draw = (void(*)(struct sprite*))Drawbackground;
b->super.updata = (void(*)(struct sprite*))Updatabackground;
b->yB = -750;
b->yA = 0;
b->bk=new IMAGE;
loadimage(b->bk, "img/bg.png");
}
void backgroundDestory(struct background* b)
{
delete b->bk;
}
5.子弹结构体的定义：
#include"image.h"
#include"sprite.h"
struct bullet {
struct sprite supper;
//子弹的图片：
IMAGE* bulletimg;
IMAGE* bulletimgmask;
};
void bulletInit(struct bullet* b);
void bulletDestory(struct bullet* b);
6.子弹的代码实现：
#include"bullet.h"
#include"image.h"
void bulletDraw(struct bullet* b)
{
//绘制子弹
PutTransParentTmage(b->supper.x, b->supper.y,
b->bulletimgmask, b->bulletimg);
}
void bulletUpdata(struct bullet* b)
{
b->supper.y = b->supper.y - 8;
}
void bulletInit(struct bullet* b)
{
b->supper.draw=(void(*)(sprite*))bulletDraw;
b->supper.updata = (void (*)(sprite*))bulletUpdata;
//new两个图片指针：
b->bulletimg=new IMAGE;
b->bulletimgmask = new IMAGE;
//加载图片：
loadimage(b->bulletimg, "img/bullet/bullet.png");
loadimage(b->bulletimgmask, "img/bullet/bullet_mask.png");
}
void bulletDestory(struct bullet* b)
{
delete b->bulletimg;
delete b->bulletimgmask;
}
7.敌人飞机的共同属性定义：
#include"sprite.h"
#include8.敌人飞机的函数定义：
#define _CRT_SECURE_NO_WARNINGS 1
#include"image.h"
#include"enemy.h"
#include9.小敌机的属性定义：
enemy0.h
#include"enemy.h"
struct enemy0 {
//父目录所有的共性：
struct enemy super;
};
void enemy0Init(struct enemy0*);
10.小敌机的函数定义：
enemy0.cpp
#include"enemy0.h"
#include"image.h"
#include11.中敌机的属性定义：
enemy1.h
#include"enemy.h"
struct enemy1 {
//父目录所有的共性：
struct enemy super;
};
void enemy1Init(struct enemy1*);
12.中敌机的函数实现：
enemy1.cpp
#include"enemy0.h"
#include"image.h"
#include13.大敌机的的属性定义：
enemy2.h
#include"enemy.h"
struct enemy2 {
//父目录所有的共性：
struct enemy super;
};
void enemy0Init(struct enemy2*);
14.大敌机的函数定义：
enemy2.cpp
#include"enemy2.h"
#include"image.h"
#include15.音乐的属性定义：
#include"vector.h"
struct music {
//打开音频文件：
void (*play)(struct music*);
//关闭音频文件
void (*close)(struct music*, int interval);
//顺序表存放音频文件的别名：
vector name;
//记录文件路径
char halfway[100];
};
void musicInit(struct music* m, const char*);
void musicDestory(struct music* m);
16.音乐播放的相关函数：
#include"music.h"
#include四.主要游戏场景的绘制：
1.对于一个代码来说写一部分运行一部分这样如果有错误也可以及时的发现：
2.定义一个场景对象：
3.实现对于一个场景的绘制，数据更新，鼠标消息，判断场景结束：
scene.h
#pragma once
//场景函数的定义
#include1.加入英雄飞机和背景到主要场景中：
1.主要场景的对象：
2.成员变量：
1.场景对象必备父成员
2.英雄飞机：……
3.背景图片……
vector.h和vector.cpp
struct vector {
//方法和内容的结合
bool (*append)(struct vector* Pvec, void* newstu);//添加数据
void* (*get)(struct vector* Pvec, int index);//获取数据
void (*clear)(struct vector* Pvec);//清楚数据
void (*remove)(struct vector* Pvec, int index);//删除数据
void** PData;
int size;
int capacity;
};
bool append(struct vector* Pvec, void* newstu);
void* get(struct vector* Pvec, int index);
void clear(struct vector* Pvec);
void remove(struct vector* Pvec, int index);
void vectorDestroy(struct vector* Pvec);
void vectorInit(struct vector* Pvec);
#include思路一：
1.引入一个顺序表，去保存我们的英雄对象和背景对象：
2.在主要场景中引入一个顺序表成员变量：
3.通过对一个顺序表的循环遍历去实现绘制飞机和场景：
mainscene.h
#include"hero.h"
#include"scene.h"
#include"vector.h"
#include"background.h"
struct mainscene {
//场景必备：
struct scene super;
//飞机
struct hero* hero;
//背景
struct background* bk;
//元素：背景+飞机
struct vector vecElements;
};
//初始化
void mainsceneInit(struct mainscene* m);
//销毁
void mainsceneInit(struct mainscene* m);
mainscene.cpp
#include"mainscene.h"
#include"hero.h"
#include2.使用场景（飞机+背景）的对象：
1.背景的一个打印和移动：
2.英雄飞机通过鼠标进行移动：
main.cpp
#includespritegloop.cpp
#include"scene.h"
#include3.加入子弹到我们的主要场景中：
#include"mainscene.h"
#include"hero.h"
#include4.使用场景（飞机+背景+子弹）的对象：
#define _CRT_SECURE_NO_WARNINGS 1
#include"scene.h"
#include5.加入大中小敌人飞机到场景中：
mainscene.h
#define _CRT_SECURE_NO_WARNINGS 1
#include"mainscene.h"
#include"hero.h"
#include6.子弹射击到敌人飞机检查
//4-1：检查子弹射击敌人飞机：
void bulletHitEnemyCheck(struct mainscene* s)
{
for (int i = 0; i < s->vecBullets.size; i++)
{
struct bullet* PBullet = (struct bullet*)
s->vecBullets.get(&s->vecBullets, i);
POINT bulletPoint;
bulletPoint.x = PBullet->super.x + 6 / 2;
bulletPoint.y = PBullet->super.y;
for (int j = 0; j < s->vecEnemy.size; j++)
{
struct enemy* PEnemy =(struct enemy*)s->vecEnemy.get(&s->vecEnemy, j);
int width, hight;
width = PEnemy->super.width;
hight = PEnemy->super.hight;
int left, top, right, bottom;
left = PEnemy->super.x;
top = PEnemy->super.y;
right = left + width;
bottom = top + hight;
if (bulletPoint.x > left && bulletPoint.x< right &&
bulletPoint.y>top && bulletPoint.y < bottom)
{
if (PEnemy->lift != 0)
{
//敌人飞机还没有死,子弹撞击到了飞机子弹应该被销毁
bulletDestory(PBullet);
free(PBullet);
s->vecBullets.remove(&s->vecBullets, i);
i--;
PEnemy->hited(PEnemy);
break;
}
}
}
}
}
//2.场景数据的更新：
void mainScenceUpdata(struct mainscene* s)
{
for (int i = 0; i < s->vecElements.size; i++)
{
//获取数据
struct sprite* tmp = (struct sprite*)(s->vecElements.PData[i]);
//更新数据
tmp->updata(tmp);
}
//添加敌人飞机：
int n = rand() % 120;
if (n == 0)
{
//新增加敌人飞机的函数；
generateNewEnemy(s);
}
//销毁无消敌人飞机时时刻刻需要判断的：
destroyInvalidEnemy(s);
//添加子弹：
s->bulletGerncnt++;
if (s->bulletGerncnt >= 15)
{
generaBullet(s);
s->bulletGerncnt = 0;
}
//判断子弹是否可以销毁：
destorygeneraBullet(s);
//监测子弹是否撞击敌人飞机：
bulletHitEnemyCheck(s);
}
7.子弹碰撞到敌人飞机的爆炸检查：
/4-2：
bool heroHitEnemyChack(struct mainscene* s)
{
//英雄飞机的矩形区域,减少了碰撞区域所以范围是这样的：
RECT rectHeror;
rectHeror.left = s->hero->super.x + 16;
rectHeror.top = s->hero->super.y + 10;
rectHeror.right = s->hero->super.x + 16 * 3;
rectHeror.bottom = s->hero->super.y + 62;
for (int i = 0; i < s->vecEnemy.size; i++)
{
struct enemy* PEnemy = (struct enemy*)
s->vecEnemy.get(&s->vecEnemy, i);
int enemyWidth = 0, enemyhight = 0;
if (PEnemy->status != enemy_normal)
continue;
//敌人飞机的矩形区域
RECT rectEnemy;
rectEnemy.left = PEnemy->super.x;
rectEnemy.top = PEnemy->super.y;
rectEnemy.right = PEnemy->super.x + PEnemy->super.width;
rectEnemy.bottom = PEnemy->super.y + PEnemy->super.hight;
//检查两个区域是否重碟
if (rectHeror.left <= rectEnemy.right
&& rectHeror.right >= rectEnemy.left
&& rectHeror.top <= rectEnemy.bottom
&& rectHeror.bottom >= rectEnemy.top)
{
if (s->hero->state== hero_normal0
|| s->hero->state == hero_normal1)
return true;
}
}
return false;
}
//2.场景数据的更新：
void mainScenceUpdata(struct mainscene* s)
{
for (int i = 0; i < s->vecElements.size; i++)
{
//获取数据
struct sprite* tmp = (struct sprite*)(s->vecElements.PData[i]);
//更新数据
tmp->updata(tmp);
}
//添加敌人飞机：
int n = rand() % 120;
if (n == 0)
{
//新增加敌人飞机的函数；
generateNewEnemy(s);
}
//销毁无消敌人飞机时时刻刻需要判断的：
destroyInvalidEnemy(s);
//添加子弹：
s->bulletGerncnt++;
if (s->bulletGerncnt >= 15)
{
generaBullet(s);
s->bulletGerncnt = 0;
}
//判断子弹是否可以销毁：
destorygeneraBullet(s);
//监测子弹是否撞击敌人飞机：
bulletHitEnemyCheck(s);
//监测英雄飞机是否被敌人碰撞：
bool isHited = heroHitEnemyChack(s);
if (isHited == true)
{
s->hero->lift--;
s->hero->state = hero_down0;
}
}
8.在游戏场景中加入音乐：
maainscene.h
#include"hero.h"
#include"scene.h"
#include"vector.h"
#include"background.h"
#include9.在对应位置播放关闭音乐和添加成绩：
初始化和开始的音乐播放
//初始化
void mainsceneInit(struct mainscene* m)
{
m->super.draw = (void(*)(scene*))mainSceneDraw;
m->super.update = (void(*)(scene*))mainScenceUpdata;
m->super.control = (void(*)(scene*,ExMessage*))mainSceneCountrol;
m->super.isQuit = (bool(*)(scene*))mainSceneIsQuit;
//初始化背景：
m->bk = (struct background*)malloc(sizeof(struct background));
backgroundInit(m->bk);
//初始化英雄飞机：
m->hero = (struct hero*)malloc(sizeof(struct hero));
heroInit(m->hero);
//初始化场景和飞机的数组：
vectorInit(&m->vecElements);
//初始化子弹顺序表：
vectorInit(&m->vecBullets);
m->bulletGerncnt = 0;
//初始化敌人飞机的顺序表：
vectorInit(&m->vecEnemy);
m->count = 0;
//初始化成绩
m->mark = 0;
//初始化音频：
settextcolor(WHITE);
settextstyle(30, 0, "微软雅黑");
setbkmode(TRANSPARENT);
musicInit(&m->enemyDownSoundMgr, "sounds/enemy_down.wma");
mciSendString("open sounds/background.wma", NULL, 0, NULL);
//背景音乐重复播放所以添加一个repeat
mciSendString("play sounds/background.wma repeat", NULL, 0, NULL);
}
成绩记录打印
//1.场景元素的绘制：
void mainSceneDraw(struct mainscene* s)
{
//顺序表中有背景和英雄就可以了：
s->vecElements.clear(&s->vecElements);
//1.加入bk和hero到顺序表中：
s->vecElements.append(&s->vecElements, s->bk);
s->vecElements.append(&s->vecElements, s->hero);
//3.加入敌人飞机到顺序表：
for (int i=0;i<s->vecEnemy.size;i++)
{
struct enemy* tmp = (struct enemy*)s->vecEnemy.get(&s->vecEnemy, i);
s->vecElements.append(&s->vecElements, tmp);
}
//2.加入子弹到我们的顺序表中：
for (int i = 0; i < s->vecBullets.size; i++)
{
struct bullet* tmp = (struct bullet*)s->vecBullets.get(&s->vecBullets, i);
s->vecElements.append(&s->vecElements, tmp);
}
for (int i = 0; i < s->vecElements.size; i++)
{
//获取数据
struct sprite* tmp = (struct sprite*)(s->vecElements.PData[i]);
//绘制数据
tmp->draw(tmp);
}
//主场景的左上角加一个成绩记录
char buff[10];
sprintf(buff, "得分：%d", s->mark);
outtextxy(0, 0, buff);
}
敌人飞机毁灭声音
//4-1：检查子弹射击敌人飞机：
void bulletHitEnemyCheck(struct mainscene* s)
{
for (int i = 0; i < s->vecBullets.size; i++)
{
struct bullet* PBullet = (struct bullet*)
s->vecBullets.get(&s->vecBullets, i);
POINT bulletPoint;
bulletPoint.x = PBullet->super.x + 6 / 2;
bulletPoint.y = PBullet->super.y;
for (int j = 0; j < s->vecEnemy.size; j++)
{
struct enemy* PEnemy =(struct enemy*)s->vecEnemy.get(&s->vecEnemy, j);
int width, hight;
width = PEnemy->super.width;
hight = PEnemy->super.hight;
int left, top, right, bottom;
left = PEnemy->super.x;
top = PEnemy->super.y;
right = left + width;
bottom = top + hight;
if (bulletPoint.x > left && bulletPoint.x< right &&
bulletPoint.y>top && bulletPoint.y < bottom)
{
if (PEnemy->lift != 0)
{
//敌人飞机还没有死,子弹撞击到了飞机子弹应该被销毁
bulletDestory(PBullet);
free(PBullet);
s->vecBullets.remove(&s->vecBullets, i);
i--;
PEnemy->hited(PEnemy);
//敌人飞机被打调之后
if (PEnemy->lift == 0)
{
s->enemyDownSoundMgr.play(&s->enemyDownSoundMgr);
}
break;
}
}
}
}
}
英雄飞机毁灭的声音
//2.场景数据的更新：
void mainScenceUpdata(struct mainscene* s)
{
for (int i = 0; i < s->vecElements.size; i++)
{
//获取数据
struct sprite* tmp = (struct sprite*)(s->vecElements.PData[i]);
//更新数据
tmp->updata(tmp);
}
//添加敌人飞机：
int n = rand() % 120;
if (n == 0)
{
//新增加敌人飞机的函数；
generateNewEnemy(s);
}
//销毁无消敌人飞机时时刻刻需要判断的：
destroyInvalidEnemy(s);
//添加子弹：
s->bulletGerncnt++;
if (s->bulletGerncnt >= 15)
{
generaBullet(s);
s->bulletGerncnt = 0;
}
//判断子弹是否可以销毁：
destorygeneraBullet(s);
//监测子弹是否撞击敌人飞机：
bulletHitEnemyCheck(s);
//监测英雄飞机是否被敌人碰撞：
bool isHited = heroHitEnemyChack(s);
if (isHited == true)
{
s->hero->lift--;
s->hero->state = hero_down0;
mciSendString("open sounds/hero_down.wma", NULL, 0, NULL);
mciSendString("play sounds/hero_down.wma", NULL, 0, NULL);
}
}
结尾关闭所有音乐和数组销毁
//销毁
void mainsceneDestory(struct mainscene* m)
{
mciSendString("close sounds/background.wma", NULL, 0, NULL);
mciSendString("close sounds/hero_down.wma", NULL, 0, NULL);
musicDestory(&m->enemyDownSoundMgr);
heroDestory(m->hero);
free(m->hero);
backgroundDestory(m->bk);
free(m->bk);
//这些销毁方法是
//1.防止内存泄漏：
//2.敌人飞机
//英雄飞机打死销毁,超出屏幕范围被销毁。
//有一些敌人飞机，在程序结束了,没有出屏幕范围也没有没有射击死就。
//没有下面的销毁就会产生内存泄漏
//销毁所有的敌人飞机，检查数组中是否还有飞机：
for (int i = 0; i < m->vecEnemy.size; i++)
{
struct enemy* pEnemy = (struct enemy*)m->vecEnemy.get(&m->vecEnemy, i);
//消除数组中的子弹：
pEnemy->destory(pEnemy);
free(pEnemy);
}
vectorDestroy(&m->vecBullets);
//销毁所有的子弹，检查数组中是否还有子弹：
for (int i = 0; i < m->vecBullets.size; i++)
{
struct bullet* p = (struct bullet*)m->vecBullets.get(&m->vecBullets, i);
//消除数组中的子弹：
bulletDestory(p);
free(p);
}
vectorDestroy(&m->vecBullets);
}
10.一次游戏结束打印总成绩（并且等待一定的时间回到菜单：）
#include五.菜单场景：
menuscene.h
#include"scene.h"
struct menu {
struct scene super;
//目录图片：
IMAGE* menu;
RECT rectStartGame, rectEndGame;
//表示是否悬停在按钮上
bool isStartGameHover, isEndGameHover;
//表示场景是否退出：默认为flase
bool isQuit;
};
void menuInit(struct menu*);
void menudestory(struct menu*);
menuscene.cpp
#include"menuscene.h"
#include"scene.h"
#include今天的分享就到这里了：全部的代码放到gitee的下面的链接中了：
飞机大战小游戏完整代码
