fixes

CMakeLists.txt

@@ -7,6 +7,7 @@ function(setup_target NAME)
   set_property(TARGET ${NAME} PROPERTY CXX_STANDARD 14)
   set_property(TARGET ${NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
   target_compile_options(${NAME} PRIVATE -Wall -Wextra)
+  target_compile_options(${NAME} PRIVATE -fdiagnostics-color=always)
   target_compile_options(${NAME} PRIVATE $<$<CONFIG:DEBUG>:-ggdb -O2>)
   target_compile_options(${NAME} PRIVATE $<$<CONFIG:RELEASE>:-O3 -NDEBUG>)
 endfunction(setup_target)

game/CMakeLists.txt

@@ -15,6 +15,8 @@ set(GAME_SRC
     util.cpp
     game.cpp
     state/object.cpp
+    state/explosion.cpp
+    state/trace.cpp
     state/state.cpp
     state/player.cpp
     state/planet.cpp
@@ -32,6 +34,7 @@ set(GAME_HEADERS
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 include_directories(${OPENGL_INCLUDE_DIR})
+include_directories(${CMAKE_SOURCE_DIR}/libs/glm/)
 
 add_executable(game ${GAME_SRC} ${GAME_HEADERS})
 setup_target(game)

game/game.cpp

@@ -32,7 +32,7 @@ bool Game::cycle(float dt)
         acc -= spawnInterval;
 
         float a = 2.0 * M_PI * util::randf_0_1();
-        float speed = 0.002;
+        float speed = 0.005;
         m_state->players[0]->addCommand(new game::ShootCommand(a, speed));
     }
 

game/game_window.hpp

@@ -5,6 +5,7 @@
 
 #include "game.hpp"
 
+#include "state/trace.hpp"
 #include "state/object.hpp"
 #include "state/missile.hpp"
 #include "state/player.hpp"
@@ -41,6 +42,10 @@ protected:
             drawPlanet(planet->position, planet->radius);
         }
 
+        for (const game::Trace *trace : m_game.state()->traces) {
+            drawTrace(trace);
+        }
+
         for (const game::Ship *ship : m_game.state()->ships) {
             drawShip(ship->position);
         }
@@ -73,9 +78,18 @@ protected:
     }
 
     void drawMissile(const glm::vec2 &pos)
+
     {
         glm::vec3 color = glm::vec3(1.0, 1.0, 0.3);
-        m_renderer.drawCircle(pos.x, pos.y, 0.005, color.x, color.y, color.z, 5);
+        m_renderer.drawCircle(pos.x, pos.y, 0.01, color.x, color.y, color.z, 6);
+    }
+
+    void drawTrace(const game::Trace *trace)
+    {
+        for (const game::Trace::TracePoint &p : trace->points) {
+            glm::vec3 color = glm::vec3(0.1, 0.3, 1.0) / (1.0f + 500.0f*p.speed);
+            m_renderer.drawCircle(p.position.x, p.position.y, 0.005, color.x, color.y, color.z, 3);
+        }
     }
 
 public:

game/opengl.cpp

@@ -130,7 +130,7 @@ void endofthejedi::GLWindow::loop() {
     prev = current;
     if(delta > 0.0) {
       m_fps = (1000000000.0/delta);
-      std::cout << m_fps << "\n";
+      //std::cout << m_fps << "\n";
     }
   }
 }

game/renderer.cpp

@@ -6,13 +6,13 @@ endofthejedi::Renderer::Renderer() {
 
 endofthejedi::Renderer::~Renderer() {}
 
-void endofthejedi::Renderer::drawCircle(float x, float y, float radius, float r,
-                                        float g, float b, int numSides) {
-  glBegin(GL_TRIANGLE_FAN);
-  glVertex2f(x, y); // center of circle
-  for (int i = 0; i <= numSides; i++) {
+void endofthejedi::Renderer::drawCircle(float x, float y, float radius, float r, float g, float b, int numSides)
+{
+    glBegin(GL_TRIANGLE_FAN);
     glColor3f(r,g,b);
-    glVertex2f(x + (radius * cos(i * 2 * M_PI / numSides)), y + (radius * sin(i * 2 * M_PI / numSides)));
-  }
-  glEnd();
+    glVertex2f(x, y); // center of circle
+    for (int i = 0; i <= numSides; i++) {
+        glVertex2f(x + (radius * cos(i * 2 * M_PI / numSides)), y + (radius * sin(i * 2 * M_PI / numSides)));
+    }
+    glEnd();
 }

game/state/commands.cpp

@@ -1,14 +1,24 @@
 #include "commands.hpp"
 
+#include "trace.hpp"
+
 namespace game {
     void ShootCommand::apply(Player *player, State *state) const
     {
-        (void) state;
-        // TODO spawn missile if alive and enough energy
         //std::cout<<"apply command " << name() << std::endl;
 
+        // TODO: idea
+        // shoot multiple rockets at once or from different positions after
+        // level up / upgrade ...
+        Missile *missile = new Missile(player, player->ship->position, m_angle, m_speed);
+
+        Trace *trace = new Trace(missile);
+        missile->trace = trace;
+
         player->energy -= m_speed;
-        player->missiles.push_back(new Missile(player->id, player->ship->position, m_angle, m_speed));
+        player->missiles.push_back(missile);
+
+        state->addTrace(trace);
     }
 
     bool ShootCommand::allowed(const Player *player, const State *state) const

game/state/explosion.hpp

@@ -1,17 +1,32 @@
 #pragma once
 
-#if 0
-class Explosion {
-public:
-    enum class Kind {
-        Normal,
-        MissileWithShip
+#include <glm/vec2.hpp>
+
+namespace game {
+    /**
+     * Explosion: just an effect which looks good.
+     */
+    class Explosion {
+    public:
+        enum class Kind {
+            MissileExplodesInSpace, // missile explode in free space
+            MissileAgainstPlanet,   // explosion of missile when it hits a planet
+            MissileAgainstShip      // bigger explosion: missile hits a ship which explodes with it
+        };
+
+        Explosion(const glm::vec2 &pos, Kind kind, float maxAge=1.0)
+            : position(pos), kind(kind), age(0.0), maxAge(maxAge)
+        {
+        }
+
+        const Kind      kind;     // kind of the explosion
+        const glm::vec2 position; // position where it starts
+        float           age;      // age (in seconsd) of the explosion
+
+        // age (in seconds) when the explosion is not visible
+        // anymore and will disappear afterwards
+        const float     maxAge;
     };
+}
 
-    glm::vec2 position;
-
-    Explosion(Kind kind);
-
-public:
-};
 #endif

game/state/missile.cpp

@@ -4,12 +4,15 @@
 
 #include "state.hpp"
 #include "player.hpp"
+#include "ship.hpp"
+#include "planet.hpp"
+#include "trace.hpp"
 
 #include <glm/gtx/norm.hpp>
 
 namespace game {
-    Missile::Missile(int playerId, const glm::vec2 &pos, float angle, float speed)
-        : playerId(playerId)
+    Missile::Missile(Player *player, const glm::vec2 &pos, float angle, float speed)
+        : player(player)
         , position(pos)
     {
         velocity = speed * glm::vec2(std::sin(angle), std::cos(angle));
@@ -28,13 +31,13 @@ namespace game {
         glm::vec2 gravityForce = glm::vec2(0.0, 0.0);
 
         for (const Player *other : state->players) {
-            if (other->ship != nullptr && other->id != playerId) {
+            if (other->ship != nullptr && other != player) {
                 glm::vec2 diff = other->ship->position - position;
                 float dist = glm::length(diff);
                 if (dist <= other->ship->radius) {
                     // TODO: collect all hits and return the first one only
                     // TODO: find exact hit position!
-                    return Missile::Event(position, playerId, other->id);
+                    return Missile::Event(position, player->id, other->id);
                 }
             }
         }

game/state/missile.hpp

@@ -3,13 +3,13 @@
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
 
-#include "state.hpp"
-
-#include "ship.hpp"
-#include "planet.hpp"
-
 namespace game {
     class State;
+    class Ship;
+    class Planet;
+    class Player;
+    class State;
+    class Trace;
 
     // missile belongs to a player and optionally fills a trace behind it.
     // trace then belongs to the player.
@@ -50,19 +50,17 @@ namespace game {
             int playerIdVictim;
         };
 
-        // XXX
-        int       playerId; // owner won't be hit by own missiles
-        glm::vec2 position;
-        glm::vec2 velocity;
-        //Trace *trace;
-
-        Missile(int playerId, const glm::vec2 &pos, float angle, float speed);
-
+        Missile(Player *player, const glm::vec2 &pos, float angle, float speed);
         ~Missile();
 
         // try to advance. if something will be hit, return the first hit in
         // time.
         Missile::Event advance(const game::State *state, float dt);
+
+        Player   *player; // owner won't be hit by own missiles
+        glm::vec2 position;
+        glm::vec2 velocity;
+        Trace    *trace;
     };
 }
 

game/state/state.cpp

@@ -12,6 +12,7 @@
 #include "planet.hpp"
 #include "ship.hpp"
 #include "commands.hpp"
+#include "trace.hpp"
 
 #include "util.hpp"
 
@@ -161,6 +162,11 @@ namespace game {
                 //std::cout<<"missile: " << (long unsigned int) missile << std::endl;
                 const Missile::Event evt = missile->advance(this, dt);
 
+                missile->trace->addPointFromMissile();
+
+                // TODO:
+                // spawn just if the path differs
+
                 if (evt.hit == Missile::HitObject::Nothing) {
                     i++;
 
@@ -259,4 +265,9 @@ namespace game {
             player->addCommand(cmd);
         }
     }
+
+    void State::addTrace(Trace *trace)
+    {
+        traces.push_back(trace);
+    }
 }

game/state/state.hpp

@@ -8,25 +8,34 @@
 #include <glm/vec2.hpp>
 
 namespace game {
+    // forward declarations
     class Command;
     class Missile;
     class Player;
     class Planet;
     class Ship;
-
-    // trace of a missile. exists without a missile at player.
-    //class Trace {
-    //public:
-    //    std::vector<glm::vec2> points;
-    //};
+    class Trace;
 
     class State {
     public:
+        /*************************************************************************/
+        /* State management */
+        /*************************************************************************/
+
+        // called to setup the state (randomize planets, kill
+        // traces/missiles/ships etc.)
         void init();
+
+        // main method to advance the simulation by the given timestamp in
+        // seconds.
         void advance(float dt);
 
-        // the (network) layer calling these three functions should keep id's
-        // unique and give one (network) input an id.
+        /*************************************************************************/
+        /* Network / Input */
+        /*************************************************************************/
+
+        // The upper layer (network/renderer) calling these three functions
+        // should keep id's unique and give one (network) input an id.
         void addPlayer(int playerId);
         void playerLeft(int playerId);
         void commandForPlayer(int playerId, Command *cmd);
@@ -34,14 +43,34 @@ namespace game {
         // lookup. return nullptr on invalid playerId
         Player *playerForId(int playerId);
 
+        /*************************************************************************/
+        /* Mixed stuff */
+
+        // distance after which missiles get lost in space (and explode)
         float maxMissileDistance() const { return m_maxMissileDistance; }
+
+        // each ship has the same radius
         float shipRadius()         const { return m_shipRadius; }
 
+        // add a trace to the list of traces.
+        void addTrace(Trace *trace);
+
+        /*************************************************************************/
+        /* Rendering */
+        /*************************************************************************/
+
+        // Game items which should be rendered are here:
+        // (access missiles by iterating over player's missiles attribute)
         std::vector<Planet*>  planets;
         std::vector<Ship*>    ships;
         std::vector<Player*>  players;
+        std::vector<Trace*>   traces;
 
     private:
+        /*************************************************************************/
+        /* Internal */
+        /*************************************************************************/
+
         void playerKillsPlayer(Player *killer, Player *victim);
 
         void advancePlayerShipSpawns(float dt);

game/state/trace.cpp

@@ -0,0 +1,27 @@
+#include "trace.hpp"
+
+#include <glm/gtx/norm.hpp>
+
+#include "missile.hpp"
+
+namespace game {
+    Trace::TracePoint::TracePoint(const Missile *missile)
+        : position(missile->position)
+        , speed(glm::length(missile->velocity))
+    {
+    }
+
+    Trace::Trace(const Missile *missile) : missile(missile), fidelityCounter(0)
+    {
+        points.push_back(TracePoint(missile));
+    }
+
+    void Trace::addPointFromMissile(bool forceAdd)
+    {
+        fidelityCounter++;
+        if (forceAdd || fidelityCounter >= 10) {
+            fidelityCounter = 0;
+            points.push_back(TracePoint(missile));
+        }
+    }
+}

game/state/trace.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <glm/vec2.hpp>
+#include <vector>
+
+namespace game {
+    class Missile;
+
+    /*
+     * Trace of a missile through the space.
+     * Useful for rendering sth. like a smoke trail to follow the rocket.
+     */
+    class Trace {
+        public:
+            Trace(const Missile *missile);
+
+            // Add the current position of the missile as a new point on the
+            // trace.
+            // Parameters:
+            // forceAdd: set to true to add this point (good for the endpoint of
+            // the missile) in case the fidelityCounter would skip the current position.
+            void addPointFromMissile(bool forceAdd=false);
+
+            // TODO: add extendLastPointToPosition() method for saving points /
+            // optimization later on
+
+            /*
+             * Trace point data to be used when rendering.
+             */
+            struct TracePoint {
+                TracePoint(const Missile *missile);
+
+                glm::vec2 position;
+                float     speed;
+            };
+
+            std::vector<TracePoint> points;
+            const Missile *missile; // missile which creates this path.
+
+            // counter which is incremented each time addPointFromMissile() is called.
+            // when reaching a certain value the point is saved for
+            // optimization.
+            int fidelityCounter;
+    };
+}