j3d1/KlassischeKeplerKriege
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

traces are now managed by state/missile code.

Browse source
This commit is contained in:
Andreas Ortmann 2016-09-27 20:13:09 +02:00
parent 2e62324815
commit fd8d56bf95
9 changed files with 109 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CMakeLists.txt
View file

@ -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)

3
game/main.cpp
View file

@ -5,6 +5,9 @@
#include "game_window.hpp"
int main(int argc, const char *argv[]) {
(void) argv;
(void) argc;
GameWindow window(500, 500);
window.set_maxfps(60.0);
window.loop();

16
game/state/commands.cpp
View file

@ -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

11
game/state/missile.cpp
View file

@ -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);
}
}
}

24
game/state/missile.hpp
View file

@ -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;
};
}

11
game/state/state.cpp
View file

@ -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);
}
}

45
game/state/state.hpp
View file

@ -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);

13
game/state/trace.cpp
View file

@ -6,17 +6,22 @@
namespace game {
Trace::TracePoint::TracePoint(const Missile *missile)
: position(missile->position), speed(glm::length(missile->velocity))
: position(missile->position)
, speed(glm::length(missile->velocity))
{
}
Trace::Trace(const Missile *missile)
Trace::Trace(const Missile *missile) : missile(missile), fidelityCounter(0)
{
points.push_back(TracePoint(missile));
}
void Trace::addPointFromMissile(const Missile *missile)
void Trace::addPointFromMissile(bool forceAdd)
{
points.push_back(TracePoint(missile));
fidelityCounter++;
if (forceAdd || fidelityCounter >= 20) {
fidelityCounter = 0;
points.push_back(TracePoint(missile));
}
}
}

23
game/state/trace.hpp
View file

@ -14,10 +14,15 @@ namespace game {
public:
Trace(const Missile *missile);
// TODO: add velocity of the rocket or age at the points too becasue
// that enables nice rendering of speed etc. at different points
// TODO: give missile to this
void addPointFromMissile(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.
@ -25,10 +30,16 @@ namespace game {
struct TracePoint {
TracePoint(const Missile *missile);
const glm::vec2 position;
const float speed;
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;
};
}