Merge branch 'master' into networking

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
@@ -24,17 +26,15 @@ set(GAME_SRC
 )
 
 set(GAME_HEADERS
-  opengl.h
-  glclasses.h
-  vector.h
-  config.h
-  simulation.h
-  renderer.h
+    opengl.hpp
+    glclasses.hpp
+    renderer.hpp
 )
 
 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/config.cpp

@@ -1,2 +0,0 @@
-#include "config.h"
-

game/config.h

@@ -1,33 +0,0 @@
-#pragma once
-
-struct Config {
-  int maxPlayers;
-  int numPlanets;
-  int maxSegments;
-  int segmentSteps;
-  int numShots;
-  int fastmode;
-  int fullscreen;
-  int timeout;
-  int margintop;
-  int marginleft;
-  int marginright;
-  int marginbottom;
-  double playerSize;
-  int energy;
-  int realtime;
-  int debug;
-  double battlefieldW;
-  double battlefieldH;
-  int throttle;
-  char* ip;
-  char* message;
-  int pot;
-  int area;
-};
-
-class ConfigParser{
- private:
- protected:
- public:
-};

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

@@ -1,10 +1,11 @@
 #pragma once
 
-#include "opengl.h"
-#include "renderer.h"
+#include "opengl.hpp"
+#include "renderer.hpp"
 
 #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/glclasses.cpp

@@ -1,4 +1,4 @@
-#include "glclasses.h"
+#include "glclasses.hpp"
 
 endofthejedi::VAO::VAO() { glGenVertexArrays(1, &m_name); }
 

game/main.cpp

@@ -1,11 +1,12 @@
-#include "opengl.h"
+#include "opengl.hpp"
+
 #include <iostream>
 #include <getopt.h>
 
-//#include "triangle_window.h"
-#include "game_window.h"
+#include "game_window.hpp"
 #include "options.hpp"
 
+uint64_t optionsFlags;
 
 using namespace std;
 

game/opengl.cpp

@@ -1,4 +1,4 @@
-#include "opengl.h"
+#include "opengl.hpp"
 
 #include <iostream>
 #include <sys/time.h>
@@ -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/options.hpp

@@ -10,7 +10,7 @@
 
 #define SET_FLAG(x,y) optionsFlags&=(~((1)<<x));optionsFlags|=((y&1)<<x)
 #define ISSET_FLAG(x) (optionsFlags&((1)<<x))
-uint64_t optionsFlags;
+extern uint64_t optionsFlags;
 
 /*
  * usage:

game/renderer.cpp

@@ -1,4 +1,4 @@
-#include "renderer.h"
+#include "renderer.hpp"
 
 endofthejedi::Renderer::Renderer() {
 
@@ -6,12 +6,12 @@ endofthejedi::Renderer::Renderer() {
 
 endofthejedi::Renderer::~Renderer() {}
 
-void endofthejedi::Renderer::drawCircle(float x, float y, float radius, float r,
-                                        float g, float b, int numSides) {
+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, y); // center of circle
     for (int i = 0; i <= numSides; i++) {
-    glColor3f(r,g,b);
         glVertex2f(x + (radius * cos(i * 2 * M_PI / numSides)), y + (radius * sin(i * 2 * M_PI / numSides)));
     }
     glEnd();

game/renderer.hpp

@@ -5,7 +5,7 @@
 #include <epoxy/gl.h>
 #include <epoxy/glx.h>
 
-#include "glclasses.h"
+#include "glclasses.hpp"
 
 namespace endofthejedi {
 

game/simulation.cpp

@@ -1,2 +0,0 @@
-#include "simulation.h"
-

game/simulation.h

@@ -1,50 +0,0 @@
-#pragma once
-
-#include "vector.h"
-
-typedef struct
-{
-  Vec2d position;
-  Vec2d speed;
-  int live;
-  int leftSource;
-  int stale;
-} SimMissile;
-
-typedef struct
-{
-  Vec2d* dot;
-  SimMissile missile;
-  int length;
-  int player;
-  double angle;
-  double velocity;
-} SimShot;
-
-typedef struct
-{
-  SimShot* shot;
-  int currentShot;
-  Vec2d position;
-  double angle;
-  double velocity;
-  double energy;
-  double oldVelocity;
-  int watch;
-  int deaths;
-  int kills;
-  int shots;
-  int active;
-  int valid;
-  int didShoot;
-  int timeout;
-  int timeoutcnt;
-  char name[16];
-} SimPlayer;
-
-typedef struct
-{
-  Vec2d position;
-  double radius;
-  double mass;
-} SimPlanet;

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:
+#include <glm/vec2.hpp>
+
+namespace game {
+    /**
+     * Explosion: just an effect which looks good.
+     */
+    class Explosion {
+    public:
         enum class Kind {
-        Normal,
-        MissileWithShip
+            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
         };
 
-    glm::vec2 position;
+        Explosion(const glm::vec2 &pos, Kind kind, float maxAge=1.0)
+            : position(pos), kind(kind), age(0.0), maxAge(maxAge)
+        {
+        }
 
-    Explosion(Kind kind);
+        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;
+    };
+}
 
-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;
+    };
+}

game/triangle_window.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "opengl.h"
+#include "opengl.hpp"
 
 class TriangleWindow : public endofthejedi::GLWindow {
 private:

game/vector.h

@@ -1,90 +0,0 @@
-#pragma once
-
-#include <math.h>
-
-struct Vec2d
-{
-  double x;
-  double y;
-
-  double length() {
-    return sqrt(x*x + y*y);
-  }
-  double distance(Vec2d other) {
-    Vec2d tmp = (*this - other);
-    return tmp.length();
-  }
-
-  Vec2d & operator+=(const Vec2d& rhs) {
-    x+=rhs.x;
-    y+=rhs.y;
-    return *this;
-  }
-  Vec2d & operator-=(const Vec2d& rhs) {
-    x-=rhs.x;
-    y-=rhs.y;
-    return *this;
-  }
-  Vec2d & operator*=(const double& rhs) {
-    x*=rhs;
-    y*=rhs;
-    return *this;
-  }
-  Vec2d & operator/=(const double& rhs) {
-    x/=rhs;
-    y/=rhs;
-    return *this;
-  }
-  const Vec2d operator+(const Vec2d& rhs) const {
-    Vec2d result = *this;
-    result += rhs;
-    return result;
-  }
-  const Vec2d operator-(const Vec2d& rhs) const {
-    Vec2d result = *this;
-    result -= rhs;
-    return result;
-  }
-  const double operator*(const Vec2d& rhs) const {
-    return (this->x * rhs.x) + (this->y * rhs.y);
-  }
-  const Vec2d operator*(const double& rhs) const {
-    Vec2d result = *this;
-    result *= rhs;
-    return result;
-  }
-  const Vec2d operator/(const double& rhs) const {
-    Vec2d result = *this;
-    result /= rhs;
-    return result;
-  }
-};
-/*
-struct Mat4d {
-  std::array<double, 16> data;
-
-  const Mat4d operator*(const Mat4d& rhs) const {
-    Mat4d result;
-    result[0] = result[0]*rhs[0] + result[1]*result[5] + result[2]*result[9] + result[3]*result[13];
-    result[1] = result[0]*rhs[1] + result[1]*result[6] + result[2]*result[10] + result[3]*result[14];
-    result[2] = result[0]*rhs[2] + result[1]*result[7] + result[2]*result[11] + result[3]*result[15];
-    result[3] = result[0]*rhs[3] + result[1]*result[8] + result[2]*result[12] + result[3]*result[16];
-
-    result[4] = result[4]*rhs[0] + result[5]*result[5] + result[6]*result[9] + result[7]*result[13];
-    result[5] = result[4]*rhs[1] + result[5]*result[6] + result[6]*result[10] + result[7]*result[14];
-    result[6] = result[4]*rhs[2] + result[5]*result[7] + result[6]*result[11] + result[7]*result[15];
-    result[7] = result[4]*rhs[3] + result[5]*result[8] + result[6]*result[12] + result[7]*result[16];
-
-    result[8] = result[8]*rhs[0] + result[9]*result[5] + result[10]*result[9] + result[11]*result[13];
-    result[9] = result[8]*rhs[1] + result[9]*result[6] + result[10]*result[10] + result[11]*result[14];
-    result[10] = result[8]*rhs[2] + result[9]*result[7] + result[10]*result[11] + result[11]*result[15];
-    result[11] = result[8]*rhs[3] + result[9]*result[8] + result[10]*result[12] + result[11]*result[16];
-
-    result[12] = result[12]*rhs[0] + result[13]*result[5] + result[14]*result[9] + result[15]*result[13];
-    result[13] = result[12]*rhs[1] + result[13]*result[6] + result[14]*result[10] + result[15]*result[14];
-    result[14] = result[12]*rhs[2] + result[13]*result[7] + result[14]*result[11] + result[15]*result[15];
-    result[15] = result[12]*rhs[3] + result[13]*result[8] + result[14]*result[12] + result[15]*result[16];
-    return result;
-  }
-};
-*/