This commit is contained in:
j3d1 2016-09-27 21:03:03 +02:00
commit a0d574b0b6
14 changed files with 207 additions and 51 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
@ -32,6 +34,7 @@ set(GAME_HEADERS
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

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

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

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

@ -6,12 +6,12 @@ endofthejedi::Renderer::Renderer() {
endofthejedi::Renderer::~Renderer() {}
void endofthejedi::Renderer::drawCircle(float x, float y, float radius, float r,
float g, float b, int numSides) {
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, y); // center of circle
for (int i = 0; i <= numSides; i++) {
glColor3f(r,g,b);
glVertex2f(x + (radius * cos(i * 2 * M_PI / numSides)), y + (radius * sin(i * 2 * M_PI / numSides)));
}
glEnd();

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
#include <glm/vec2.hpp>
namespace game {
/**
* Explosion: just an effect which looks good.
*/
class Explosion {
public:
enum class Kind {
Normal,
MissileWithShip
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
};
glm::vec2 position;
Explosion(const glm::vec2 &pos, Kind kind, float maxAge=1.0)
: position(pos), kind(kind), age(0.0), maxAge(maxAge)
{
}
Explosion(Kind kind);
const Kind kind; // kind of the explosion
const glm::vec2 position; // position where it starts
float age; // age (in seconsd) of the explosion
public:
// age (in seconds) when the explosion is not visible
// anymore and will disappear afterwards
const float maxAge;
};
}
#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;
};
}