Using smart pointers

game/game.cpp

@@ -132,7 +132,7 @@ void Game::GameLoop(sf::Time elapsed_time, float& countdown, Timer& powerup_cloc
     map->Draw(window);
 
     // Update players
-    std::map<std::size_t, Player*>::const_iterator itr = _game_object_manager._game_objects.begin();
+    std::map<std::size_t, std::shared_ptr<Player>>::const_iterator itr = _game_object_manager._game_objects.begin();
     while (itr != _game_object_manager._game_objects.end()) {
         itr->second->rect.setPosition(SCALE * itr->second->body->GetPosition().x, SCALE * itr->second->body->GetPosition().y);
         itr->second->rect.setRotation(itr->second->body->GetAngle() * 180 / b2_pi);
@@ -162,9 +162,9 @@ void Game::GameLoop(sf::Time elapsed_time, float& countdown, Timer& powerup_cloc
     }
 
     // Player-Player collision
-    std::map<std::size_t, Player*>::const_iterator iter = _game_object_manager._game_objects.begin();
+    std::map<std::size_t, std::shared_ptr<Player>>::const_iterator iter = _game_object_manager._game_objects.begin();
     while (iter != _game_object_manager._game_objects.end() && countdown > 0) { // Stop collisions after game ends
-        std::map<std::size_t, Player*>::const_iterator iter2 = _game_object_manager._game_objects.begin();
+        std::map<std::size_t, std::shared_ptr<Player>>::const_iterator iter2 = _game_object_manager._game_objects.begin();
         while (iter2 != _game_object_manager._game_objects.end()) {
             if (iter->second->rectB.getGlobalBounds().intersects(iter2->second->rectA.getGlobalBounds())) {
                 iter->second->score += 1;
@@ -281,21 +281,21 @@ void Game::CreateRound(std::size_t players_num, std::size_t level_number, b2Worl
 
 void Game::LoadPlayers(std::size_t number_of_players) {
     // Create them again
-    player1 = new Player();
-    player2 = new Player();
+    player1 = std::make_shared<Player>();
+    player2 = std::make_shared<Player>();
     SpawnPlayer(1, player1, amnesia_blue, sf::Keyboard::Key::W, sf::Keyboard::Key::A, sf::Keyboard::Key::D);
     SpawnPlayer(2, player2, amnesia_red, sf::Keyboard::Key::Up, sf::Keyboard::Key::Left, sf::Keyboard::Key::Right);
     if (number_of_players > 2 && number_of_players < 5) {
-        player3 = new Player();
+        player3 = std::make_shared<Player>();
         SpawnPlayer(3, player3, amnesia_dark_blue, sf::Keyboard::Key::T, sf::Keyboard::Key::F, sf::Keyboard::Key::H);
         if (number_of_players == 4) {
-            player4 = new Player();
+            player4 = std::make_shared<Player>();
             SpawnPlayer(4, player4, amnesia_dark_red, sf::Keyboard::Key::I, sf::Keyboard::Key::J, sf::Keyboard::Key::L);
         }
     }
 }
 
-void Game::SpawnPlayer(std::size_t number, Player* player, sf::Color color, sf::Keyboard::Key jump, sf::Keyboard::Key left, sf::Keyboard::Key right) {
+void Game::SpawnPlayer(std::size_t number, std::shared_ptr<Player> player, sf::Color color, sf::Keyboard::Key jump, sf::Keyboard::Key left, sf::Keyboard::Key right) {
     // Player controls configurations
     player->number = number;
     player->jump = jump;
@@ -313,7 +313,7 @@ void Game::LoadResources() {
 
     // Default spawn locations
     spawn_locations.push_back(b2Vec2(GAME_WIDTH/3, GAME_HEIGHT/3));
-    spawn_locations.push_back(b2Vec2(GAME_WIDTH - GAME_WIDTH/3, GAME_HEIGHT/3));
+    spawn_locations.push_back(b2Vec2(GAME_WIDTH - GAME_WIDTH/3 + 25, GAME_HEIGHT/3));
     spawn_locations.push_back(b2Vec2(GAME_WIDTH/6, GAME_HEIGHT - GAME_HEIGHT/3));
     spawn_locations.push_back(b2Vec2(GAME_WIDTH - GAME_WIDTH/6, GAME_HEIGHT - GAME_HEIGHT/3));
 
@@ -332,7 +332,7 @@ void Game::LoadResources() {
     background_music.play();
 }
 
-void Game::CreatePlayer(b2World& world, Player* player, int x, int y) {
+void Game::CreatePlayer(b2World& world, std::shared_ptr<Player> player, int x, int y) {
     // Creating physics body
     const float density = 1;
     player->bodydef.type = b2_dynamicBody;
@@ -393,7 +393,7 @@ void Game::WinnerCheck() {
 }
 
 void Game::ResetPowerups() {
-    std::map<std::size_t, Player*>::const_iterator iter = _game_object_manager._game_objects.begin();
+    std::map<std::size_t, std::shared_ptr<Player>>::const_iterator iter = _game_object_manager._game_objects.begin();
     while (iter != _game_object_manager._game_objects.end()) {
         if (iter->second->powered_up) {
             PowerUp::ResetPowerupEffects(iter);
@@ -410,7 +410,7 @@ void Game::EndRound() {
     auto i = 1;
 
     // Delete players physics bodies
-    std::map<std::size_t, Player*>::const_iterator iter = _game_object_manager._game_objects.begin();
+    std::map<std::size_t, std::shared_ptr<Player>>::const_iterator iter = _game_object_manager._game_objects.begin();
     while (iter != _game_object_manager._game_objects.end()) {
         iter->second->body->GetWorld()->DestroyBody(iter->second->body);
         _game_object_manager.Remove(i);

game/game.h

@@ -21,8 +21,8 @@ class Game {
     void LoadResources();
     void CreateRound(std::size_t players_num, std::size_t level_number, b2World& world);
     void LoadPlayers(std::size_t number_of_players);
-    void SpawnPlayer(std::size_t number, Player* player, sf::Color color, sf::Keyboard::Key jump, sf::Keyboard::Key left, sf::Keyboard::Key right);
-    void CreatePlayer(b2World& world, Player* player, int x, int y);
+    void SpawnPlayer(std::size_t number, std::shared_ptr<Player> player, sf::Color color, sf::Keyboard::Key jump, sf::Keyboard::Key left, sf::Keyboard::Key right);
+    void CreatePlayer(b2World& world, std::shared_ptr<Player> player, int x, int y);
 
     void TitleScreen();
     void ModeSelect();
@@ -55,10 +55,10 @@ class Game {
     class ModeSelect* mode_select;
     class LevelSelect* levelselect;
 
-    Player* player1;
-    Player* player2;
-    Player* player3;
-    Player* player4;
+    std::shared_ptr<Player> player1;
+    std::shared_ptr<Player> player2;
+    std::shared_ptr<Player> player3;
+    std::shared_ptr<Player> player4;
     Map* map;
 
     sf::Texture control_texture;

game/game_object_manager.cpp

@@ -2,30 +2,26 @@
 #include "game_object_manager.h"
 #include "game.h"
 
-GameObjectManager::GameObjectManager() {}
+GameObjectManager::GameObjectManager() = default;
 
-GameObjectManager::~GameObjectManager() {
-    std::for_each(_game_objects.begin(), _game_objects.end(), 
-        GameObjectDeallocator());
-}
+GameObjectManager::~GameObjectManager() = default;
 
-void GameObjectManager::Add(std::size_t number, Player* game_object) {
+void GameObjectManager::Add(std::size_t number, std::shared_ptr<Player> game_object) {
     _game_objects.insert(
-        std::pair<std::size_t, Player*>(number, game_object)
+        std::pair<std::size_t, std::shared_ptr<Player>>(number, game_object)
     );
 }
 
 void GameObjectManager::Remove(std::size_t number) {
-    std::map<std::size_t, Player*>::iterator results =
+    std::map<std::size_t, std::shared_ptr<Player>>::iterator results =
         _game_objects.find(number);
     if (results != _game_objects.end()) {
-        delete results->second;
         _game_objects.erase(results);
     }
 }
 
-Player* GameObjectManager::Get(std::size_t number) const {
-    std::map<std::size_t, Player*>::const_iterator results =
+std::shared_ptr<Player> GameObjectManager::Get(std::size_t number) const {
+    std::map<std::size_t, std::shared_ptr<Player>>::const_iterator results =
         _game_objects.find(number);
     if (results == _game_objects.end()) {
         return NULL;
@@ -38,7 +34,7 @@ int GameObjectManager::GetObjectCount() const {
 }
 
 void GameObjectManager::DrawAll(sf::RenderWindow& render_window) {
-    std::map<std::size_t, Player*>::const_iterator itr =
+    std::map<std::size_t, std::shared_ptr<Player>>::const_iterator itr =
         _game_objects.begin();
     while (itr != _game_objects.end()) {
         itr->second->Draw(render_window);

game/game_object_manager.h

@@ -7,21 +7,15 @@ class GameObjectManager {
     GameObjectManager();
     ~GameObjectManager();
 
-    void Add(std::size_t number, Player* game_object);
+    void Add(std::size_t number, std::shared_ptr<Player> game_object);
     void Remove(std::size_t number);
     int GetObjectCount() const;
-    Player* Get(std::size_t number) const;
+    std::shared_ptr<Player> Get(std::size_t number) const;
     static sf::Clock& GetClock();
 
     void DrawAll(sf::RenderWindow& render_window);
-    std::map<std::size_t, Player*> _game_objects;
+    std::map<std::size_t, std::shared_ptr<Player>> _game_objects;
 
 private:
     static sf::Clock _clock;
-
-    struct GameObjectDeallocator {
-        void operator() (const std::pair<std::size_t, Player*>& p) const {
-            delete p.second;
-        }
-    };
 };

game/hud.cpp

@@ -48,7 +48,7 @@ HUD::HUD(std::size_t number_of_players) {
     winner_text.setString("PX WON"); // placeholder string
 }
 
-void HUD::Update(std::map<std::size_t, Player*>::const_iterator &iter, float countdown) {
+void HUD::Update(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator &iter, float countdown) {
     for (auto i = 0u; i < number_of_players; ++i) {
         score_array[i].setString(std::to_string(iter->second->score));
         ++iter;

game/hud.h

@@ -6,7 +6,7 @@
 class HUD {
 public:
     HUD(std::size_t number_of_players);
-    void Update(std::map<std::size_t, Player*>::const_iterator &iter, float coundown);
+    void Update(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator &iter, float coundown);
     void Draw(sf::RenderWindow& window);
     std::vector<sf::Text> score_array;
 

game/powerup.cpp

@@ -41,18 +41,18 @@ PowerUp::PowerUp() {
     sprite.setTextureRect(sf::IntRect(0, 0, rect.getLocalBounds().width, rect.getLocalBounds().height));
 }
 
-void PowerUp::Invisibility(std::map<std::size_t, Player*>::const_iterator& iter) {
+void PowerUp::Invisibility(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter) {
     auto color = iter->second->sprite.getColor();
     color.a = 70;
     iter->second->sprite.setColor(color);
 }
 
-void PowerUp::Speed(std::map<std::size_t, Player*>::const_iterator& iter) {
+void PowerUp::Speed(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter) {
     iter->second->max_speed = 30.f;
     iter->second->jump_impulse = 20.f;
 }
 
-void PowerUp::Rage(std::map<std::size_t, Player*>::const_iterator& iter) {
+void PowerUp::Rage(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter) {
     iter->second->rectA.setSize(sf::Vector2f(0, 0));
     iter->second->rectB.setSize(sf::Vector2f(70, 110)); // Some magic numbers
     iter->second->rectB.setOrigin(sf::Vector2f(35, 100));
@@ -61,17 +61,17 @@ void PowerUp::Rage(std::map<std::size_t, Player*>::const_iterator& iter) {
     iter->second->sprite.setTexture(iter->second->inverted_texture);
 }
 
-void PowerUp::Floaty(std::map<std::size_t, Player*>::const_iterator& iter) {
+void PowerUp::Floaty(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter) {
     iter->second->body->SetGravityScale(0.2f);
 }
 
-void PowerUp::Immunity(std::map<std::size_t, Player*>::const_iterator& iter) {
+void PowerUp::Immunity(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter) {
     iter->second->rectA.setSize(sf::Vector2f(0, 0));
     iter->second->sprite.setTexture(iter->second->immune_texture);
     iter->second->fixturedef.density = 9;
 }
 
-void PowerUp::ResetPowerupEffects(std::map<std::size_t, Player*>::const_iterator& iter) {
+void PowerUp::ResetPowerupEffects(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter) {
     // Reset speed
     iter->second->max_speed = 10.f;
     iter->second->jump_impulse = 15.f;

game/powerup.h

@@ -8,13 +8,13 @@ class PowerUp : public Entity {
     void Draw(sf::RenderWindow& window);
     void Update(float countdown);
 
-    void Invisibility(std::map<std::size_t, Player*>::const_iterator& iter);
-    void Speed(std::map<std::size_t, Player*>::const_iterator& iter);
-    void Rage(std::map<std::size_t, Player*>::const_iterator& iter);
-    void Floaty(std::map<std::size_t, Player*>::const_iterator& iter);
-    void Immunity(std::map<std::size_t, Player*>::const_iterator& iter);
+    void Invisibility(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter);
+    void Speed(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter);
+    void Rage(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter);
+    void Floaty(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter);
+    void Immunity(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter);
 
-    static void ResetPowerupEffects(std::map<std::size_t, Player*>::const_iterator& iter);
+    static void ResetPowerupEffects(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator& iter);
 
     float floating_effect = 7.f;
     float rotation = 50.f;

game/spring.cpp

@@ -11,7 +11,7 @@ void Spring::Draw(sf::RenderWindow& window) {
     window.draw(sprite);
 }
 
-void Spring::Update(std::map<std::size_t, Player*>::const_iterator &iter, sf::Time elapsed_time) {
+void Spring::Update(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator &iter, sf::Time elapsed_time) {
     sprite.setPosition(rect.getPosition());
     sprite.setRotation(rect.getRotation());
 

game/spring.h

@@ -6,7 +6,7 @@ class Spring : public Entity {
 public:
     Spring();
     void Draw(sf::RenderWindow& window);
-    void Update(std::map<std::size_t, Player*>::const_iterator &iter, sf::Time elapsed_time);
+    void Update(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator &iter, sf::Time elapsed_time);
 
 private:
     float spring_propulsion = 100000.f;

game/stdafx.h

@@ -12,6 +12,7 @@
 
 #include <map>
 #include <iostream>
+#include <memory>
 #include <cassert>
 #include <cmath>
 #include <string>

game/teleport_pad.cpp

@@ -12,7 +12,7 @@ void TeleportPad::SetDestination(b2Vec2 destination) {
     this->destination = destination;
 }
 
-void TeleportPad::Update(std::map<std::size_t, Player*>::const_iterator &iter, sf::Time elapsed_time) {
+void TeleportPad::Update(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator &iter, sf::Time elapsed_time) {
     sprite.setPosition(rect.getPosition());
     sprite.setRotation(rect.getRotation());
 

game/teleport_pad.h

@@ -9,7 +9,7 @@ class TeleportPad : public Entity {
     TeleportPad();
     void SetDestination(b2Vec2 destination);
 
-    void Update(std::map<std::size_t, Player*>::const_iterator &iter, sf::Time elapsed_time);
+    void Update(std::map<std::size_t, std::shared_ptr<Player>>::const_iterator &iter, sf::Time elapsed_time);
     void Draw(sf::RenderWindow& window);
 
     sf::Texture tpad_texture;