foo
This commit is contained in:
commit
94ab89e4b5
12 changed files with 155 additions and 43 deletions
|
@ -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)
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -6,7 +6,6 @@
|
|||
#include "game_window.hpp"
|
||||
#include "options.hpp"
|
||||
|
||||
|
||||
using namespace std;
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
|
|
|
@ -1,5 +1,4 @@
|
|||
#pragma once
|
||||
|
||||
#include <stdexcept>
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xlib.h>
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
}
|
|
@ -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;
|
||||
};
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue