fixes
This commit is contained in:
commit
a0d574b0b6
14 changed files with 207 additions and 51 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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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));
|
||||
}
|
||||
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
|
|
27
game/state/trace.cpp
Normal file
27
game/state/trace.cpp
Normal 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
45
game/state/trace.hpp
Normal 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;
|
||||
};
|
||||
}
|
Loading…
Reference in a new issue