replaced vectors with lists for easier managment.

game/game.cpp

@@ -51,8 +51,8 @@ bool Game::cycle(float dt)
         float angle = 360.0 * util::randf_0_1();
         float speed = 0.005;
 
-        m_state->players[0]->addCommand(new game::SetSpeedCommand(speed));
+        m_state->players.back()->addCommand(new game::SetSpeedCommand(speed));
-        m_state->players[0]->addCommand(new game::ShootCommand(angle));
+        m_state->players.back()->addCommand(new game::ShootCommand(angle));
 
         //static bool done = false;
         //if (total >= 10.0 && !done) {

game/state/commands.cpp

@@ -58,16 +58,17 @@ namespace game {
     {
         std::cout<<"clearing traces!!!" << std::endl;
 
-        size_t i = 0;
+        std::vector<Trace*> rm;
-        while(i < state->traces.size()) {
-            Trace *trace = state->traces[i];
-            if (trace->missile == nullptr && trace->player == player) {
-                state->deleteTrace(i);
 
-            } else {
+        for (Trace *trace : state->traces) {
-                i++;
+            if (trace->missile == nullptr && trace->player == player) {
+                rm.push_back(trace);
             }
         }
+
+        for (Trace *trace : rm) {
+            state->traces.remove(trace);
+        }
     }
 
 #if 0

game/state/missile.cpp

@@ -23,7 +23,7 @@ namespace game {
 
     Missile::~Missile()
     {
-        //std::cout<<"destroyed missile" << std::endl;
+        //std::cout<<"~Missile" << std::endl;
     }
 
     Missile::Event Missile::advance(const game::State *state, float dt)

game/state/player.hpp

@@ -2,7 +2,7 @@
 
 #include <string>
 #include <deque>
-#include <vector>
+#include <list>
 
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
@@ -21,7 +21,7 @@ namespace game {
         float      deadTimeCounter;
         Ship      *ship;
         std::string name;
-        std::vector<Missile*> missiles;
+        std::list<Missile*> missiles;
 
         Player(int id) : id(id), alive(true), speed(0.01), energy(0.0), ship(nullptr), name("<unnamed>")
         {

game/state/state.cpp

@@ -18,8 +18,6 @@
 
 #include "util.hpp"
 
-using namespace std;
-
 namespace game {
     void State::init()
     {
@@ -77,13 +75,21 @@ namespace game {
 
     void State::quitPlayer(int playerId)
     {
-        (void) playerId;
+		std::cout << playerId << " quit" << std::endl;
-        cout << playerId << " quit" << endl;
+
+		Player *player = playerForId(playerId);
+		if (player != nullptr) {
+			for (Missile *missile : player->missiles) {
+				missile->player = nullptr;
+			}
+
+			players.remove(player);
+		}
     }
 
     void State::clear(int playerId)
     {
-        cout << playerId << " clear" << endl;
+		std::cout << playerId << " clear" << std::endl;
     }
 
     void State::setName(int playerId, std::string name)
@@ -158,13 +164,7 @@ namespace game {
         std::cout<<"player " << killer->id << " killed " << victim->id << std::endl;
 
         // destroy ship
-        size_t i;
+		ships.remove(victim->ship);
-        for (i=0; i<ships.size(); i++) {
-            if (ships[i] == victim->ship) {
-                ships.erase(ships.begin() + i);
-                break;
-            }
-        }
 
         delete(victim->ship);
         victim->ship = nullptr;
@@ -181,11 +181,11 @@ namespace game {
 
     void State::advancePlayerMissiles(float dt)
     {
+		std::vector<Missile*> rm;
+
         // advance missiles
         for (Player *player : players) {
-            size_t i = 0;
+			for (Missile *missile : player->missiles) {
-            while (i<player->missiles.size()) {
-                Missile *missile = player->missiles[i];
 
                 //std::cout<<"missile: " << (long unsigned int) missile << std::endl;
                 const Missile::Event evt = missile->advance(this, dt);
@@ -196,59 +196,59 @@ namespace game {
                     missile->trace->addPointFromMissile(isHit); // force point if missile gets destroyed a
                 }
 
-                if (!isHit) {
+				if (!isHit) {
-                    i++;
+					continue;
+				}
 
-                } else {
+				switch(evt.hit) {
-                    switch(evt.hit) {
+					case Hit::Planet:
-                        case Hit::Planet:
+						//std::cout<<"hit Planet" << std::endl;
-                            //std::cout<<"hit Planet" << std::endl;
+						break;
-                            break;
 
-                        case Hit::Ship:
+					case Hit::Ship:
-                            //std::cout<<"hit Player" << std::endl;
+						//std::cout<<"hit Player" << std::endl;
-                            playerKillsPlayer(playerForId(evt.playerIdKiller), playerForId(evt.playerIdVictim));
+						playerKillsPlayer(playerForId(evt.playerIdKiller), playerForId(evt.playerIdVictim));
-                            break;
+						break;
 
-                        case Hit::BorderOfUniverse:
+					case Hit::BorderOfUniverse:
-                            //std::cout<<"missile left the universe." << std::endl;
+						//std::cout<<"missile left the universe." << std::endl;
-                            break;
+						break;
 
-                        default:
+					default:
-                            break;
+						break;
-                    }
+				}
 
-                    addExplosionFromHit(&evt);
+				addExplosionFromHit(&evt);
 
-                    if (missile->trace != nullptr) {
+				if (missile->trace != nullptr) {
-                        missile->trace->finish();
+					missile->trace->finish();
-                    }
+				}
 
-                    player->missiles.erase(player->missiles.begin() + i);
+				rm.push_back(missile);
-                    delete(missile);
-                    //std::cout<<std::endl;
-                }
-
-                // TODO
-                // add trace to the missile
             }
+
+			for (Missile *missile : rm) {
+				player->missiles.remove(missile);
+				delete(missile);
+			}
         }
     }
 
     void State::advanceExplosions(float dt)
     {
-        size_t i=0;
+		std::vector<Explosion*> rm;
-        while(i < explosions.size()) {
+
-            Explosion *explosion = explosions[i];
+		for (Explosion *explosion : explosions) {
             explosion->age += dt;
             if (explosion->age >= explosion->maxAge) {
-                delete(explosion);
+				rm.push_back(explosion);
-                explosions.erase(explosions.begin()+i);
-                continue;
             }
-
-            i++;
         }
+
+		for (Explosion *explosion : rm) {
+			explosions.remove(explosion);
+			delete(explosion);
+		}
     }
 
     void State::advance(float dt)
@@ -260,7 +260,6 @@ namespace game {
         advancePlayerCommands(dt);
 
         advancePlayerMissiles(dt);
-
     }
 
     Player *State::playerForId(int playerId)
@@ -288,7 +287,6 @@ namespace game {
                 pos = glm::vec2(0.0, 0.0);
             } else {
                 pos = glm::vec2(util::randf_0_1(), util::randf_m1_1());
-                        //glm::linearRand(-1.0, 1.0), glm::linearRand(-1.0, 1.0));
             }
 
             for (Planet *p : planets) {
@@ -332,37 +330,19 @@ namespace game {
         traces.push_back(trace);
     }
 
-    void State::deleteTrace(size_t index)
+    void State::deleteTrace(Trace *trace)
     {
-        if (index >= traces.size()) {
+		traces.remove(trace);
-            std::cerr << "can't find trace with invalid index " << index << std::endl;
-            return;
-        }
 
-        Trace *trace = traces[index];
-
-        //std::cout<<"removing a trace" << std::endl;
         if (trace->missile != nullptr) {
             // delete backlink.
             // XXX: there's a missile without a trace now.
             trace->missile->trace = nullptr;
         }
 
-        traces.erase(traces.begin() + index);
         delete(trace);
     }
 
-    void State::deleteTrace(Trace *trace)
-    {
-        size_t i = 0;
-        while(i < traces.size()) {
-            if (traces[i] == trace) {
-                deleteTrace(i);
-                break;
-            }
-        }
-    }
-
     void State::addExplosionFromHit(const Missile::Event *evt)
     {
         if (evt->hit == Hit::Nothing || evt->hit == Hit::BorderOfUniverse) {

game/state/state.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <vector>
+#include <list>
 #include <queue>
 #include <string>
 
@@ -75,7 +76,6 @@ namespace game {
 
         // delete traces with this command
         void deleteTrace(Trace *trace); // using a pointer
-        void deleteTrace(size_t index); // using an index
 
         /*************************************************************************/
         /* Rendering */
@@ -83,11 +83,11 @@ namespace game {
 
         // Game items which should be rendered are here:
         // (access missiles by iterating over player's missiles attribute)
-        std::vector<Planet*>    planets;
+        std::vector<Planet*>  planets;
-        std::vector<Ship*>      ships;
+        std::list<Ship*>      ships;
-        std::vector<Player*>    players;
+        std::list<Player*>    players;
-        std::vector<Trace*>     traces;
+        std::list<Trace*>     traces;
-        std::vector<Explosion*> explosions;
+        std::list<Explosion*> explosions;
 
     private:
         /*************************************************************************/