Programmer

EMIL STRÖM

Platform

Engine

Language

Development Time

Team Size

Windows

OpenGL

C++

3 months

Solo

Latest Build

Source

HellGun

HellGun is a singleplayer arena shooter, with heavy focus on tight movement control and juicy gameplay. The game automatically uploads the players' score to a leaderboard server.

This is a solo project with the purpose of furthering my knowledge of C++ and OpenGL, and how the two can be used to create applicable code and modules. The project consists of three separate components: an OpenGL-library, the actual HellGun engine and a scoreboard server (written in C# for Linux).

The HellGun Engine

The game engine is built from scratch and is handcrafted to run HellGun specifically.

Features include basic collision detection, physics and a particle system. Some other features such as audio, context creation and input management are accomplished using libraries such as SFML and Boost.

Some of the movement mechanics in HellGun include dashing, double jumping and wall jumping, all of which can be combined.

Code Samples

<Actor>

Gun mechanics and particles. Recoil is added to character which enables some air control.

Enemy AI, which is relatively complex. I wanted the enemies to feel a bit random and unpredictable, but keep them moving in "packs".

Code Samples

FX_Trail.hpp

#pragma once
#include <GLT\MeshDrawer.hpp>
#include <glm\vec2.hpp>
#include <vector>

#include "FX.hpp"
#include "Entity.hpp"

class FX_Trail : public FX {
public:
    float minDistance = 1.5f;
    float size = 1.f;
    float segmentLife = 1.f;

    //-----------

    FX_Trail( Entity* target, float minDistance = 1.5f, float size = 1.f, float segmentLife = 1.f );
    ~FX_Trail( );

    void logic( ) override;
    void draw( ) override;

    void release( );

private:
    struct Segment {
    public:
        glm::vec2 position;
        glm::vec2 direction;

        //------------

        Segment( glm::vec2 position, glm::vec2 direction, float size = 1.f, float time = 0.2f );

        void update( );
        std::array<float, 6> getVertices( );
        bool isDone( ) { return timer.isDone( ); }

    private:
        float size = 1.f;
        Timer timer = Timer( 0.2f );

        //--------------

        float getSize( );
    };

    Entity* target;
    glm::vec2 position;

    std::vector<float> vertices;
    std::vector<Segment> segments;
    glt::MeshDrawer mesh;

    //--------------

    void addSegment( glm::vec2 location, glm::vec2 normal );
    void updateMesh( );
};

FX_Trail.cpp

#include "FX_Trail.hpp"

#include "GameState.hpp"

using namespace glm;
using namespace std;
using namespace glt;

FX_Trail::FX_Trail( Entity* target, float minDistance, float size, float segmentLife ) : mesh( new Mesh( ) ), FX( ) {
    this->target = target;
    this->minDistance = minDistance;
    this->size = size;
    this->segmentLife = segmentLife;

    position = target->position;

    mesh.getMesh( )->drawMode = GL_TRIANGLE_STRIP;
    mesh.getMesh( )->setVertices( nullptr, 0 );
    mesh.getMesh( )->setDataUsage( GL_STREAM_DRAW );
}
FX_Trail::~FX_Trail( ) {
    FX::~FX( );
    delete mesh.getMesh( );
}

void FX_Trail::addSegment( vec2 position, vec2 normal ) {
    segments.push_back( Segment( position, normal, size, segmentLife ) );
}

void FX_Trail::updateMesh( ) {
    if (segments.size( ) <= 0)
        return;

    vector<float> vertexList( segments.size( ) * 6 );
    int index = 0;

    for (vector<Segment>::iterator i = segments.begin( ); i != segments.end( ); i++) {
        if (i->isDone( )) continue;

        array<float, 6> segVertices = i->getVertices( );
        for (int j = 0; j < segVertices.size( ); j++)
            vertexList[index + j] = segVertices[j];

        index += 6;
    }

    mesh.getMesh( )->setVertices( &vertexList[0], vertexList.size( ) * sizeof( float ) );
}

void FX_Trail::release( ) {
    target = nullptr;
}

void FX_Trail::logic( ) {
    FX::logic( );

    if (target != nullptr && !target->isDestroyed( )) {
        //Check to add segments
        float distance = length( position - target->position );

        if (distance >= minDistance) { //Minimum
            //Create more segments if needed
            int segments = floor( distance / minDistance );

            vec2 normal = normalize( target->position - position );

            //Create them all, evenly spaced
            for (int i = 0; i < segments; i++) {
                addSegment( target->position - normal * distance * ((float)i / segments), normal );
            }

            //Update position
            position = target->position;
        }
    }
    //If entity is null, and all segments are gone, finish the particle
    else if (segments.size( ) <= 0)
        finish( );

    //Update particles
    for (int i = 0; i < segments.size( ); i++) {
        segments[i].update( );

        //Remove them from the list if it's done
        if (segments[i].isDone( )) {
            segments.erase( segments.begin( ) + i );
            i--;
        }
    }

    updateMesh( );
}

void FX_Trail::draw( ) {
    FX::draw( );

    mesh.draw( );
}

////SEGMENTS

FX_Trail::Segment::Segment( glm::vec2 position, glm::vec2 direction, float size, float time ) {
    this->position = position;
    this->direction = direction;
    this->size = size;
    timer.reset( time );
}

void FX_Trail::Segment::update( ) {
    timer.update( );
}

array<float, 6> FX_Trail::Segment::getVertices( ) {
    if (isDone( ))
        return array<float, 6>( );

    vec2 parallel = normalize( vec2( -direction.y, direction.x ) ) * getSize( );

    array<float, 6> vertices;
    vertices[0] = position.x + parallel.x;
    vertices[1] = position.y + parallel.y;
    vertices[2] = 0.f;

    vertices[3] = position.x + -parallel.x;
    vertices[4] = position.y + -parallel.y;
    vertices[5] = 0.f;

    return vertices;
}

float FX_Trail::Segment::getSize( ) {
    if (timer.value < 0.2f)
        return size * timer.value / 0.2f;
    else
        return size * (1.f - (timer.value - 0.2f) / 0.8f);
}

FX_Muzzle.hpp

#pragma once
#include <glm\glm.hpp>
#include <GLT\MeshDrawer.hpp>
#include <vector>

#include "Timer.hpp"
#include "FX.hpp"

class FX_Muzzle : public FX {
public:
    FX_Muzzle( glm::vec2 position, glm::vec2 direction );
    ~FX_Muzzle( );

    void logic( ) override;
    void draw( ) override;

private:
    class Flash {
    public:
        Flash( glt::Mesh* mesh, glm::vec2 position, float direction, glm::vec2 size, float time );

        void logic( );
        void draw( );

    private:
        glt::MeshDrawer mesh;
        glm::vec2 size;
        Timer life = Timer( 0.1f );
    };

    class Spark {
    public:
        Spark( glt::Mesh* mesh, glm::vec2 position, float size, float direction, float velocity, float life );

        void logic( );
        void draw( );

    private:
        glt::MeshDrawer mesh;

        glm::vec2 position;
        glm::vec2 size;
        float direction;
        float velocity;
        float angularVelocity;
        Timer life = Timer( 0.4f );
    };

    glt::Mesh smallFlash;
    glt::Mesh bigFlash;

    Timer timer = Timer( 0.5f );

    std::vector<Flash*> flashList;
    std::vector<Spark*> sparkList;
};

FX_Muzzle.cpp

#include "FX_Muzzle.hpp"

#include "AssetBank.hpp"
#include "MathUtil.hpp"
#include "GameState.hpp"

using namespace glt;
using namespace glm;

FX_Muzzle::FX_Muzzle( vec2 position, vec2 direction ) : FX( ) {
    //Create flash meshes
    float vertices_small[] ={
        0.f, 0.f, 0.f,
        0.2f, -0.5f, 0.f,
        1.f, 0.f, 0.f,
        0.2f, 0.5f, 0.f
    };

    float vertices_big[] ={
        -1.f, 0.f, 0.f,
        0.f, -0.5f, 0.f,
        1.f, 0.f, 0.f,
        0.f, 0.5f, 0.f
    };

    smallFlash.drawMode = GL_QUADS;
    smallFlash.setVertices( vertices_small, sizeof( vertices_small ) );

    bigFlash.drawMode = GL_QUADS;
    bigFlash.setVertices( vertices_big, sizeof( vertices_big ) );

    //Fireangle in degrees
    float fireAngle = getAngle( direction );

    //Create 2 big flashes
    //One perpendicular right at the muzzle
    flashList.push_back( new Flash( &bigFlash, position, fireAngle - 90, vec2( 0.6f + 1.2f * frand( ), 0.7f + 1.5f * frand( ) ), 0.1f ) );
    //And one parallel, the main flash
    flashList.push_back( new Flash( &smallFlash, position, fireAngle, vec2( 6.f, 2.f ), 0.1f ) );

    //3 smaller flashes
    for (int i = 0; i < 3; i++) {
        vec2 size = vec2( 2.f + frand( ) * 2.f, 1.f + frand( ) * 2.f );
        float dir = fireAngle + 45.f * (frand( ) - 0.5f);

        size *= 1.f - abs( dir - fireAngle ) / 20.f;

        flashList.push_back( new Flash( &smallFlash, position, dir, size, 0.1f ) );
    }

    //Create smoke
    for (int i = 0; i < 4; i++) {
        float dir = fireAngle + (frand( ) - 0.5f) * 45.f;
        float dirDif = 1.f - (abs( dir - fireAngle ) / 15.f);

        float velocity = 2.f + 30.f * frand( ) * dirDif;
        vec2 offset = getVector( dir ) * (0.5f + 6.f * frand( ) * dirDif);

        float size = 0.8f + 1.5f * frand( ) * (velocity / 35.f) * (1.f - length( offset ) / 6.f);
        float life = 0.3f + 0.5f * frand( );

        sparkList.push_back( new Spark( AssetBank::loadMesh( "smoke" ), position + offset, size, dir, velocity, life ) );
    }
}

FX_Muzzle::~FX_Muzzle( ) {
    FX::~FX( );

    for (int i = 0; i < flashList.size( ); i++)
        delete flashList[i];

    for (int i = 0; i < sparkList.size( ); i++)
        delete sparkList[i];
}

void FX_Muzzle::logic( ) {
    FX::logic( );

    for (int i = 0; i < flashList.size( ); i++)
        flashList[i]->logic( );
    for (int i = 0; i < sparkList.size( ); i++)
        sparkList[i]->logic( );

    timer.update( );
    if (timer.isDone( ))
        finish( );
}

void FX_Muzzle::draw( ) {
    FX::draw( );

    for (int i = 0; i < flashList.size( ); i++)
        flashList[i]->draw( );
    for (int i = 0; i < sparkList.size( ); i++)
        sparkList[i]->draw( );
}

//FLASHES
FX_Muzzle::Flash::Flash( Mesh* mesh, vec2 position, float direction, vec2 size, float time ) {
    this->mesh.setMesh( mesh );
    this->mesh.position = vec3( position, 0.f );
    this->mesh.rotation.z = direction;
    this->mesh.scale = vec3( size, 1.f );

    this->size = size;
    life.reset( time );
}

void FX_Muzzle::Flash::logic( ) {
    life.update( );

    mesh.scale.x = size.x + 2.f * life.value;
    mesh.scale.y = size.y * (1.f - life.value);
}

void FX_Muzzle::Flash::draw( ) {
    if (life.isDone( ))
        return;

    mesh.draw( );
}

//SPARK
FX_Muzzle::Spark::Spark( Mesh* mesh, vec2 position, float size, float direction, float velocity, float life ) {
    this->mesh.setMesh( mesh );
    this->position = position;
    this->size = vec2( size + size*0.4f * (frand( ) - 0.5f), size + size*0.4f * (frand( ) - 0.5f) );
    this->direction = direction;
    this->velocity = velocity;
    this->life.reset( life );

    angularVelocity = (frand( ) - 0.5f) * 400.f;
}

void FX_Muzzle::Spark::logic( ) {
    life.update( );

    float perc = 1.f - life.value;

    direction += angularVelocity * GameState::deltaTime * perc;
    position += getVector( direction ) * velocity * GameState::deltaTime * perc;

    mesh.position = vec3( position, 0.f );
    mesh.rotation.z = direction - 180;
    mesh.scale = vec3( size, 1.f ) * perc;
    mesh.color.a = perc;
}

void FX_Muzzle::Spark::draw( ) {
    if (life.isDone( ))
        return;

    mesh.draw( );
}

Networking

Server source at GitHub

After each round played, the players' stats are uploaded to a server which stores it in a database. The server is written in C# and compiled with Mono to run on a remote Linux server. HellGun communicates with the server through TCP socketing, using a simple query protocol.

Scoreboard in the game. Displays the top 5 entries, as well as 5 local entries. All of this data is received from the server after every game.

Interface on the server. Accessed with SSH though PuTTY.

Queries

Each square represents a byte

The format of the packets sent between the client and server. The client will send a query, and if the data is valid the server will send a response.

Add Request

Get Request

OpenGL Library (GLT)

GLT source at GitHub

The GLT (OpenGL Tools) library has three main elements:

OpenGL Classes

To minimize direct OpenGL calls, classes are made for the most common OpenGL functionality.

Rendering Classes

To make the pipeline of Shaders, VAOs and VBOs a bit simpler to use, the Mesh class is designed to handle standard attribute buffers such as vertex positions, color, normal and UV. The class also handles binding all these buffers to specified attributes.

The Transform struct is used for handling position, rotation and scale for objects in world space. The struct will output MVP and Normal matrices for use in renderering.

Utilities

Some utilites such as Fonts, FrameBuffer rendering, Cameras and Timers are included in GLT to make sure that creating working games is as smooth as possible.