Ocena kodu źródłowego.

Question

Witam, proszę o ocenę kodu źródłowego. Ma on za zadanie wykrywanie, czy nastąpiła kolizja skrzynki z graczem i jeżeli tak się stało, to poinformowanie o tym obu obiektów.

Gameplay.cpp (fragment zastosowania)

void Gameplay::detectCollisions()
{
	CollisionDetector collisionDetector;
	for (const auto& player : data->players) 
		for (const auto& box : data->boxes) 
			if (collisionDetector.detect(*player, *box)) 
				collisionDetector.informAboutCollision(*player, *box);
}

CollisionDetector.h

#pragma once

#include <array>
#include <SFML/Graphics.hpp>

class Player;
class Box;

class CollisionDetector {
public:
	bool detect(Player& player, Box& box);

	void captureBounds(const sf::FloatRect& bounds);

	void informAboutCollision(Player& player, Box& box) const;

private:
	std::array<sf::FloatRect, 2> capturedBounds;
	unsigned countOfCapturedBounds = 0;
};

CollisionDetector.cpp

#include "CollisionDetector.h"
#include "Player.h"
#include "Box.h"

bool CollisionDetector::detect(Player& player, Box& box)
{
	player.informAboutBounds(*this);
	box.informAboutBounds(*this);
	countOfCapturedBounds = 0;
	return capturedBounds[0].intersects(capturedBounds[1]);
}

void CollisionDetector::captureBounds(const sf::FloatRect& bounds)
{
	if (countOfCapturedBounds == 0)
		capturedBounds[0] = bounds;
	else if (countOfCapturedBounds == 1)
		capturedBounds[1] = bounds;
	countOfCapturedBounds++;
}

void CollisionDetector::informAboutCollision(Player& player, Box& box) const
{
	player.onCollide(box);
	box.onCollide(player);
}

Player.h

#pragma once

#include <SFML/Graphics.hpp>

class Box;
class CollisionDetector;

class Player {
public:
	void informAboutBounds(CollisionDetector& collisionDetector) const;

	void onCollide(const Box&);

private:
	sf::Sprite sprite;
}

Player.cpp

#include "Player.h"
#include "CollisionDetector.h"
#include "Box.h"

void Player::informAboutBounds(CollisionDetector& collisionDetector) const
{
	const sf::FloatRect bounds = sprite.getGlobalBounds();
	collisionDetector.captureBounds(bounds);
}

void Player::onCollide(const Box&)
{
	// Kod reagujacy na kolizje ze skrzynka.
}

Box.h

#pragma once

#include <SFML/Graphics.hpp>

class Player;
class CollisionDetector;

class Box {
public:
	void informAboutBounds(CollisionDetector& collisionDetector) const;

	void onCollide(const Player&);

private:
	sf::Sprite sprite;
};

Box.cpp

#include "Box.h"
#include "CollisionDetector.h"
#include "Player.h"

void Box::informAboutBounds(CollisionDetector& collisionDetector) const
{
	const sf::FloatRect bounds = data.sprite.getGlobalBounds();
	collisionDetector.captureBounds(bounds);
}

void Box::onCollide(const Player&)
{
	// Kod reagujacy na kolizje z graczem.
}

Answer 1

Pomyśl o klasie wirtualnej:

class GameObject
{
public:
   GameObject(){}
   ~GameObject(){}
   void informAboutBounds(/*...*/);
  // Możesz zrobić nawet
  // virtual void informAboutBounds(/*...*/);
  // Jeżeli czymś się różnią w klasach pochodnych.
protected:
   sf::Sprite sprite;
};

class Player :public GameObject
{
public:
  // virtual void informAboutBounds(/*...*/);
private:

};

Ułatwi ci to zadanie w przyszłości i pozwoli na więcej.