Merge branch 'master' into networking

This commit is contained in:
j3d1 2016-09-27 21:19:20 +02:00
commit 2be3549b49
26 changed files with 222 additions and 245 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

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

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

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

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

27
game/state/trace.cpp Normal file
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));
}
}
}

45
game/state/trace.hpp Normal file
View file

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

View file

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

View file

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