new event, added walls

src/Entity.cpp

@@ -1 +0,0 @@
-#include "Entity.h"

src/Entity.h

@@ -1,5 +0,0 @@
-#pragma once
-
-class Entity {
-
-};

src/Event.h

@@ -55,4 +55,8 @@ class Player;
 struct WallJumpEvent : GameEvent {
 	double wallHeight = 0;
 	Player * player = nullptr;
+};
+
+struct WallCrashEvent : GameEvent {
+	Player * player = nullptr;
 };

src/Game.cpp

@@ -2,19 +2,38 @@
 #include "Game.h"
 #include "InputWindow.h"
 #include "Window.h"
+#include <random>
 
 void Game::draw(QPixmap &output) {
 	QPainter p(&output);
 
-	p.drawText(50, 50, QString::fromStdString(std::to_string(int(window->currentFPS))));
 	for (auto & spectator : spectators)
 		spectator.draw(p);
+	for (auto & wall : walls)
+		wall.draw(p);
 	player.draw(p);
 }
 
 void Game::update(float dTime) {
 	eTime += dTime;
-	player.update(dTime);
+	player.update(dTime, walls);
+	for (auto & wall : walls)
+		wall.update(dTime);
+	tryCreateWall();
+	removeWalls();
+}
+
+void Game::tryCreateWall() {
+	int val = rand() % 1000;
+	if (val > 990){
+		walls.emplace_back();
+	}
+}
+
+void Game::removeWalls() {
+	erase_if(walls, [](const Wall& wall){
+		return wall.isLost();
+	});
 }
 
 Game::Game() {
@@ -27,3 +46,4 @@ Game::Game() {
 
 GameQueue * Game::eventQueue = new GameQueue;
 Game * Game::instance = nullptr;
+

src/Game.h

@@ -3,6 +3,7 @@
 #include "Queue.h"
 #include "Player.h"
 #include "Spectator.h"
+#include "Wall.h"
 
 #define WIDTH 1000
 #define HEIGHT 500
@@ -13,8 +14,12 @@ class Window;
 class Game {
 	Player player;
 	std::vector<Spectator> spectators {5};
+	std::vector<Wall> walls;
+	void tryCreateWall();
+	void removeWalls();
 public:
-	Window * window;
+	Window * window = nullptr;
+	// seconds
 	float eTime = 0;
 	static Game * instance;
 	static GameQueue * eventQueue;

src/Listener.cpp

@@ -3,6 +3,8 @@
 void GameListener::accept(GameEvent *event) {
 	if (auto wallJumpEvent = dynamic_cast<WallJumpEvent *>(event))
 		OnWallJumped(wallJumpEvent);
+	if (auto wallCrashEvent = dynamic_cast<WallCrashEvent *>(event))
+		OnWallCrashed(wallCrashEvent);
 }
 
 void InputListener::accept(InputEvent *event) {

src/Listener.h

@@ -27,4 +27,5 @@ public:
 	void accept(GameEvent * event) override;
 protected:
 	virtual void OnWallJumped(WallJumpEvent * event) {};
+	virtual void OnWallCrashed(WallCrashEvent * event) {};
 };

src/Player.cpp

@@ -4,26 +4,20 @@
 #include "Game.h"
 
 void Player::mousePressed(MouseEvent *event) {
-	if (pos.y() == GROUND_Y && event->button == Qt::MouseButton::LeftButton){
+	if (pos.y() == GROUND_Y && event->button == Qt::MouseButton::LeftButton)
 		jump();
-		auto e = new WallJumpEvent;
-		e->time = Game::instance->eTime;
-		e->player = this;
-		e->wallHeight = 100;
-		Game::eventQueue->submitEvent(e);
-	}
 }
 
 void Player::draw(QPainter &painter) const {
 	painter.save();
 
 	painter.translate(pos.toPoint());
-	painter.fillRect(-5, -5, 10, 10, Qt::black);
+	painter.fillRect(-5, -10, 10, 10, Qt::black);
 
 	painter.restore();
 }
 
-void Player::update(float dTime) {
+void Player::update(float dTime, std::vector<Wall> &walls) {
 	pos += vel * dTime;
 	vel += acc * dTime;
 
@@ -31,6 +25,28 @@ void Player::update(float dTime) {
 		pos.setY(GROUND_Y);
 		vel = {};
 	}
+
+	for (auto &wall : walls){
+		if (!wall.jumped && !wall.failed){
+			if (pos.x() > wall.pos.x() - wall.size.width() / 2
+			&&  pos.x() < wall.pos.x() + wall.size.width() / 2){
+				if (pos.y() < wall.pos.y() - wall.size.height()){
+					wall.jumped = true;
+					auto e = new WallJumpEvent;
+					e->time = Game::instance->eTime;
+					e->player = this;
+					e->wallHeight = wall.size.height();
+					Game::eventQueue->submitEvent(e);
+				} else {
+					wall.failed = true;
+					auto e = new WallCrashEvent;
+					e->time = Game::instance->eTime;
+					e->player = this;
+					Game::eventQueue->submitEvent(e);
+				}
+			}
+		}
+	}
 }
 
 void Player::jump() {

src/Player.h

@@ -2,10 +2,10 @@
 
 #include "Listener.h"
 #include "Event.h"
-#include "Entity.h"
+#include "Wall.h"
 #include <QPainter>
 
-class Player : public Entity, public InputListener {
+class Player : public InputListener {
 	QVector2D pos {50, 50};
 	QVector2D vel {};
 	QVector2D acc {0, 9.81 * 30};
@@ -13,7 +13,7 @@ class Player : public Entity, public InputListener {
 	void jump();
 public:
 	void draw(QPainter &painter) const;
-	void update(float dTime);
+	void update(float dTime, std::vector<Wall>&);
 
 protected:
 	void mousePressed(MouseEvent *) override;

src/Spectator.cpp

@@ -7,6 +7,13 @@ void Spectator::OnWallJumped(WallJumpEvent *event) {
 	std::cout << "Wall jump at " << event->time << std::endl;
 }
 
+void Spectator::OnWallCrashed(WallCrashEvent *event) {
+	std::cout << "Wall crash at " << event->time << std::endl;
+}
+
+
 void Spectator::draw(QPainter &painter) const {
 
 }
+
+

src/Spectator.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include "Entity.h"
 #include "Listener.h"
 
-class Spectator : public Entity, public GameListener {
+class Spectator : public GameListener {
 protected:
 	void OnWallJumped(WallJumpEvent * event) override;
+	void OnWallCrashed(WallCrashEvent * event) override;
 public:
 	void draw(QPainter &painter) const;
 };

src/Wall.cpp

@@ -0,0 +1,26 @@
+#include "Wall.h"
+#include "Game.h"
+
+void Wall::draw(QPainter &painter) const {
+	painter.save();
+
+	int w = size.width();
+	int h = size.height();
+	painter.translate(pos.toPoint());
+	painter.fillRect(w / 2, -h, w, h, Qt::black);
+
+	painter.restore();
+}
+
+void Wall::update(float dTime) {
+	pos.setX(pos.x() - dTime * velocity);
+}
+
+Wall::Wall() {
+	pos = {WIDTH, GROUND_Y};
+	size = {50, 50};
+}
+
+bool Wall::isLost() const {
+	return pos.x() < -100;
+}

src/Wall.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <QPainter>
+#include <QVector2D>
+
+class Wall {
+	float velocity = 300;
+public:
+	bool jumped = false;
+	bool failed = false;
+	QVector2D pos;
+	QSize size;
+	bool isLost() const;
+	explicit Wall();
+	void draw(QPainter &painter) const;
+	void update(float dTime);
+};