STM32学习笔记十九:WS2812制作像素游戏屏-飞行射击游戏(9)探索道具系统

 增加道具的初衷,是为了增加游戏的趣味性。但是现在有些游戏吧,啧啧啧。

考虑道具,我们要考虑几方面的事情:

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;
	}
}

这里用了AABB碰撞:

	uint8_t checkAABBCollision(PlaneObject_t *a, PlaneObject_t *b) {
		return abs(a->x - b->x) / PlaneXYScale < (a->width + b->width) / 2
				&& abs(a->y - b->y) / PlaneXYScale < (a->height + b->height) / 2;
	}

 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++;
	}
}

showProp用于在屏幕两侧分别显示两个玩家的未使用的道具和当前血量。

现在实现几种道具:

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制作像素游戏屏-飞行射击

STM32学习笔记二十:WS2812制作像素游戏屏-飞行射击游戏(10)探索游戏平衡

你可能感兴趣的:(嵌入式开发,stm32,游戏机,c语言,单片机)