diff --git a/CMakeLists.txt b/CMakeLists.txt index 64bcd0f..a2823b4 100644 --- a/CMakeLists.txt +++ b/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 $<$:-ggdb -O2>) target_compile_options(${NAME} PRIVATE $<$:-O3 -NDEBUG>) endfunction(setup_target) diff --git a/game/game.cpp b/game/game.cpp index 3733e47..2b08287 100644 --- a/game/game.cpp +++ b/game/game.cpp @@ -30,7 +30,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)); } diff --git a/game/game_window.hpp b/game/game_window.hpp index 4ee7ed5..1c9a1a8 100644 --- a/game/game_window.hpp +++ b/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 @@ class GameWindow : public endofthejedi::GLWindow { 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); } @@ -72,10 +77,19 @@ class GameWindow : public endofthejedi::GLWindow { 32); } - void drawMissile(const glm::vec2 &pos) { + 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: diff --git a/game/main.cpp b/game/main.cpp index 7f30ea2..2d703ad 100644 --- a/game/main.cpp +++ b/game/main.cpp @@ -6,7 +6,6 @@ #include "game_window.hpp" #include "options.hpp" - using namespace std; int main(int argc, char *argv[]) { diff --git a/game/opengl.hpp b/game/opengl.hpp index 2114682..3b61958 100644 --- a/game/opengl.hpp +++ b/game/opengl.hpp @@ -1,5 +1,4 @@ #pragma once - #include #include #include diff --git a/game/state/commands.cpp b/game/state/commands.cpp index f656dc6..b84a214 100644 --- a/game/state/commands.cpp +++ b/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 diff --git a/game/state/missile.cpp b/game/state/missile.cpp index b060ca3..b789b5f 100644 --- a/game/state/missile.cpp +++ b/game/state/missile.cpp @@ -4,12 +4,15 @@ #include "state.hpp" #include "player.hpp" +#include "ship.hpp" +#include "planet.hpp" +#include "trace.hpp" #include 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); } } } diff --git a/game/state/missile.hpp b/game/state/missile.hpp index b1f0f96..c68706d 100644 --- a/game/state/missile.hpp +++ b/game/state/missile.hpp @@ -3,13 +3,13 @@ #include #include -#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; }; } diff --git a/game/state/state.cpp b/game/state/state.cpp index 462f62a..bc39594 100644 --- a/game/state/state.cpp +++ b/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); + } } diff --git a/game/state/state.hpp b/game/state/state.hpp index 1182147..0df4313 100644 --- a/game/state/state.hpp +++ b/game/state/state.hpp @@ -8,25 +8,34 @@ #include 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 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 planets; std::vector ships; std::vector players; + std::vector traces; private: + /*************************************************************************/ + /* Internal */ + /*************************************************************************/ + void playerKillsPlayer(Player *killer, Player *victim); void advancePlayerShipSpawns(float dt); diff --git a/game/state/trace.cpp b/game/state/trace.cpp index e69de29..4d93d2c 100644 --- a/game/state/trace.cpp +++ b/game/state/trace.cpp @@ -0,0 +1,27 @@ +#include "trace.hpp" + +#include + +#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)); + } + } +} diff --git a/game/state/trace.hpp b/game/state/trace.hpp index 5c7f050..ab33b2f 100644 --- a/game/state/trace.hpp +++ b/game/state/trace.hpp @@ -1,24 +1,45 @@ #pragma once #include +#include 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 glm::vec2 &startPoint) - { - points.push_back(startPoint); - } + Trace(const Missile *missile); - void addPoint(const glm::vec2 &p) - { - points.push_back(p); - } + // 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); - std::vector points; + // 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 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; }; }