增加道具的初衷，是为了增加游戏的趣味性。但是现在有些游戏吧，啧啧啧。
考虑道具，我们要考虑几方面的事情：
1、道具产生，可以随机产生，指定位置或时间自动产生，击杀地方产生。
2、未捡拾的道具管理。可以自动获取，主动捡拾，如何移动，如何呈现，如何销毁等等
3、已捡拾道具管理。这和上面2是两个不同链表，特别是双人游戏，显然不能用上面那个。
4、道具使用。包括特效呈现，后端数据处理。这很重要！因为你做的时候才会发现，道具可能会影响各种各样的数据，全世界的任何数据都可能需要访问到，就看你希望道具是什么效果了。这对前面章节的数据管理方式影响很大。
不发散了，回归我们的游戏。
我们可以通过前面 IntervalAniTimer_t 来控制 玩家使用道具的间隔，道具的数量是通过玩家自己捡拾的方式来控制。
另外，我们加一点小小的游戏设定——捡到的道具先进入出放在链表里面，只能按顺序使用——这样，可以增加一点点小小的策略性。
不同道具的差异是很大的，为此，我们要为每种道具定义一个新的类。前面我们把道具用结构来做，这回我们把他们拆出来，统一当成道具效果来使用。暂定我们有四种道具：
炸弹、激光、护盾、恢复。
每个道具有两种显示形态：
-》下落过程中的包裹形态，是一条结构数据，用管理类PropManager进行管理。像子弹数据一样，保留基础信息即可，用tag保存类型。
-》显示特效形态。此时应处于玩家的道具列表进行管理。每种道具对应一个实体类。
开始吧。
1、先定义PropManager。
PropManager.h
/*
* PropManager.h
*
* Created on: Dec 27, 2023
* Author: YoungMay
*/
#ifndef SRC_PLANE_PROPMANAGER_H_
#define SRC_PLANE_PROPMANAGER_H_
#include "PlaneDef.h"
#include "../drivers/DList.h"
#include "PropBase.h"
#include "PropBomb.h"
#include "PropHealth.h"
#include "PropSheel.h"
#include "PropLaser.h"
class PropManager {
public:
PropManager();
virtual ~PropManager();
uint8_t tick(uint32_t t);
void init();
uint8_t show(void);
ListNode *propList;
PlaneObject_t* createPropObject(int type);
PropBase* createPropEffect(PlaneObject_t *prop) {
PropBase *pb = NULL;
switch (prop->tag) {
case 0:
pb = new PropBomb;
break;
case 1:
pb = new PropLaser;
break;
case 2:
pb = new PropHealth;
break;
case 3:
pb = new PropSheel;
break;
}
pb->baseInfo.tag = prop->tag;
return pb;
}
private:
IntervalAniTimer_t createTimer = { 1000, 10000 };
uint16_t propTypeProportion[4] = { 100, 100, 100, 100 };
};
#endif /* SRC_PLANE_PROPMANAGER_H_ */
PropManager.cpp
/*
* PropManager.cpp
*
* Created on: Dec 27, 2023
* Author: YoungMay
*/
#include "PropManager.h"
PropManager::PropManager() {
propList = ListCreate();
}
PropManager::~PropManager() {
Serial_print("Destroy PropManager start");
for (ListNode *cur = propList->next; cur != propList; cur = cur->next) {
delete ((PlaneObject_t*) (cur->data));
}
ListDestroy(propList);
Serial_print("Destroy PropManager OK");
}
void PropManager::init() {
}
PlaneObject_t* PropManager::createPropObject(int type) {
PlaneObject_t *prop = new PlaneObject_t;
prop->tag = type;
prop->x = ran_range(5, 27) * PlaneXYScale;
prop->y = 0;
prop->speedX = 0;
prop->speedY = 10;
prop->width = 3;
prop->height = 3;
prop->visiable = 1;
prop->color = 0x900090;
prop->life = 60000;
return prop;
}
uint8_t PropManager::tick(uint32_t t) {
if (createTimer.tick(t)) {
int type = ran_seq(4, propTypeProportion);
PlaneObject_t *prop = createPropObject(type);
ListPushBack(propList, (LTDataType) prop);
}
for (ListNode *cur = propList->next; cur != propList; cur = cur->next) {
PlaneObject_t *prop = ((PlaneObject_t*) (cur->data));
prop->y += prop->speedY * t;
prop->life -= t;
if (prop->y > 64 * PlaneXYScale || prop->life < 0)
prop->visiable = 0;
}
return 0;
}
uint8_t PropManager::show(void) {
ListNode *cur = propList->next;
while (cur != propList) {
PlaneObject_t *prop = ((PlaneObject_t*) (cur->data));
if (prop->visiable) {
ws2812_fill(prop->x / PlaneXYScale - 1, prop->y / PlaneXYScale - 1,
3, 3, 128, 0, 128);
uint8_t idx = (prop->life >> 7) & 0x7;
ws2812_pixel(prop->x / PlaneXYScale + Explode_X[idx],
prop->y / PlaneXYScale + Explode_Y[idx],
(PropColor[prop->tag] & 0xff0000) >> 16,
(PropColor[prop->tag] & 0xff00) >> 8,
PropColor[prop->tag] & 0xff);
ws2812_pixel(prop->x / PlaneXYScale + Explode_X[(idx + 4) & 7],
prop->y / PlaneXYScale + Explode_Y[(idx + 4) & 7],
(PropColor[prop->tag] & 0xff0000) >> 16,
(PropColor[prop->tag] & 0xff00) >> 8,
PropColor[prop->tag] & 0xff);
} else {
delete prop;
ListErase(cur);
}
cur = cur->next;
}
return 0;
}
四种掉落包的形状是一样的，做了一个转圈的颜色特效。
2、在plane.cpp的tick中，加入掉落物的处理
uint8_t Plane::tick(uint32_t t, uint8_t b1, uint8_t b2) {
。。
enemyManager.tick(t);
propManager.tick(t);
checkEffectCollision(t, player1);
checkEffectCollision(t, player2);
checkEnemyCollision();
checkPlayerCollision();
checkPropCollision();
backGroundStar.show();
enemyManager.show();
player1->show();
player2->show();
propManager.show();
。。。
}3、添加掉落物的碰撞检测
void Plane::checkPropCollision() {
ListNode *cur = propManager.propList->next;
while (cur != propManager.propList) {
PlaneObject_t *prop = (PlaneObject_t*) (cur->data);
if (player1->baseInfo.visiable
&& checkAABBCollision(&player1->baseInfo, prop)) {
prop->visiable = 0;
player1->pickProp(propManager.createPropEffect(prop));
}
if (player2->baseInfo.visiable
&& checkAABBCollision(&player2->baseInfo, prop)) {
prop->visiable = 0;
player2->pickProp(propManager.createPropEffect(prop));
}
cur = cur->next;
}
}4、为玩家添加拾取操作pickProp
class PlanePlayer {
public:
PlanePlayer();
~PlanePlayer();
void init(uint8_t id);
void start(uint8_t id);
uint8_t tick(uint32_t t, uint8_t b1);
uint8_t show(void);
uint8_t hitDetect(int x, int y, int damage);
uint8_t hitEffectDetect(int x, int y, int r);
void pickProp(PropBase *prop) {
if (propCount < 30) {
ListPushBack(propList, (LTDataType) prop);
propCount++;
}
}
PlaneObject_t baseInfo;
ListNode *bulletList;
PropBase *currentProp = NULL;
private:
DispersedAnimation *damageAnimation;
ListNode *animationList;
ListNode *propList;
uint8_t propCount = 0;
IntervalAniTimer_t fireTimer = { 0, 200 };
PlaneObject_t* createBulletObject();
void showProp(int locX);
};
5、然后是实现玩家甩道具。
uint8_t PlanePlayer::tick(uint32_t t, uint8_t b1) {
。。。
if (currentProp == NULL) {
if (b1 & KEY_BUTTON_D && propList->next != propList) {
currentProp = (PropBase*) (propList->next->data);
currentProp->init(&baseInfo);
propCount--;
ListErase(propList->next);
}
} else {
currentProp->tick(t);
if (currentProp->baseInfo.life < 0) {
delete currentProp;
currentProp = NULL;
}
}
。。。
return 0;
}如果道具已经甩出去了，则执行道具的TICK方法。
6、在玩家的显示操作中添加显示道具特效
uint8_t PlanePlayer::show(void) {
。。。
if (currentProp != NULL) {
currentProp->show();
}
if (baseInfo.tag == 1)
showProp(0);
else
showProp(31);
return 0;
}
void PlanePlayer::showProp(int locX) {
uint8_t h1 = baseInfo.life / (PlayerMaxLife / 30);
uint8_t h2 = baseInfo.life - h1 * (PlayerMaxLife / 30);
ws2812_fill(locX, 31 - h1, 1, h1, 240, 0, 0);
ws2812_pixel(locX, 31 - h1 - 1, h2 * 5, h2 * 3, 0);
int locY = 32;
for (ListNode *cur = propList->next; cur != propList; cur = cur->next) {
uint8_t tag = ((PropBase*) (cur->data))->baseInfo.tag;
ws2812_pixel(locX, locY, (PropColor[tag] >> 16) & 0xff,
(PropColor[tag] >> 8) & 0xff, PropColor[tag] & 0xff);
locY++;
}
}
现在实现几种道具：
1、先定义好基类：
/*
* PropBase.h
*
* Created on: Dec 27, 2023
* Author: YoungMay
*/
#ifndef SRC_PLANE_PLANEPROP_H_
#define SRC_PLANE_PLANEPROP_H_
#include "PlaneDef.h"
#include "../drivers/DList.h"
#include "../drivers/DataBulk.h"
#include "../drivers/ws2812Frame.h"
const uint32_t PropColor[4] = { 0xf02000, 0x0020f0, 0x20f000, 0x008080 };
class PropBase {
public:
PropBase();
virtual ~PropBase();
virtual uint8_t tick(uint32_t t)=0;
virtual void init(PlaneObject_t *player)=0;
virtual void hitEffectDetect(uint32_t t)=0;
virtual uint8_t show()=0;
PlaneObject_t baseInfo;
PlaneObject_t *player;
protected:
uint32_t totalTick = 0;
};
#endif /* SRC_PLANE_PLANEPROP_H_ */
2、然后是几种道具。每种道具有不同的显示特效和碰撞检测
炸弹道具：PropBomb.cpp
/*
* PropBomb.cpp
*
* Created on: Dec 27, 2023
* Author: YoungMay
*/
#include "PropBomb.h"
#include "EnemyBase.h"
PropBomb::PropBomb() {
// TODO Auto-generated constructor stub
}
PropBomb::~PropBomb() {
// TODO Auto-generated destructor stub
}
void PropBomb::init(PlaneObject_t *_player) {
player = _player;
baseInfo.x = player->x;
baseInfo.y =
player->y > 25 * PlaneXYScale ? player->y - 25 * PlaneXYScale : 0;
baseInfo.life = 4000;
baseInfo.visiable = 1;
}
uint8_t PropBomb::tick(uint32_t t) {
baseInfo.life -= t;
return 0;
}
uint8_t PropBomb::show() {
ws2812_Fill_Circle(baseInfo.x / PlaneXYScale, baseInfo.y / PlaneXYScale, 10,
PropColor[0]);
return 0;
}
uint8_t PropBomb::hitEffectDetectOnce(int x, int y, int r) {
int a = (x - baseInfo.x) / 100;
int b = (y - baseInfo.y) / 100;
int c = (r + 10) * 100;
return (a * a + b * b < c * c) ? 20 : 0;
}
void PropBomb::hitEffectDetect(uint32_t t) {
for (ListNode *enemy = EnemyList->next; enemy != EnemyList;
enemy = enemy->next) {
EnemyBase *ene = (EnemyBase*) enemy->data;
if (ene->explodeState)
continue;
uint8_t res = hitEffectDetectOnce(ene->baseInfo.x, ene->baseInfo.y,
(ene->baseInfo.width + ene->baseInfo.height) / 3);
if (res) {
ene->baseInfo.life -= res * t;
ene->hurt();
}
}
for (ListNode *enemyBul = EnemyBulletList->next;
enemyBul != EnemyBulletList; enemyBul = enemyBul->next) {
PlaneObject_t *bul = (PlaneObject_t*) enemyBul->data;
uint8_t res = hitEffectDetectOnce(bul->x, bul->y, 1);
if (res) {
bul->visiable = 0;
}
}
for (ListNode *enemyBul = EnemyRocketList->next;
enemyBul != EnemyRocketList; enemyBul = enemyBul->next) {
PlaneObject_t *bul = (PlaneObject_t*) enemyBul->data;
uint8_t res = hitEffectDetectOnce(bul->x, bul->y, 1);
if (res) {
bul->visiable = 0;
}
}
}
激光道具：PropLaser.cpp
/*
* PropLaser.cpp
*
* Created on: Dec 27, 2023
* Author: YoungMay
*/
#include "PropLaser.h"
#include "EnemyBase.h"
PropLaser::PropLaser() {
// TODO Auto-generated constructor stub
}
PropLaser::~PropLaser() {
// TODO Auto-generated destructor stub
}
void PropLaser::init(PlaneObject_t *_player) {
player = _player;
baseInfo.x = player->x;
baseInfo.y = player->y;
baseInfo.life = 6000;
}
uint8_t PropLaser::tick(uint32_t t) {
baseInfo.life -= t;
return 0;
}
uint8_t PropLaser::show() {
ws2812_fill(player->x / PlaneXYScale, 0, 1, player->y / PlaneXYScale,
(PropColor[1] >> 16) & 0xff, (PropColor[1] >> 8) & 0xff,
PropColor[1] & 0xff);
return 0;
}
uint8_t PropLaser::hitEffectDetectOnce(int x, int y, int r) {
return abs(x - player->x) < r * PlaneXYScale && y < player->y ? 20 : 0;
}
void PropLaser::hitEffectDetect(uint32_t t) {
for (ListNode *enemy = EnemyList->next; enemy != EnemyList;
enemy = enemy->next) {
EnemyBase *ene = (EnemyBase*) enemy->data;
if (ene->explodeState)
continue;
uint8_t res = hitEffectDetectOnce(ene->baseInfo.x, ene->baseInfo.y,
ene->baseInfo.width / 2);
if (res) {
ene->baseInfo.life -= res * t;
ene->hurt();
}
}
for (ListNode *enemyBul = EnemyBulletList->next;
enemyBul != EnemyBulletList; enemyBul = enemyBul->next) {
PlaneObject_t *bul = (PlaneObject_t*) enemyBul->data;
uint8_t res = hitEffectDetectOnce(bul->x, bul->y, 1);
if (res) {
bul->visiable = 0;
}
}
for (ListNode *enemyBul = EnemyRocketList->next;
enemyBul != EnemyRocketList; enemyBul = enemyBul->next) {
PlaneObject_t *bul = (PlaneObject_t*) enemyBul->data;
uint8_t res = hitEffectDetectOnce(bul->x, bul->y, 1);
if (res) {
bul->visiable = 0;
}
}
}
恢复道具 PropHealth.cpp：这个道具不需要碰撞检测
/*
* PropHealth.cpp
*
* Created on: Dec 27, 2023
* Author: YoungMay
*/
#include "PropHealth.h"
PropHealth::PropHealth() {
// TODO Auto-generated constructor stub
}
PropHealth::~PropHealth() {
// TODO Auto-generated destructor stub
}
void PropHealth::init(PlaneObject_t *_player) {
player = _player;
baseInfo.x = player->x;
baseInfo.y = player->y;
baseInfo.life = 10000;
}
uint8_t PropHealth::tick(uint32_t t) {
baseInfo.life -= t;
player->life += t;
if (player->life > PlayerMaxLife)
player->life = PlayerMaxLife;
return 0;
}
uint8_t PropHealth::show() {
ws2812_Draw_Circle(player->x / PlaneXYScale, player->y / PlaneXYScale, 4,
PropColor[2]);
return 0;
}
void PropHealth::hitEffectDetect(uint32_t t) {
}
护盾道具 PropSheel.cpp： 护盾只能防子弹，不能防飞机。当然，敌我飞机的碰撞也没做。屏幕小，飞机一多就容易混在一起了，所以就不让他们碰了。
/*
* PropSheel.cpp
*
* Created on: Dec 27, 2023
* Author: YoungMay
*/
#include "PropSheel.h"
PropSheel::PropSheel() {
// TODO Auto-generated constructor stub
}
PropSheel::~PropSheel() {
// TODO Auto-generated destructor stub
}
void PropSheel::init(PlaneObject_t *_player) {
player = _player;
baseInfo.x = player->x;
baseInfo.y = player->y;
baseInfo.life = 10000;
}
uint8_t PropSheel::tick(uint32_t t) {
baseInfo.life -= t;
return 0;
}
uint8_t PropSheel::show() {
ws2812_Draw_Circle(player->x / PlaneXYScale, player->y / PlaneXYScale, 4,
PropColor[3]);
return 0;
}
uint8_t PropSheel::hitEffectDetectOnce(int x, int y, int r) {
int a = (x - player->x) / 100;
int b = (y - player->y) / 100;
int c = (r + 5) * 100;
return (a * a + b * b < c * c) ? 2 : 0;
}
void PropSheel::hitEffectDetect(uint32_t t) {
for (ListNode *enemyBul = EnemyBulletList->next;
enemyBul != EnemyBulletList; enemyBul = enemyBul->next) {
PlaneObject_t *bul = (PlaneObject_t*) enemyBul->data;
uint8_t res = hitEffectDetectOnce(bul->x, bul->y, 1);
if (res) {
bul->visiable = 0;
}
}
for (ListNode *enemyBul = EnemyRocketList->next;
enemyBul != EnemyRocketList; enemyBul = enemyBul->next) {
PlaneObject_t *bul = (PlaneObject_t*) enemyBul->data;
uint8_t res = hitEffectDetectOnce(bul->x, bul->y, 1);
if (res) {
bul->visiable = 0;
}
}
}
最后看看效果：
STM32学习笔记十九：WS2812制作像素游戏屏-飞行射击