Qt planeGame day10

Game基本框架

qt中没有现成的游戏框架可以用，我们需要自己搭框架
首先创建一个QGame类作为框架，这个基本框架里面应该有如下功能：
游戏初始化

void init(const QSize& siez,const QString& title);

游戏反初始化(清理)

void clean();

更新游戏

void update(int);

渲染游戏

void render(QPainter* painter);

游戏是否在运行

bool isRunning() const;

退出游戏

void quit();

运行游戏

void runGame();

设置游戏帧率

void setFps(qreal fps);

一个游戏肯定要在一个主循环里面，在Qt中肯定不能使用死循环，就得使用定时器了，基本的变量

	//控制游戏进行的变量
	bool m_isRunning = false;
	//游戏的主循环
	QTimer* m_mainLoopTimerP{};
	//游戏帧率60帧
	qreal m_fps = 1000 / 60;

基本框架思路：判断游戏是否运行中，运行中的话需要连接定时器处理游戏更新于绘图，然后开启定时器，因为qt的绘图只能在事件中完成，所以把渲染写在事件中即可，在定时器中去调用父类的更新画面
基本框架

QGame.h

#ifndef QGAME_H_
#define QGAME_H_

#include <QWidget>
#include <Qtimer>

class QGame :public QWidget
{
	Q_OBJECT
public:
	QGame(QWidget* parent = nullptr);
	~QGame();
	//游戏初始化
	void init(const QSize& size, const QString& title);
	//游戏反初始化
	void clean();
	//更新游戏，站位符与父类的方法做区别
	void update(int);
	//渲染游戏
	void render(QPainter* painter);
	//游戏是否进行
	bool isRuning() const;
	//退出游戏
	void quit();
	//运行游戏
	void runGame();
	//设置游戏帧率
	void setFps(qreal fps);

	//获取游戏帧数的接口
	qreal fps() const { return m_fps; }
protected:
	void paintEvent(QPaintEvent* ev) override;
private:
	//控制游戏进行的变量
	bool m_isRunning = false;
	//游戏的主循环
	QTimer* m_mainLoopTimer{};
	//游戏帧率60帧
	qreal m_fps = 1000 / 60;
};

#endif

QGame.cpp

#include "QGame.h"
#include <QApplication>
#include <QPainter>
QGame::QGame(QWidget* parent) :QWidget(parent)
	, m_mainLoopTimer(new QTimer)
{

}
QGame::~QGame()
{
	//清理
	clean();
}
//游戏初始化
void QGame::init(const QSize& size, const QString& title)
{
	//设置窗口固定大小
	setFixedSize(size);
	//设置标题
	setWindowTitle(title);

	//因为上面会有各种资源的初始化，如果初始化失败，那么m_isRunning=false;游戏不继续运行了
	//初始化成功就为true 
	m_isRunning = true;
}
//游戏反初始化
void QGame::clean()
{
}
//更新游戏
void QGame::update(int)
{
}
//渲染游戏
void QGame::render(QPainter* painter)
{
}
//游戏是否进行
bool QGame::isRuning() const
{
	return true;
}
//退出游戏
void QGame::quit()
{
	m_isRunning = false;
}
//运行游戏
void QGame::runGame()
{	
	//显示窗口
	show();
	//连接定时器
	m_mainLoopTimer->callOnTimeout([=]()
		{
			//如果游戏没有在运行，那么就结束游戏
			if (!isRuning())
			{
				m_mainLoopTimer->stop();
				qApp->quit();
			}
			//更新游戏,QGame的自定义update
			update(0);
			//重绘,父类的update
			QWidget::update();
			
			//测试游戏是否在进行
			qDebug() << "游戏运行中";
		}
	);
	//开始定时器，设置游戏开启的帧数
	m_mainLoopTimer->start(m_fps);
}
//设置游戏帧率
void QGame::setFps(qreal fps)
{
	m_fps = fps;
}

//绘图事件
void QGame::paintEvent(QPaintEvent* ev)
{
	//开启画家
	QPainter painter(this);
	//渲染游戏
	render(&painter);
}

mian.cpp

#include <QApplication>
#include "QGame.h"

int main(int argc,char* argv[])
{
	QApplication a(argc, argv);
	QGame game;
	game.init({ 600,600 }, "小瓜");
	game.runGame();
	return a.exec();
}

运行结果，游戏是在主循环中，基本框架搭建完毕

构建精灵与实体类

实体类

新建一个Entity空类，什么都不需要继承，这个类里面可以存放各种实体，我们统一称为精灵，每一个精灵都会有一种状态，例如是否死亡；所以我们还需要存在一个类别用与判断实体类型。

private:
	bool m_active = true;//实体是否是活动的
	int m_type = 0;//实体类型

那么这个实体被精灵继承的时候，是需要更新释放渲染实体的，所以这个实体类一定要有虚析构与纯虚方法，不然子类可能释放不了造成内存泄漏

public:
	virtual ~Entity() {};//虚析构，当子类继承重写的时候就可以释放子类的内存
	virtual void update() = 0;//更新实体
	virtual void render(QPainter* painter);//渲染实体

我们当前实体类中的方法可以设置状态的销毁与实体的类型，到时候由一个统一的管理类去进行管理

	//接口
	bool active()const { return m_active; }
	int type()const { return m_type; }

	//状态销毁
	void destory() { m_active = false; }

	//设置实体类型
	void setType(int type) { m_type = type; }

Entity.h

#ifndef ENTITY_H_
#define ENTITY_H_

#include <QPainter>

class Entity
{
public:
	virtual ~Entity() {};//虚析构，当子类继承重写的时候就可以释放子类的内存
	virtual void update() = 0;//更新实体
	virtual void render(QPainter* painter) = 0;//渲染实体

	//接口
	bool active()const { return m_active; }
	int type()const { return m_type; }

	//状态销毁
	void destroy() { m_active = false; }

	//设置实体类型
	void setType(int type) { m_type = type; }
	
private:
	bool m_active = true;//精灵是否是活动的
	int m_type = 0;//精灵类型

};
#endif // !ENTITY_H_

精灵类

新建一个精灵类，这个类需要重写Entity的纯虚方法，这个类拥有设置坐标与加载图片的方法

private:
	QPixmap m_image;
	QVector2D m_pos;

设置图片

//设置图片
void setPixmap(const QString& fileName, const QSize& size = QSize());

设置坐标

//设置坐标
void setPos(float x, float y)
{
	m_pos = { x,y };
}

Sprite.h

#ifndef SPRITE_H_
#define SPRITE_H_

#include "Entity.h"
#include <QVector2D>

class Sprite :public Entity
{
public:
	Sprite() = default;
	Sprite(const QString& fileName, const QSize& size = QSize());
	
	//接口
	QVector2D getPos()const { return m_pos; }
	QPixmap getPixmap()const { return m_image; }

	//设置坐标
	void setPos(float x, float y)
	{
		m_pos = { x,y };
	}
	//设置图片
	void setPixmap(const QString& fileName, const QSize& size = QSize());
	
	// 通过 Entity 继承
	void update() override;
	// 通过 Entity 继承
	void render(QPainter* painter) override;


private:
	QPixmap m_image;
	QVector2D m_pos;
};
#endif // !SPRITE_H_

Sprite.cpp

#include "Sprite.h"

Sprite::Sprite(const QString& fileName, const QSize& size)
{
	setPixmap(fileName, size);
}
//设置图片
void Sprite::setPixmap(const QString& fileName, const QSize& size)
{
	m_image.load(fileName);
	if (size.isValid())
	{
		//保持缩放	
		m_image.scaled(size, Qt::AspectRatioMode::KeepAspectRatio);
	}
}

void Sprite::update()
{
}

void Sprite::render(QPainter* painter)
{
	painter->drawPixmap(m_pos.toPoint(), m_image);
}

QGame.cpp

在QGame.cpp中声明一个全局的精灵类，然后去初始化精灵

#include "QGame.h"
#include "Sprite.h"
#include <QApplication>
#include <QPainter>

QGame::QGame(QWidget* parent) :QWidget(parent)
	, m_mainLoopTimer(new QTimer)
{

}
QGame::~QGame()
{
	//清理
	clean();
}

//全局精灵类,注意这里必须使用指针类，如果是普通类对象会报错
//因为QT里面QApplication执行后是不允许对象还没有构造完的，指针是个不完整类就不会默认构造
Sprite* player;

//游戏初始化
void QGame::init(const QSize& size, const QString& title)
{
	//设置窗口固定大小
	setFixedSize(size);
	//设置标题
	setWindowTitle(title);

	player = new Sprite;
	player->setPixmap(":/plane/Resource/images/hero1.png");
	//因为上面会有各种资源的初始化，如果初始化失败，那么m_isRunning=false;游戏不继续运行了
	//初始化成功就为true 
	m_isRunning = true;
}
//游戏反初始化
void QGame::clean()
{
}
//更新游戏
void QGame::update(int)
{
	player->update();
}
//渲染游戏
void QGame::render(QPainter* painter)
{
	player->render(painter);
}
//游戏是否进行
bool QGame::isRuning() const
{
	return true;
}
//退出游戏
void QGame::quit()
{
	m_isRunning = false;
}
//运行游戏
void QGame::runGame()
{	
	//显示窗口
	show();
	//连接定时器
	m_mainLoopTimer->callOnTimeout([=]()
		{
			//如果游戏没有在运行，那么就结束游戏
			if (!isRuning())
			{
				m_mainLoopTimer->stop();
				qApp->quit();
			}
			//更新游戏,QGame的自定义update
			update(0);
			//重绘,父类的update
			QWidget::update();
			
			//测试游戏是否在进行
			qDebug() << "游戏运行中";
		}
	);
	//开始定时器，设置游戏开启的帧数
	m_mainLoopTimer->start(m_fps);
}
//设置游戏帧率
void QGame::setFps(qreal fps)
{
	m_fps = fps;
}

//绘图事件
void QGame::paintEvent(QPaintEvent* ev)
{
	//开启画家
	QPainter painter(this);
	//渲染游戏
	render(&painter);
}

运行结果

精灵移动

毫无疑问，我们需要让精灵动起来，那肯定得使用事件去调用，采用两种方式去移动精灵，键盘事件和鼠标事件
使用键盘事件的时候，我们需要知道一个知识点，我们采用分量概念去乘上速度来达到效果

Sprite.h中
public:
	
Sprite() = default;
Sprite(const QString& fileName, const QSize& size = QSize());
	
//接口
QVector2D getPos()const { return m_pos; }
QPixmap getPixmap()const { return m_image; }
QVector2D velocity() const{ return m_velocity; }
QVector2D& velocity() { return m_velocity; }
private：
//移动速度
float m_speed = 3;
//速度分量
QVector2D m_velocity;
-----------------------------------------------------------------
Sprite.cpp中
void Sprite::update()
{
	//获取一下坐标
	float x = m_pos.x();
	float y = m_pos.y();
	//通过分量去改变坐标的速度，移动就比较正常一点
	x += m_velocity.x() * m_speed;
	y += m_velocity.y() * m_speed;
	//将坐标给m_pos
	m_pos = { x,y };
}

QGame.h

protected:
	void paintEvent(QPaintEvent* ev) override;
	void keyPressEvent(QKeyEvent* ev) override;
	void keyReleaseEvent(QKeyEvent* ev) override;
	void mouseMoveEvent(QMouseEvent* ev) override;

QGame.cpp

//捕获按键事件
void QGame::keyPressEvent(QKeyEvent* ev)
{
	switch (ev->key())
	{
	case Qt::Key_Up:
		player->velocity().setY(-1);
		break;
	case Qt::Key_Down:
		player->velocity().setY(1);
		break;
	case Qt::Key_Left:
		player->velocity().setX(-1);
		break;
	case Qt::Key_Right:
		player->velocity().setX(1);
		break;
	}
}

void QGame::keyReleaseEvent(QKeyEvent* ev)
{
	switch (ev->key())
	{
	case Qt::Key_Up:
	case Qt::Key_Down:
		player->velocity().setY(0);
		break;
	case Qt::Key_Left:
	case Qt::Key_Right:
		player->velocity().setX(0);
		break;
	}
}

void QGame::mouseMoveEvent(QMouseEvent* ev)
{
	//让鼠标居中到图片中间
	auto pos = player->sizeImage() / 2;
	player->setPos(ev->pos() - QPoint{ pos.width(),pos.height() });
}

子弹类，飞机类与单例设计模式

构造两个类，一个子弹类一个飞机类，为了在这些类里面能使用QGame的实例，我们设计一个单例设计模式让QGame实例唯一存在

QGame.h

#ifndef QGAME_H_
#define QGAME_H_
#include <QWidget>
#include <Qtimer>
//宏定义一下这个单例
#define qGame QGame::instance()

class QGame :public QWidget
{
	Q_OBJECT
public:
	//单例设计模式,让QGame实例只允许存在一个
	static QGame* instance();

	QGame(QWidget* parent = nullptr);
	~QGame();
	//游戏初始化
	void init(const QSize& size, const QString& title);
	//游戏反初始化
	void clean();
	//更新游戏，站位符与父类的方法做区别
	void update(int);
	//渲染游戏
	void render(QPainter* painter);
	//游戏是否进行
	bool isRuning() const;
	//退出游戏
	void quit();
	//运行游戏
	void runGame();
	//设置游戏帧率
	void setFps(qreal fps);

	//获取游戏帧数的接口
	qreal fps() const { return m_fps; }
protected:
	void paintEvent(QPaintEvent* ev) override;
	void keyPressEvent(QKeyEvent* ev) override;
	void keyReleaseEvent(QKeyEvent* ev) override;
	void mouseMoveEvent(QMouseEvent* ev) override;
private:
	//控制游戏进行的变量
	bool m_isRunning = false;
	//游戏的主循环
	QTimer* m_mainLoopTimer{};
	//游戏帧率60帧
	qreal m_fps = 1000 / 60;
};

#endif

QGame.cpp

#include "QGame.h"
#include "Sprite.h"
#include <QApplication>
#include <QPainter>
#include <QKeyEvent>
#include <QMessageBox>

//定义一个静态指针，指向唯一对象
static QGame* ins = nullptr;
QGame* QGame::instance()
{
	return ins;
}

QGame::QGame(QWidget* parent) :QWidget(parent)
	, m_mainLoopTimer(new QTimer)
{
	//保证不存在调用多个QGame实例
	Q_ASSERT_X(ins == nullptr, "QGame", "已经存在一个QGame实例");
	ins = this;
}
QGame::~QGame()
{
	//清理
	clean();
}

//全局精灵类,注意这里必须使用指针类，如果是普通类对象会报错
//因为QT里面QApplication执行后是不允许对象还没有构造完的，指针是个不完整类就不会默认构造
Sprite* player;

//游戏初始化
void QGame::init(const QSize& size, const QString& title)
{
	//设置窗口固定大小
	setFixedSize(size);
	//设置标题
	setWindowTitle(title);
	//开启鼠标自动追踪
	setMouseTracking(true);

	player = new Sprite;
	player->setPixmap(":/plane/Resource/images/hero1.png");
	//因为上面会有各种资源的初始化，如果初始化失败，那么m_isRunning=false;游戏不继续运行了
	//初始化成功就为true 
	m_isRunning = true;
}
//游戏反初始化
void QGame::clean()
{
}
//更新游戏
void QGame::update(int)
{
	player->update();
}
//渲染游戏
void QGame::render(QPainter* painter)
{
	player->render(painter);
}
//游戏是否进行
bool QGame::isRuning() const
{
	return true;
}
//退出游戏
void QGame::quit()
{
	m_isRunning = false;
}
//运行游戏
void QGame::runGame()
{	
	//显示窗口
	show();
	//连接定时器
	m_mainLoopTimer->callOnTimeout([=]()
		{
			//如果游戏没有在运行，那么就结束游戏
			if (!isRuning())
			{
				m_mainLoopTimer->stop();
				qApp->quit();
			}
			//更新游戏,QGame的自定义update
			update(0);
			//重绘,父类的update
			QWidget::update();
			
			//测试游戏是否在进行
			qDebug() << "游戏运行中";
		}
	);
	//开始定时器，设置游戏开启的帧数
	m_mainLoopTimer->start(m_fps);
}
//设置游戏帧率
void QGame::setFps(qreal fps)
{
	m_fps = fps;
}

//绘图事件
void QGame::paintEvent(QPaintEvent* ev)
{
	//开启画家
	QPainter painter(this);
	//渲染游戏
	render(&painter);
}

//捕获按键事件
void QGame::keyPressEvent(QKeyEvent* ev)
{
	switch (ev->key())
	{
	case Qt::Key_Up:
		player->velocity().setY(-1);
		break;
	case Qt::Key_Down:
		player->velocity().setY(1);
		break;
	case Qt::Key_Left:
		player->velocity().setX(-1);
		break;
	case Qt::Key_Right:
		player->velocity().setX(1);
		break;
	}
}

void QGame::keyReleaseEvent(QKeyEvent* ev)
{
	switch (ev->key())
	{
	case Qt::Key_Up:
	case Qt::Key_Down:
		player->velocity().setY(0);
		break;
	case Qt::Key_Left:
	case Qt::Key_Right:
		player->velocity().setX(0);
		break;
	}
}

void QGame::mouseMoveEvent(QMouseEvent* ev)
{
	//让鼠标居中到图片中间
	auto pos = player->sizeImage() / 2;
	player->setPos(ev->pos() - QPoint{ pos.width(),pos.height() });
}

PlayerPlane.h

#ifndef PLAYERPLANE_H_
#define PLAYERPLANE_H_

#include "Sprite.h"
#include "Bullet.h"
#include <array>
class PlayerPlane : public Sprite
{
public:
	PlayerPlane();
	//发射子弹
	bool emitBullet();
private:

};
#endif // !PLAYERPLANE_H_

PlayerPlane.cpp

#include "PlayerPlane.h"

PlayerPlane::PlayerPlane()
{
	
}

bool PlayerPlane::emitBullet()
{
	return false;
}

Bullte.h

#ifndef BULLET_H_
#define BULLET_H_

#include "Sprite.h"
class Bullet :public Sprite
{
public:
	//更新子弹出边界就得消失
	void update() override;
private:

};
#endif // !BULLET_H_

Bullte.cpp

#include "Bullet.h"
#include "QGame.h"
void Bullet::update()
{
	//父类方法帮忙移动
	Sprite::update();
	//就可以调用游戏唯一的单例
	//如果子弹超出边界让子弹消失
	if (getPos().x() > qGame->width() || getPos().x() < 0 - sizeImage().width() ||
		getPos().y() > qGame->height() || getPos().y() < 0 - sizeImage().height())
	{
		destroy();
	}
}

精灵管理类

创建一个EntityManager类来管理所有的实体与精灵，为这个类构造单例，然后使用链表去管理存储所有的实体与精灵。主游戏里面的所有实体与精灵就可以通过EntityManger这个单例去完成操作

EntityManager.h

#ifndef		ENTITYMANAGER_H_
#define		ENTITYMANAGER_H_

#include"Sprite.h"
#include<QList>
#include<memory>
#include<QDebug>
class EntityManager
{
public:
	//得到唯一的实例
	static EntityManager& instance()
	{
		static EntityManager ev;
		return ev;
	}
	//更新管理的所有实体与精灵
	void update()
	{
		for (auto& e : m_entities)
		{
			e->update();
		}
	}
	//渲染
	void render(QPainter* painter)
	{
		for (auto& e : m_entities)
		{
			e->render(painter);
		}
	}
	
	//添加实体开个模版方便使用
	template<typename T = Entity>
	T* addEntity(T* e)
	{
		m_entities.emplaceBack(e);
		return e;
	}

	//刷新，如果有实体要消除，就在这里销毁
	void refresh()
	{
		m_entities.removeIf([](Entity* e)
			{
				if (!e->active())
				{
					//测试输出
					qDebug() << "destoryed" << e;
					//释放这个实体
					delete e;
					return true;
				}
				return false;
			});
		//测试输出
		qDebug() << m_entities.size();
	}
	
private:
	QList<Entity*> m_entities;
	//构造函数私有化，设计单例
	EntityManager() {}
};
#endif

PlayerPlane.h

#ifndef PLAYERPLANE_H_
#define PLAYERPLANE_H_

#include "Sprite.h"
#include "Bullet.h"
#include <array>
class PlayerPlane : public Sprite
{
public:
	//继承父类的构造方法
	using Sprite::Sprite;
	PlayerPlane();
	//发射子弹
	bool emitBullet();
private:
	
};
#endif // !PLAYERPLANE_H_

此时的PlayerPlane.cpp就可以处理发射子弹了

#include "PlayerPlane.h"
#include "EntityManager.h"
PlayerPlane::PlayerPlane()
{
	
}

bool PlayerPlane::emitBullet()
{
	Bullet* b = new Bullet;
	//添加子弹
	b->setPixmap(":/plane/Resource/images/bullet2.png");
	//设置子弹在主角上
	b->setPos(getPos() + QVector2D{ sizeImage().width() / 2.0f,0.0f });
	//子弹发出
	b->velocity().setY(-1);
	//添加进实体
	EntityManager::instance().addEntity(b);
    return false;
}

QGame.cpp

#include "QGame.h"
#include "Sprite.h"
#include "EntityManager.h"
#include "PlayerPlane.h"

#include <QApplication>
#include <QPainter>
#include <QKeyEvent>
#include <QMessageBox>

//定义一个静态指针，指向唯一对象
static QGame* ins = nullptr;
QGame* QGame::instance()
{
	return ins;
}

QGame::QGame(QWidget* parent) :QWidget(parent)
	, m_mainLoopTimer(new QTimer)
{
	//保证不存在调用多个QGame实例
	Q_ASSERT_X(ins == nullptr, "QGame", "已经存在一个QGame实例");
	ins = this;
}
QGame::~QGame()
{
	//清理
	clean();
}

//全局精灵类,注意这里必须使用指针类，如果是普通类对象会报错
//因为QT里面QApplication执行后是不允许对象还没有构造完的，指针是个不完整类就不会默认构造
PlayerPlane* player;

//游戏初始化
void QGame::init(const QSize& size, const QString& title)
{
	//设置窗口固定大小
	setFixedSize(size);
	//设置标题
	setWindowTitle(title);
	//开启鼠标自动追踪
	setMouseTracking(true);

	player = EntityManager::instance().addEntity(new PlayerPlane(":/plane/Resource/images/hero1.png"));
	
	//因为上面会有各种资源的初始化，如果初始化失败，那么m_isRunning=false;游戏不继续运行了
	//初始化成功就为true 
	m_isRunning = true;
}
//游戏反初始化
void QGame::clean()
{
}
//更新游戏
void QGame::update(int)
{
	//刷新销毁所有不需要的实体精灵
	EntityManager::instance().refresh();
	//更新实体精灵信息
	EntityManager::instance().update();
	//发射子弹
	player->emitBullet();
}
//渲染游戏
void QGame::render(QPainter* painter)
{
	EntityManager::instance().render(painter);
}
//游戏是否进行
bool QGame::isRuning() const
{
	return true;
}
//退出游戏
void QGame::quit()
{
	m_isRunning = false;
}
//运行游戏
void QGame::runGame()
{	
	//显示窗口
	show();
	//连接定时器
	m_mainLoopTimer->callOnTimeout([=]()
		{
			//如果游戏没有在运行，那么就结束游戏
			if (!isRuning())
			{
				m_mainLoopTimer->stop();
				qApp->quit();
			}

			//更新游戏,QGame的自定义update
			update(0);

			//重绘,父类的update
			QWidget::update();
			
			//测试游戏是否在进行
			//qDebug() << "游戏运行中";
		}
	);
	//开始定时器，设置游戏开启的帧数
	m_mainLoopTimer->start(m_fps);
}
//设置游戏帧率
void QGame::setFps(qreal fps)
{
	m_fps = fps;
}

//绘图事件
void QGame::paintEvent(QPaintEvent* ev)
{
	//开启画家
	QPainter painter(this);
	//渲染游戏
	render(&painter);
}

//捕获按键事件
void QGame::keyPressEvent(QKeyEvent* ev)
{
	switch (ev->key())
	{
	case Qt::Key_Up:
		player->velocity().setY(-1);
		break;
	case Qt::Key_Down:
		player->velocity().setY(1);
		break;
	case Qt::Key_Left:
		player->velocity().setX(-1);
		break;
	case Qt::Key_Right:
		player->velocity().setX(1);
		break;
	}
}

void QGame::keyReleaseEvent(QKeyEvent* ev)
{
	switch (ev->key())
	{
	case Qt::Key_Up:
	case Qt::Key_Down:
		player->velocity().setY(0);
		break;
	case Qt::Key_Left:
	case Qt::Key_Right:
		player->velocity().setX(0);
		break;
	}
}

void QGame::mouseMoveEvent(QMouseEvent* ev)
{
	//让鼠标居中到图片中间
	auto pos = player->sizeImage() / 2;
	player->setPos(ev->pos() - QPoint{ pos.width(),pos.height() });
}

背景图滚动

思路：因为沿着y轴移动，用两个变量来表示图片不同位置的y坐标，然后一个位置在窗口上，一个位置在窗口上方，让两个变量一直自增实现滚动像素，当窗口上的坐标大于窗口高度时，就把窗口上的y坐标重置为0，当窗口之上的坐标大于0时就把y坐标重置为一开始的窗口之上的坐标

Map::Map()
{
	//加载背景图
	m_pixmap.load(":/plane/Resource/images/background.png");
	//一个在窗口上面
	yPos1 = -m_pixmap.height();
	//一个在窗口上
	yPos2 = 0;
}
void Map::update()
{
	//实现滚动背景
	yPos1 += m_scrollSpeed;
	if (yPos1 >= 0)
	{
		yPos1 = -m_pixmap.height();
	}
	yPos2 += m_scrollSpeed;
	//大于等于窗口高度后重新置为0
	if (yPos2 >= qGame->height())
	{
		yPos2 = 0;
	}
}
void Map::render(QPainter* painter)
{
	painter->drawPixmap(0, yPos1, m_pixmap);
	painter->drawPixmap(0, yPos2, m_pixmap);
}

新建地图类继承实体类，然后去重写渲染与更新方法

Map.h

#ifndef MAP_H_
#define MAP_H_

#include "Entity.h"
class Map :public Entity
{
public:
	Map();

	// 通过 Entity 继承
	virtual void update() override;

	virtual void render(QPainter* painter) override;
private:
	QPixmap m_pixmap;
	//用来实现滚动
	int yPos1,yPos2;
	int m_scrollSpeed = 2;
};
#endif // !MAP_H_

Map.cpp

#include "Map.h"
#include "QGame.h"
Map::Map()
{
	//加载背景图
	m_pixmap.load(":/plane/Resource/images/background.png");
	//一个在窗口上面
	yPos1 = -m_pixmap.height();
	//一个在窗口上
	yPos2 = 0;
}

void Map::update()
{
	//实现滚动背景
	yPos1 += m_scrollSpeed;
	if (yPos1 >= 0)
	{
		yPos1 = -m_pixmap.height();
	}
	yPos2 += m_scrollSpeed;
	//大于等于窗口高度后重新置为0
	if (yPos2 >= qGame->height())
	{
		yPos2 = 0;
	}
}

void Map::render(QPainter* painter)
{
	painter->drawPixmap(0, yPos1, m_pixmap);
	painter->drawPixmap(0, yPos2, m_pixmap);
}

子弹与敌机碰撞

新建一个类用来存放应该enum，enum里面存放不同类别标识，现在就需要在子弹，player，敌机生成的时候设置类别，方便后面进行碰撞判断，在EntityManager中提供类别识别方法，注意识别类型要是活动的，不然就没意义，在Sprite中构造矩阵变量，在update方法中添加矩阵的构造，采用矩阵碰撞方式去检测碰撞，最后在QGame.cpp中去完成敌机的生成与碰撞。
基本完整框架如下：

main.cpp

#include <QApplication>
#include "QGame.h"

int main(int argc,char* argv[])
{
	QApplication a(argc, argv);
	QGame game;
	game.init({ 480,852 }, "小瓜");
	game.runGame();

	return a.exec();
}

QGame.h

#ifndef QGAME_H_
#define QGAME_H_
#include <QWidget>
#include <Qtimer>
//宏定义一下这个单例
#define qGame QGame::instance()

class QGame :public QWidget
{
	Q_OBJECT
public:
	//单例设计模式,让QGame实例只允许存在一个
	static QGame* instance();

	QGame(QWidget* parent = nullptr);
	~QGame();
	//游戏初始化
	void init(const QSize& size, const QString& title);
	//游戏反初始化
	void clean();
	//更新游戏，站位符与父类的方法做区别
	void update(int);
	//渲染游戏
	void render(QPainter* painter);
	//游戏是否进行
	bool isRuning() const;
	//退出游戏
	void quit();
	//运行游戏
	void runGame();
	//设置游戏帧率
	void setFps(qreal fps);

	//获取游戏帧数的接口
	qreal fps() const { return m_fps; }
protected:
	void paintEvent(QPaintEvent* ev) override;
	void keyPressEvent(QKeyEvent* ev) override;
	void keyReleaseEvent(QKeyEvent* ev) override;
	void mouseMoveEvent(QMouseEvent* ev) override;
private:
	//控制游戏进行的变量
	bool m_isRunning = false;
	//游戏的主循环
	QTimer* m_mainLoopTimer{};
	//游戏帧率60帧
	qreal m_fps = 1000 / 60;
};

#endif

QGame.cpp

#include "QGame.h"
#include "Sprite.h"
#include "EntityManager.h"
#include "PlayerPlane.h"
#include "Map.h"

#include <QApplication>
#include <QPainter>
#include <QKeyEvent>
#include <QMessageBox>
#include <QStringList>
//随机数头文件
#include <qrandom.h>

//宏定义这个随机生成器函数
#define qRand(min,max) QRandomGenerator::global()->bounded(min, max)

//定义一个静态指针，指向唯一对象
static QGame* ins = nullptr;
QGame* QGame::instance()
{
	return ins;
}

QGame::QGame(QWidget* parent) :QWidget(parent)
	, m_mainLoopTimer(new QTimer)
{
	//保证不存在调用多个QGame实例
	Q_ASSERT_X(ins == nullptr, "QGame", "已经存在一个QGame实例");
	ins = this;
}
QGame::~QGame()
{
	//清理
	clean();
}

//全局精灵类,注意这里必须使用指针类，如果是普通类对象会报错
//因为QT里面QApplication执行后是不允许对象还没有构造完的，指针是个不完整类就不会默认构造
PlayerPlane* player;

//游戏初始化
void QGame::init(const QSize& size, const QString& title)
{
	//设置窗口固定大小
	setFixedSize(size);
	//设置标题
	setWindowTitle(title);
	//开启鼠标自动追踪
	setMouseTracking(true);

	//初始化背景
	EntityManager::instance().addEntity(new Map);
	//初始化主角对象
	player = EntityManager::instance().addEntity(new PlayerPlane(":/plane/Resource/images/hero1.png"));
	player->setType(Player);

	//因为上面会有各种资源的初始化，如果初始化失败，那么m_isRunning=false;游戏不继续运行了
	//初始化成功就为true 
	m_isRunning = true;
}
//游戏反初始化
void QGame::clean()
{
}
//更新游戏
void QGame::update(int)
{
	//刷新销毁所有不需要的实体精灵
	EntityManager::instance().refresh();
	//更新实体精灵信息
	EntityManager::instance().update();

	
	static int BulletVelocity = 0;
	//发射子弹的速率
	if (BulletVelocity % 10 == 0)
	{
		//发射子弹
		player->emitBullet();
	}
	//出现敌机
	if (BulletVelocity % 60 == 0)
	{
		QStringList efile = { ":/plane/Resource/images/enemy1.png",":/plane/Resource/images/enemy2.png" };
		auto enemy = new Sprite(efile[qRand(0,2)]);
		//设置敌机从上面往下
		enemy->velocity().setY(1);
		//设置随机出现的敌机位置
		enemy->setPos(qRand(0, width()), -50);
		//设置类别
		enemy->setType(Enemy);
		//添加到精灵管理类中
		EntityManager::instance().addEntity(enemy);
	}

	//获取子弹列表
	auto bullet_list = EntityManager::instance().getSpriteByType(bullet);
	//获取敌机列表
	auto enemy_list = EntityManager::instance().getSpriteByType(Enemy);

	//遍历，查看是否矩形碰撞
	for (auto& e : enemy_list)
	{
		for (auto& b : bullet_list)
		{
			//判断敌机是否包含子弹，如果包含就释放掉子弹和敌机
			if (e->collider().intersects(b->collider()))
			{
				e->destroy();
				b->destroy();
				break;
			}
		}
	}
	BulletVelocity++;
	qDebug() <<"时间值：" << BulletVelocity;
}
//渲染游戏
void QGame::render(QPainter* painter)
{
	EntityManager::instance().render(painter);
}
//游戏是否进行
bool QGame::isRuning() const
{
	return true;
}
//退出游戏
void QGame::quit()
{
	m_isRunning = false;
}
//运行游戏
void QGame::runGame()
{	
	//显示窗口
	show();
	//连接定时器
	m_mainLoopTimer->callOnTimeout([=]()
		{
			//如果游戏没有在运行，那么就结束游戏
			if (!isRuning())
			{
				m_mainLoopTimer->stop();
				qApp->quit();
			}

			//更新游戏,QGame的自定义update
			update(0);

			//重绘,父类的update
			QWidget::update();
			
			//测试游戏是否在进行
			//qDebug() << "游戏运行中";
		}
	);
	//开始定时器，设置游戏开启的帧数
	m_mainLoopTimer->start(m_fps);
}
//设置游戏帧率
void QGame::setFps(qreal fps)
{
	m_fps = fps;
}

//绘图事件
void QGame::paintEvent(QPaintEvent* ev)
{
	//开启画家
	QPainter painter(this);
	//渲染游戏
	render(&painter);
}

//捕获按键事件
void QGame::keyPressEvent(QKeyEvent* ev)
{
	switch (ev->key())
	{
	case Qt::Key_Up:
		player->velocity().setY(-1);
		break;
	case Qt::Key_Down:
		player->velocity().setY(1);
		break;
	case Qt::Key_Left:
		player->velocity().setX(-1);
		break;
	case Qt::Key_Right:
		player->velocity().setX(1);
		break;
	}
}

void QGame::keyReleaseEvent(QKeyEvent* ev)
{
	switch (ev->key())
	{
	case Qt::Key_Up:
	case Qt::Key_Down:
		player->velocity().setY(0);
		break;
	case Qt::Key_Left:
	case Qt::Key_Right:
		player->velocity().setX(0);
		break;
	}
}

void QGame::mouseMoveEvent(QMouseEvent* ev)
{
	//让鼠标居中到图片中间
	auto pos = player->sizeImage() / 2;
	player->setPos(ev->pos() - QPoint{ pos.width(),pos.height() });
}

Entity.h

#ifndef ENTITY_H_
#define ENTITY_H_

#include "Global.h"
#include <QPainter>

class Entity
{
public:
	virtual ~Entity() {};//虚析构，当子类继承重写的时候就可以释放子类的内存
	virtual void update() = 0;//更新实体
	virtual void render(QPainter* painter) = 0;//渲染实体

	//接口
	bool active()const { return m_active; }
	int type()const { return m_type; }

	//状态销毁
	void destroy() { m_active = false; }

	//设置实体类型
	void setType(int type) { m_type = type; }
private:
	
	bool m_active = true;//实体是否是活动的
	int m_type = 0;//实体类型

};
#endif // !ENTITY_H_

Sprite.h

#ifndef SPRITE_H_
#define SPRITE_H_

#include "Entity.h"
#include <QVector2D>

class Sprite :public Entity
{
public:
	
	Sprite() = default;
	Sprite(const QString& fileName, const QSize& size = QSize());
	
	//接口
	QVector2D getPos()const { return m_pos; }
	QPixmap getPixmap()const { return m_image; }
	QVector2D velocity() const{ return m_velocity; }
	QVector2D& velocity() { return m_velocity; }
	QRect collider()const { return m_collider; }

	//设置坐标
	void setPos(float x, float y)
	{
		m_pos = { x,y };
	}
	void setPos(const QPointF& pos)
	{
		m_pos = { (float)pos.x(),(float)pos.y() };
	}
	void setPos(const QVector2D& pos) 
	{
		m_pos = pos; 
	}

	//设置速度分量
	void setVelocity(float vx, float vy)
	{
		m_velocity = { vx,vy };
	}
	//获取图片大小
	QSize sizeImage()const;
	//设置图片
	void setPixmap(const QString& fileName, const QSize& size = QSize());
	
	// 通过 Entity 继承
	void update() override;
	// 通过 Entity 继承
	void render(QPainter* painter) override;


private:
	QPixmap m_image;
	QVector2D m_pos;

	//移动速度
	float m_speed = 3;
	//速度分量
	QVector2D m_velocity;
	//碰撞器
	QRect m_collider{};
};
#endif // !SPRITE_H_

Sprite.cpp

#include "Sprite.h"

Sprite::Sprite(const QString& fileName, const QSize& size)
{
	setPixmap(fileName, size);
}

//获取精灵图片大小
QSize Sprite::sizeImage() const
{
	if (m_image.isNull())
	{
		return QSize();
	}
	return m_image.size();
}
//设置图片
void Sprite::setPixmap(const QString& fileName, const QSize& size)
{
	m_image.load(fileName);
	if (size.isValid())
	{
		//保持缩放	
		m_image.scaled(size, Qt::AspectRatioMode::KeepAspectRatio);
	}
}

void Sprite::update()
{
	//获取一下坐标
	float x = m_pos.x();
	float y = m_pos.y();
	//通过分量去改变坐标的速度，移动就比较正常一点
	x += m_velocity.x() * m_speed;
	y += m_velocity.y() * m_speed;
	//将坐标给m_pos
	m_pos = { x,y };

	//设置矩形
	m_collider = QRect(m_pos.x(), m_pos.y(), m_image.width(), m_image.height());
}

void Sprite::render(QPainter* painter)
{
	painter->drawPixmap(m_pos.toPoint(), m_image);
}

Bullet.h

#ifndef BULLET_H_
#define BULLET_H_

#include "Sprite.h"
class Bullet :public Sprite
{
public:
	//更新子弹出边界就得消失
	void update() override;
private:
	
};
#endif // !BULLET_H_

Bullet.cpp

#include "Bullet.h"
#include "QGame.h"
void Bullet::update()
{
	//继承父类的方法帮忙移动
	Sprite::update();
	//就可以调用游戏唯一的单例
	//如果子弹超出边界让子弹消失
	if (getPos().x() > qGame->width() || getPos().x() < 0 - sizeImage().width() ||
		getPos().y() > qGame->height() || getPos().y() < 0 - sizeImage().height())
	{
		destroy();
	}
}

PlayerPlane.h

#ifndef PLAYERPLANE_H_
#define PLAYERPLANE_H_

#include "Sprite.h"
#include "Bullet.h"
#include <array>
class PlayerPlane : public Sprite
{
public:
	//继承父类的构造方法
	using Sprite::Sprite;
	PlayerPlane();
	//发射子弹
	bool emitBullet();
private:
	
};
#endif // !PLAYERPLANE_H_

PlayerPlane.cpp

#include "PlayerPlane.h"
#include "EntityManager.h"
PlayerPlane::PlayerPlane()
{
	
}

bool PlayerPlane::emitBullet()
{
	Bullet* b = new Bullet;
	//添加子弹
	b->setPixmap(":/plane/Resource/images/bullet2.png");
	//设置子弹在主角上
	b->setPos(getPos() + QVector2D{ sizeImage().width() / 2.0f,0.0f });
	//子弹发出
	b->velocity().setY(-2);
	//设置类型
	b->setType(bullet);
	//添加进实体
	EntityManager::instance().addEntity(b);
    return false;
}

EntityManager.h

#ifndef		ENTITYMANAGER_H_
#define		ENTITYMANAGER_H_

#include"Sprite.h"
#include<QList>
#include<memory>
#include<QDebug>
class EntityManager
{
public:
	//得到唯一的实例
	static EntityManager& instance()
	{
		static EntityManager ev;
		return ev;
	}
	//更新管理的所有实体与精灵
	void update()
	{
		for (auto& e : m_entities)
		{
			e->update();
		}
	}
	//渲染
	void render(QPainter* painter)
	{
		for (auto& e : m_entities)
		{
			e->render(painter);
		}
	}
	
	//添加实体开个模版方便使用
	template<typename T = Entity>
	T* addEntity(T* e)
	{
		m_entities.emplaceBack(e);
		return e;
	}

	//刷新，如果有实体要消除，就在这里销毁
	void refresh()
	{
		m_entities.removeIf([](Entity* e)
			{
				//不是活动的就释放
				if (!e->active())
				{
					//测试输出
					qDebug() << "destoryed" << e;
					//释放这个实体
					delete e;
					return true;
				}
				return false;
			});
		//测试输出
		qDebug() << m_entities.size();
	}

	//获取类别，好做碰撞
	QList<Sprite*> getSpriteByType(int type)
	{
		QList<Sprite*> s;
		for (auto& e : m_entities)
		{
			//要是活动的
			if(e->type()==type && e->active())
			{
				s.append(dynamic_cast<Sprite*>(e));
			}
		}
		return s;
	}
private:
	QList<Entity*> m_entities;
	//构造函数私有化，设计单例
	EntityManager() {}
};

#endif

Map.h

#ifndef MAP_H_
#define MAP_H_

#include "Entity.h"
class Map :public Entity
{
public:
	Map();

	// 通过 Entity 继承
	virtual void update() override;

	virtual void render(QPainter* painter) override;
private:
	QPixmap m_pixmap;
	//用来实现滚动
	int yPos1,yPos2;
	int m_scrollSpeed = 2;
};
#endif // !MAP_H_

Map.cpp

#include "Map.h"
#include "QGame.h"
Map::Map()
{
	//加载背景图
	m_pixmap.load(":/plane/Resource/images/background.png");
	//一个在窗口上面
	yPos1 = -m_pixmap.height();
	//一个在窗口上
	yPos2 = 0;
}

void Map::update()
{
	//实现滚动背景
	yPos1 += m_scrollSpeed;
	if (yPos1 >= 0)
	{
		yPos1 = -m_pixmap.height();
	}
	yPos2 += m_scrollSpeed;
	//大于等于窗口高度后重新置为0
	if (yPos2 >= qGame->height())
	{
		yPos2 = 0;
	}
}

void Map::render(QPainter* painter)
{
	painter->drawPixmap(0, yPos1, m_pixmap);
	painter->drawPixmap(0, yPos2, m_pixmap);
}

Global.h

#ifndef GLOBAL_H_
#define GLOBAL_H_

enum EntityType
{
	None,
	Player,
	Enemy,
	bullet
};

#endif

运行结果

在这里插入图片描述

Qt planeGame day10

Qt planeGame day10

Game基本框架

QGame.h

QGame.cpp

mian.cpp

构建精灵与实体类

实体类

Entity.h

精灵类

Sprite.h

Sprite.cpp

QGame.cpp

精灵移动

QGame.h

QGame.cpp

子弹类，飞机类与单例设计模式

QGame.h

QGame.cpp

PlayerPlane.h

Bullte.h

Bullte.cpp

精灵管理类

EntityManager.h

PlayerPlane.h

此时的PlayerPlane.cpp就可以处理发射子弹了

QGame.cpp

背景图滚动

Map.h

Map.cpp

子弹与敌机碰撞

main.cpp

QGame.h

QGame.cpp

Entity.h

Sprite.h

Sprite.cpp

Bullet.h

Bullet.cpp

PlayerPlane.h

PlayerPlane.cpp

EntityManager.h

Map.h

Map.cpp

Global.h

运行结果

相关文章