This commit is contained in:
end 2016-09-27 21:04:53 +02:00
commit 94ab89e4b5
12 changed files with 155 additions and 43 deletions

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)

View file

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

View file

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

View file

@ -6,7 +6,6 @@
#include "game_window.hpp"
#include "options.hpp"
using namespace std;
int main(int argc, char *argv[]) {

View file

@ -1,5 +1,4 @@
#pragma once
#include <stdexcept>
#include <X11/X.h>
#include <X11/Xlib.h>

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

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

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

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

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

View file

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

View file

@ -1,24 +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 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<glm::vec2> 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<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;
};
}