Import old project

CMakeLists.txt

@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.7)
+project(TinyShooter)
+
+set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/modules")
+
+find_package(SDL2)
+find_package(SDL2_image)
+find_package(Box2D)
+include_directories(${SDL2_INCLUDE_DIR} ${SDL2_IMAGE_INCLUDE_DIR} ${BOX2D_INCLUDE_DIR})
+
+set(CMAKE_CXX_STANDARD 11)
+
+set(SOURCE_FILES
+        main.cpp
+        GameCore.cpp
+        Control/Input.cpp
+        Control/InputAndJoy.cpp
+        Control/MouseCtrl.cpp
+        Control/JoyPadCtrl.cpp
+        Control/Controller.cpp
+        Graphics/Renderer.cpp
+        Graphics/Visual.cpp
+        Physics/TinyWorld.cpp
+        Physics/Entity.cpp
+        Physics/Wall.cpp
+        Physics/Bullet.cpp
+        Physics/Soldier.cpp
+        Physics/HumanSoldier.cpp
+        Physics/AISoldier.cpp
+        Physics/b2Angle.cpp
+        Physics/ScullingQuery.cpp)
+
+add_executable(TinyShooter ${SOURCE_FILES})
+
+target_link_libraries(TinyShooter ${SDL2_LIBRARY} ${SDL2_IMAGE_LIBRARY} ${BOX2D_LIBRARY})

Control/Controller.cpp

@@ -0,0 +1,36 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include "Controller.h"
+
+Controller::Controller()
+        : m_jump(false), m_firing(false), m_shield(false),
+          m_visor(0.0f, 0.0f), m_move(0.0f, 0.0f), m_zoomScale(1.0f) {
+
+}
+
+bool Controller::isJumping() const {
+    return m_jump;
+}
+
+bool Controller::isFiring() const {
+    return m_firing;
+}
+
+bool Controller::isShielded() const {
+    return m_shield;
+}
+
+const b2Vec2 &Controller::getVisor() const {
+    return m_visor;
+}
+
+const b2Vec2 &Controller::getMove() const {
+    return m_move;
+}
+
+float Controller::getZoomScale() const {
+    return m_zoomScale;
+}
+

Control/Controller.h

@@ -0,0 +1,36 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_CONTROLLER_H
+#define TINYSHOOTER_CONTROLLER_H
+
+// todo Use HardContacts with scopes like Visuals in Renderer
+
+#include <Box2D/Box2D.h>
+
+class Controller {
+public:
+    Controller();
+    
+    virtual void refresh() = 0; // Read input and modify behaviour
+
+    bool isJumping() const;
+    bool isFiring() const;
+    bool isShielded() const;
+    const b2Vec2 &getVisor() const;
+    const b2Vec2 &getMove() const;
+
+    float getZoomScale() const;
+
+protected:
+    bool m_jump;
+    bool m_firing;
+    bool m_shield;
+    b2Vec2 m_visor;
+    b2Vec2 m_move;
+    float m_zoomScale;
+};
+
+
+#endif //TINYSHOOTER_CONTROLLER_H

Control/Input.cpp

@@ -0,0 +1,166 @@
+#include "Input.h"
+
+
+// Constructor
+Input::Input()
+        : m_x(0), m_y(0), m_xRel(0), m_yRel(0),
+          m_finished(false), m_relativeMouse(false), m_window(0), m_windowHalfHeight(0), m_windowHalfWidth(0) {
+    // Initialisation du tableau m_keys[]
+    for (int i(0); i < SDL_NUM_SCANCODES; i++)
+        m_keys[i] = false;
+
+    // Initialisation du tableau m_mouseKeys[]
+    for (int i(0); i < 8; i++)
+        m_mouseKeys[i] = false;
+}
+
+// Destructor
+Input::~Input() {}
+
+
+// Methods
+void Input::updateEvents() {
+    // Reset relative coordinates
+    m_xRel = 0;
+    m_yRel = 0;
+
+    // Clear instant keys
+    m_instantKeys.clear();
+
+    // Event loop
+    while (SDL_PollEvent(&m_event)) {
+        if (catchKeyBoardEvents(m_event))
+            continue;
+        else if (catchMouseEvents(m_event))
+            continue;
+        else
+            catchWindowEvents(m_event);
+    }
+
+    // Keeping mouse in window
+    if (m_relativeMouse)
+        SDL_WarpMouseInWindow(m_window, m_windowHalfWidth, m_windowHalfHeight);
+}
+
+bool Input::catchKeyBoardEvents(const SDL_Event &event) {
+    switch (event.type) {
+        case SDL_KEYDOWN:
+            m_keys[event.key.keysym.scancode] = true;
+            m_instantKeys.insert(event.key.keysym.scancode);
+            return true;
+        case SDL_KEYUP:
+            m_keys[event.key.keysym.scancode] = false;
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool Input::catchMouseEvents(const SDL_Event &event) {
+    switch (event.type) {
+        case SDL_MOUSEBUTTONDOWN:
+            m_mouseKeys[event.button.button] = true;
+            return true;
+        case SDL_MOUSEBUTTONUP:
+            m_mouseKeys[event.button.button] = false;
+            return true;
+        case SDL_MOUSEMOTION:
+            if (m_relativeMouse) {
+                m_xRel = event.motion.x - m_windowHalfWidth;
+                m_yRel = event.motion.y - m_windowHalfHeight;
+            } else {
+                m_x = event.motion.x;
+                m_y = event.motion.y;
+                m_xRel = event.motion.xrel;
+                m_yRel = event.motion.yrel;
+            }
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool Input::catchWindowEvents(const SDL_Event &event) {
+    switch (event.type) {
+        case SDL_WINDOWEVENT:
+            if (event.window.event == SDL_WINDOWEVENT_CLOSE)
+                m_finished = true;
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool Input::isFinished() const {
+    return m_finished;
+}
+
+
+void Input::showCursor(bool flag) const {
+    if (flag)
+        SDL_ShowCursor(SDL_ENABLE);
+    else
+        SDL_ShowCursor(SDL_DISABLE);
+}
+
+
+void Input::capPtr(bool flag) {
+    m_relativeMouse = flag;
+}
+
+
+// Getters
+bool Input::getKey(const SDL_Scancode key) const {
+    return m_keys[key];
+}
+
+bool Input::getInstantKey(const SDL_Scancode key) const {
+    return m_instantKeys.find(key) != m_instantKeys.end();
+}
+
+bool Input::getMouseKey(const Uint8 key) const {
+    return m_mouseKeys[key];
+}
+
+
+bool Input::isMouseMoving() const {
+    return !(m_xRel == 0 && m_yRel == 0);
+}
+
+
+// Getters upon cursor position
+int Input::getX() const {
+    return m_x;
+}
+
+int Input::getY() const {
+    return m_y;
+}
+
+int Input::getXFromCenter() {
+    return m_x - m_windowHalfWidth;
+}
+
+int Input::getYFromCenter() {
+    return m_y - m_windowHalfHeight;
+}
+
+int Input::getXRel() const {
+    return m_xRel;
+}
+
+int Input::getYRel() const {
+    return m_yRel;
+}
+
+void Input::setWindow(SDL_Window *activWindow) {
+    // Direct relation
+    m_window = activWindow;
+
+    // Middle computation
+    SDL_GetWindowSize(activWindow, &m_windowHalfWidth, &m_windowHalfHeight);
+    m_windowHalfWidth /= 2;
+    m_windowHalfHeight /= 2;
+}
+
+

Control/Input.h

@@ -0,0 +1,80 @@
+#ifndef DEF_INPUT
+#define DEF_INPUT
+
+///Jovian
+///Centralisation du traitement d'évènement
+
+// Include
+#include <set>
+#include <SDL.h>
+
+
+class Input {
+    /// Methods
+public:
+
+    Input();
+
+    virtual ~Input();
+
+    virtual void updateEvents();
+
+protected: // Deal with an event, return true if caught
+    bool catchKeyBoardEvents(const SDL_Event &event);
+
+    bool catchMouseEvents(const SDL_Event &event);
+
+    bool catchWindowEvents(const SDL_Event &event);
+
+public:
+    bool isFinished() const;
+
+    void showCursor(bool flag) const;
+
+    void capPtr(bool flag);
+
+    bool getKey(const SDL_Scancode key) const;
+
+    bool getInstantKey(const SDL_Scancode key) const;
+
+    bool getMouseKey(const Uint8 key) const;
+
+    bool isMouseMoving() const;
+
+    int getX() const;
+
+    int getY() const;
+
+    int getXFromCenter();
+
+    int getYFromCenter();
+
+    int getXRel() const;
+
+    int getYRel() const;
+
+    void setWindow(SDL_Window *activWindow);
+
+    /// Variables
+protected:
+
+    SDL_Event m_event;
+    bool m_keys[SDL_NUM_SCANCODES];
+    std::set<SDL_Scancode> m_instantKeys;
+    bool m_mouseKeys[8];
+
+    int m_x;
+    int m_y;
+    int m_xRel;
+    int m_yRel;
+
+    bool m_finished;
+    bool m_relativeMouse;
+
+    SDL_Window *m_window;
+    int m_windowHalfHeight;
+    int m_windowHalfWidth;
+};
+
+#endif
+

Control/InputAndJoy.cpp

@@ -0,0 +1,134 @@
+#include "InputAndJoy.h"
+
+// Data description
+struct GamePadData {
+    GamePadData() : joystick(nullptr), nbAxes(0), nbButtons(0) {};
+
+    SDL_Joystick *joystick;
+    int nbAxes;
+    int nbButtons;
+
+    std::vector<int> axeValue;
+    std::vector<bool> buttonValue;
+};
+
+// InputAndJoy methods
+InputAndJoy::InputAndJoy() {
+    // JoyStick init
+    if (SDL_InitSubSystem(SDL_INIT_JOYSTICK) < 0) {
+        std::cout << "InputAndJoy::InputAndJoy() > " << SDL_GetError() << std::endl;
+    } else {
+        // Opening joysticks
+        SDL_JoystickEventState(SDL_ENABLE);
+        SDL_Joystick* currentJoystick(NULL);
+        int i(0);
+        while (true)
+        {
+            // Is a new joystick available
+            currentJoystick = SDL_JoystickOpen(i);
+            
+            if (currentJoystick == NULL)
+                break;
+            
+            m_pad.push_back(new GamePadData);
+            
+            // Read data
+            m_pad[i]->joystick = currentJoystick;
+            m_pad[i]->nbAxes = SDL_JoystickNumAxes(currentJoystick);
+            m_pad[i]->nbButtons = SDL_JoystickNumButtons(currentJoystick);
+            
+            for (int k(0); k < m_pad[i]->nbAxes; k++)
+                m_pad[i]->axeValue.push_back(0);
+            
+            for (int k(0); k < m_pad[i]->nbButtons; k++)
+                m_pad[i]->buttonValue.push_back(false);
+            
+            // Next one
+            i++;
+        }
+    }
+}
+
+InputAndJoy::~InputAndJoy() {
+    while (!m_pad.empty()) {
+        SDL_JoystickClose(m_pad.back()->joystick);
+        delete m_pad.back();
+        m_pad.back() = nullptr;
+        m_pad.pop_back();
+    }
+}
+
+void InputAndJoy::updateEvents() {
+    // Doubling code
+    m_xRel = 0;
+    m_yRel = 0;
+
+    // Clear instant keys
+    m_instantKeys.clear();
+
+    // Super event loop
+    while (SDL_PollEvent(&m_event)) {
+        if (catchKeyBoardEvents(m_event))
+            continue;
+        else if (catchMouseEvents(m_event))
+            continue;
+        else if (catchWindowEvents(m_event))
+            continue;
+        else
+            catchPadEvents(m_event);
+    }
+
+    // Keeping mouse in window
+    if (m_relativeMouse)
+        SDL_WarpMouseInWindow(m_window, m_windowHalfWidth, m_windowHalfHeight);
+}
+
+bool InputAndJoy::catchPadEvents(const SDL_Event &event) {
+    switch (event.type) {
+        case SDL_JOYAXISMOTION:
+            m_pad[event.jaxis.which]->axeValue[event.jaxis.axis] = event.jaxis.value;
+            return true;
+        case SDL_JOYBUTTONDOWN:
+            m_pad[event.jaxis.which]->buttonValue[event.jbutton.button] = true;
+            return true;
+        case SDL_JOYBUTTONUP:
+            m_pad[event.jaxis.which]->buttonValue[event.jbutton.button] = false;
+            return true;
+        default:
+            return false;
+    }
+}
+
+int InputAndJoy::getAxeValue(const Uint8 axeID, Sint32 joyID) const {
+    if (joyID >= m_pad.size()) {
+        std::cout << "InputAndJoy::getAxeValue() > Game-pad " << joyID << " doesn't exist." << std::endl;
+        return -1;
+    }
+
+    if (axeID < m_pad[joyID]->nbAxes)
+        return m_pad[joyID]->axeValue[axeID];
+    else
+        std::cout << "InputAndJoy::getAxeValue() > Axe number " << axeID << " doesn't exist on pad ";
+        std::cout << "number " << joyID << " named " << SDL_JoystickName(m_pad[joyID]->joystick) << "." << std::endl;
+    return -1;
+}
+
+bool InputAndJoy::getButtonPad(const Uint8 button, Sint32 joyID) const {
+    if (joyID >= m_pad.size()) {
+        std::cout << "InputAndJoy::getButtonPad() > Game-pad " << joyID << " doesn't exist." << std::endl;
+        return -1;
+    }
+
+    if (button < m_pad[joyID]->nbButtons)
+        return m_pad[joyID]->buttonValue[button];
+    else
+        std::cout << "InputAndJoy::getButtonPad() > Button number " << button << " doesn't exist on pad ";
+        std::cout << "number " << joyID << " named " << SDL_JoystickName(m_pad[joyID]->joystick) << "." << std::endl;
+    return false;
+}
+
+unsigned long InputAndJoy::getNbPads() const {
+    return m_pad.size();
+}
+
+

Control/InputAndJoy.h

@@ -0,0 +1,48 @@
+#ifndef INPUTANDJOY_H_INCLUDED
+#define INPUTANDJOY_H_INCLUDED
+
+
+//Jovian
+/* InputAndJoy :
+ * Last modification : 3rd August 2017
+ * Allow several game-pads
+ */
+
+// Includes
+#include <SDL.h>
+#include <iostream>
+#include <vector>
+#include "Input.h"
+
+// Data
+struct GamePadData;
+
+// Class
+class InputAndJoy : public Input {
+public:
+
+    InputAndJoy();
+
+    virtual ~InputAndJoy();
+
+    virtual void updateEvents();
+
+protected:
+
+    bool catchPadEvents(const SDL_Event &event);
+
+public:
+
+    int getAxeValue(const Uint8 axeID, Sint32 joyID = 0) const;
+
+    bool getButtonPad(const Uint8 button, Sint32 joyID = 0) const;
+
+    unsigned long getNbPads() const;
+
+
+private:
+    std::vector<GamePadData*> m_pad;
+
+};
+
+#endif // INPUTANDJOY_H_INCLUDED

Control/JoyPadCtrl.cpp

@@ -0,0 +1,58 @@
+//
+// Created by jovian on 01/08/17.
+//
+
+#include "JoyPadCtrl.h"
+
+JoyPadCtrl::JoyPadCtrl(InputAndJoy *inputJoy, SDL_JoystickID id)
+        : m_inputJoy(inputJoy), m_id(id),
+          m_sqCeilMove(100000000.0f), m_sqCeilVisor(500000000.0f) {
+    m_visor.x = 1.0f;
+}
+
+void JoyPadCtrl::refresh() {
+    // Firing
+    m_firing = m_inputJoy->getButtonPad(5, m_id);
+
+    // Shield activation
+    m_shield = m_inputJoy->getButtonPad(0, m_id);
+
+    // Jumping
+    m_jump = m_inputJoy->getButtonPad(4, m_id);
+
+    // Movement
+    m_move.x = (float) m_inputJoy->getAxeValue(0, m_id);
+    m_move.y = (float) m_inputJoy->getAxeValue(1, m_id);
+
+    if (m_move.LengthSquared() < m_sqCeilMove)
+        m_move.SetZero();
+    else
+        m_move.Normalize();
+
+    // Visor
+    b2Vec2 newVisor;
+    newVisor.x = (float) m_inputJoy->getAxeValue(3, m_id);
+    newVisor.y = (float) m_inputJoy->getAxeValue(4, m_id);
+
+    if (newVisor.LengthSquared() > m_sqCeilVisor) {
+        m_visor = newVisor;
+        m_visor.Normalize();
+    }
+
+    // Zoom
+    int axe(30000 + m_inputJoy->getAxeValue(2, m_id));
+    if (axe > 0) {
+        float scale((float) axe / 30000.0f);
+
+        if (scale > m_zoomScale)
+            m_zoomScale = scale;
+    }
+
+    axe = 30000 + m_inputJoy->getAxeValue(5, m_id);
+    if (axe > 0) {
+        float scale((float) 10000.0f / axe);
+
+        if (scale < m_zoomScale)
+            m_zoomScale = scale;
+    }
+}

Control/JoyPadCtrl.h

@@ -0,0 +1,28 @@
+//
+// Created by jovian on 01/08/17.
+//
+
+#ifndef TINYSHOOTER_JOYPADCTRL_H
+#define TINYSHOOTER_JOYPADCTRL_H
+
+
+#include "Controller.h"
+#include "InputAndJoy.h"
+
+class JoyPadCtrl : public Controller {
+public:
+    JoyPadCtrl(InputAndJoy *inputJoy, SDL_JoystickID id = 0);
+
+    void refresh() override;
+
+protected:
+    InputAndJoy *m_inputJoy;
+    SDL_JoystickID m_id;
+
+    const float m_sqCeilMove; // Dead moving joystick zone (squared length)
+    const float m_sqCeilVisor; // Dead visor joystick zone (squared length)
+
+};
+
+
+#endif //TINYSHOOTER_JOYPADCTRL_H

Control/MouseCtrl.cpp

@@ -0,0 +1,38 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include "MouseCtrl.h"
+
+MouseCtrl::MouseCtrl(Input *input) : m_input(input) {
+
+}
+
+void MouseCtrl::refresh() {
+    // Firing
+    m_firing = m_input->getMouseKey(1);
+
+    // Shield activation
+    m_shield = m_input->getMouseKey(3);
+
+    // Jumping
+    m_jump = m_input->getKey(SDL_SCANCODE_SPACE);
+
+    // Movement
+    m_move.SetZero();
+
+    if (m_input->getKey(SDL_SCANCODE_W))
+        m_move.y = -1.0f;
+    else if (m_input->getKey(SDL_SCANCODE_S))
+        m_move.y = 1.0f;
+
+    if (m_input->getKey(SDL_SCANCODE_D))
+        m_move.x = 1.0f;
+    else if (m_input->getKey(SDL_SCANCODE_A))
+        m_move.x = -1.0f;
+
+    // Visor
+    m_visor.x = (float) m_input->getXFromCenter();
+    m_visor.y = (float) m_input->getYFromCenter();
+    m_visor.Normalize();
+}

Control/MouseCtrl.h

@@ -0,0 +1,23 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_MOUSECTRL_H
+#define TINYSHOOTER_MOUSECTRL_H
+
+#include "Controller.h"
+#include "Input.h"
+
+class MouseCtrl : public Controller {
+public:
+    MouseCtrl(Input *input);
+
+    void refresh() override;
+
+protected:
+    Input* m_input;
+
+};
+
+
+#endif //TINYSHOOTER_MOUSECTRL_H

Descriptif.txt

@@ -0,0 +1,32 @@
+Jovian Hersemeule
+
+Why design TinyShooter
+
+Four main reasons :
+1> Practise with CLion
+2> Practise with Box2D an SDL2
+3> Implement and test general classes to use them again in other projects
+4> A shooter is pretty cool to design
+
+1) A powerful editor with a powerless beginner.
+- Learn how to use useful shortcuts
+- Learn how to generate classes
+
+2) and 3) Design classes to easily create games.
+- Rendering management : with Scopes systems in order to separate physics and drawing
+- Input management : use inheritance to swap controllers (mouse / gamepad)
+- Physics and game design : create a class which inherits from b2World,
+in order to manage the userData void pointer.
+
+4) Make a playable game to experiment.
+
+******************************************************
+
+Encountered problems :
+- Visuals are more relevant in Fixture than in Body userData.
+- I have to set a float scaling number to link BoxD length with pixel length. It is hard to determinate where this
+variable should be set : Renderer, GameCore, Controller ? Here I have chosen to set this variable in Soldier since
+this class hasn't a single instance and zoom can be different for each player in a split-screen mode.
+- I forgot to implement a system of event description (similar to Visual description) to separate event and order.
+- I have doubts about update-able and non-update-able entities. For example, walls can't move. However they can have a
+dynamic picture (like a gif).

GameCore.cpp

@@ -0,0 +1,171 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include <iostream>
+#include "GameCore.h"
+#include "Control/MouseCtrl.h"
+#include "Control/JoyPadCtrl.h"
+#include "Physics/b2Angle.h"
+
+GameCore::GameCore()
+        : m_world(nullptr), m_rend(nullptr) {}
+
+GameCore::~GameCore() {
+    // Destroy physic world
+    if (m_world != nullptr) {
+        delete m_world;
+        m_world = nullptr;
+    }
+
+    // Destroy SDL renderer
+    if (m_rend != nullptr) {
+        delete m_rend;
+        m_rend = nullptr;
+    }
+}
+
+bool GameCore::initialize() {
+    // Already initialized
+    if (m_world != nullptr)
+        return false;
+
+    // Error check
+    bool okay(true);
+
+    // Create physic world
+    b2Vec2 gravity(0.0f, 10.0f);
+    m_world = new TinyWorld(gravity);
+
+    // Create display
+    m_rend = new Renderer;
+    okay = okay && m_rend->initialize(2);
+
+    // Create hardware interface
+    m_input = new InputAndJoy;
+    m_input->setWindow(m_rend->getWindow());
+
+    // End
+    return okay;
+}
+
+void GameCore::startQuickGame() {
+    // Time
+    Uint32 frameRate(60); // Frame per second
+    Uint32 prevTime(0); // Previous chrono
+    Uint32 waitTime(1000 / frameRate); // Time to wait between each frame
+    Uint32 osBuffer(4); // To prevent SDL_Delay mistake : high > less mistake, more CPU usage
+
+    float timeStep(1.0f / frameRate);
+    int32 velocityIterations = 8;
+    int32 positionIterations = 3;
+
+    // Textures
+    std::vector<Visual *> myScope, hisScope;
+
+    // Create main character slot
+    HumanSoldier *myGunner(nullptr);
+    HumanSoldier *hisGunner(nullptr);
+
+    // Create controller, game-pad if exists
+    Controller *myCtrl(nullptr);
+    Controller *hisCtrl(nullptr);
+
+    if (m_input->getNbPads() == 0) {
+        myCtrl = new MouseCtrl(m_input);
+        hisCtrl = new MouseCtrl(m_input);
+    } else if (m_input->getNbPads() == 1) {
+        myCtrl = new MouseCtrl(m_input);
+        hisCtrl = new JoyPadCtrl(m_input);
+    } else {
+        myCtrl = new JoyPadCtrl(m_input, 0);
+        hisCtrl = new JoyPadCtrl(m_input, 1);
+    }
+
+    // Visor
+    float visorAngle;
+    b2Vec2 visorPos;
+
+    // Create physical area
+    m_world->createProceduralWorld();
+
+    // Main loop
+    while (!m_input->isFinished() && !m_input->getKey(SDL_SCANCODE_ESCAPE)) {
+        // Update events
+        m_input->updateEvents();
+        myCtrl->refresh();
+        hisCtrl->refresh();
+
+        // New game
+        if (m_input->getInstantKey(SDL_SCANCODE_P)) {
+            // Disable focus on gunners
+            myGunner = nullptr;
+            hisGunner = nullptr;
+
+            // Clear entities
+            m_world->clearEveryEntity();
+
+            // Recreate area
+            m_world->createProceduralWorld();
+        }
+
+        // Update physic
+        m_world->Step(timeStep, velocityIterations, positionIterations);
+
+        if (myGunner == nullptr || !myGunner->isExist()) {
+            myGunner = new HumanSoldier(m_world, myCtrl, b2Vec2(9.0f, -6.8f), 0);
+            m_world->addEntity(myGunner);
+        }
+
+        if (hisGunner == nullptr || !hisGunner->isExist()) {
+            hisGunner = new HumanSoldier(m_world, hisCtrl, b2Vec2(0.0f, -2.8f), 1);
+            m_world->addEntity(hisGunner);
+        }
+
+        m_world->updateAll(); // Clean dead people, including my Gunner
+
+        // Clear visuals
+        clearVisuals(myScope);
+        clearVisuals(hisScope);
+
+        // Gather visible entities
+        m_world->collectVisuals(myScope, myGunner->getPos(), m_rend->computeDiago(myGunner->getZoom(), 0));
+        m_world->collectVisuals(hisScope, hisGunner->getPos(), m_rend->computeDiago(hisGunner->getZoom(), 1));
+
+        // Display visor and life
+        visorPos = 1.2f * myCtrl->getVisor() + myGunner->getPos();
+        visorAngle = b2Angle(myCtrl->getVisor(), b2Vec2(0.0f, -1.0f));
+        myScope.push_back(new Visual(11, visorPos, visorAngle));
+        myScope.push_back(myGunner->makeLifeBar());
+
+        visorPos = 1.2f * hisCtrl->getVisor() + hisGunner->getPos();
+        visorAngle = b2Angle(hisCtrl->getVisor(), b2Vec2(0.0f, -1.0f));
+        hisScope.push_back(new Visual(11, visorPos, visorAngle));
+        hisScope.push_back(hisGunner->makeLifeBar());
+
+        // Rendering
+        m_rend->clearWindow();
+
+        m_rend->renderScene(myScope, myGunner->getPos(), myGunner->getZoom());
+        m_rend->renderScene(hisScope, hisGunner->getPos(), hisGunner->getZoom(), 1);
+
+        m_rend->presentWindow();
+
+        // todo Remove debug
+        /*Uint32 debug_conso(SDL_GetTicks() - prevTime);
+        std::cout << "Time use : " << debug_conso << std::endl;*/
+
+        // Pause
+        if (SDL_GetTicks() + osBuffer < prevTime + waitTime)
+            SDL_Delay(waitTime + prevTime - SDL_GetTicks() - osBuffer);
+
+        while (SDL_GetTicks() < prevTime + waitTime) {}
+
+        prevTime = SDL_GetTicks();
+    }
+
+    // Destruction
+    delete myCtrl;
+    delete hisCtrl;
+}
+

GameCore.h

@@ -0,0 +1,37 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_GAMECORE_H
+#define TINYSHOOTER_GAMECORE_H
+
+// Read hardware commands
+#include "Control/InputAndJoy.h"
+
+// For game contents
+#include "Physics/TinyWorld.h"
+
+// For game display
+#include "Graphics/Renderer.h"
+
+// For creation of entities
+#include "Physics/Wall.h"
+#include "Physics/HumanSoldier.h"
+#include "Physics/AISoldier.h"
+
+class GameCore {
+public :
+    GameCore();
+    virtual ~GameCore();
+
+    bool initialize(); // Create attributes, return false if failure occurred
+    void startQuickGame(); // Start a default game
+
+protected:
+    InputAndJoy *m_input;
+    TinyWorld *m_world;
+    Renderer *m_rend;
+};
+
+
+#endif //TINYSHOOTER_GAMECORE_H

Graphics/Renderer.cpp

@@ -0,0 +1,280 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include <iostream>
+#include <SDL_image.h>
+#include "Renderer.h"
+
+#define RAD_TO_DEG 57.2957795130f
+
+Renderer::Renderer()
+        : m_screenWidth(0), m_screenHeight(0), m_window(nullptr), m_renderer(nullptr), m_border(1) {}
+
+Renderer::~Renderer() {
+    // Destroy textures
+    while (!m_pictureTab.empty()) {
+        if (m_pictureTab.back() != nullptr)
+            SDL_DestroyTexture(m_pictureTab.back());
+        m_pictureTab.pop_back();
+    }
+
+    // Destroy SDL renderer
+    if (m_renderer != nullptr) {
+        SDL_DestroyRenderer(m_renderer);
+        m_renderer = nullptr;
+    }
+
+    // Destroy the beautiful window
+    if (m_window != nullptr) {
+        SDL_DestroyWindow(m_window);
+        m_window = nullptr;
+    }
+}
+
+bool Renderer::initialize(int nbPlayers) {
+    // Announce
+    std::cout << "Renderer::initialize() > ";
+    // Already initialized
+    if (m_window != nullptr) {
+        std::cout << "Window already created." << std::endl << std::endl;
+        return false;
+    }
+
+    // Default screen size
+    m_screenWidth = 1200;
+    m_screenHeight = 700;
+
+    // Init video
+    if (SDL_Init(SDL_INIT_VIDEO) != 0) {
+        std::cout << "SDL video failed : " << SDL_GetError() << std::endl << std::endl;
+        return false;
+    }
+
+    // Opening window
+    m_window = SDL_CreateWindow("< TinyShooter >",
+                                SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+                                m_screenWidth, m_screenHeight,
+                                SDL_WINDOW_SHOWN | SDL_WINDOW_FULLSCREEN_DESKTOP);
+    if (m_window == nullptr) {
+        std::cout << "Window creation failed : " << SDL_GetError() << std::endl << std::endl;
+        SDL_Quit();
+        return false;
+    }
+
+    // Hardware physical screen size
+    SDL_GetWindowSize(m_window, &m_screenWidth, &m_screenHeight);
+
+    // Create renderer
+    m_renderer = SDL_CreateRenderer(m_window, -1,
+                                    SDL_RENDERER_ACCELERATED |
+                                    SDL_RENDERER_PRESENTVSYNC);
+    if (m_renderer == nullptr) {
+        SDL_DestroyWindow(m_window);
+        std::cout << "SDL Renderer creation failed : " << SDL_GetError() << std::endl << std::endl;
+        SDL_Quit();
+        return false;
+    }
+
+    // Split-screen
+    locateViews(nbPlayers);
+
+    // End
+    std::cout << "Done, no error detected." << std::endl;
+
+    // Okay
+    return loadEveryPicture();
+}
+
+void Renderer::clearWindow() {
+    // Clean up buffer
+    SDL_SetRenderDrawColor(m_renderer, 0x00, 0x00, 0x00, 0x00);
+    SDL_RenderClear(m_renderer);
+}
+
+void Renderer::renderScene(std::vector<Visual *> &scope, const b2Vec2 &center, float zoom, int which) {
+    // Rect
+    SDL_Rect dst;
+    SDL_Texture *tex;
+    b2Vec2 rel;
+
+    // View port (useful with split-screen)
+    if (which < 0 || which > 3)
+        return;
+    SDL_RenderSetViewport(m_renderer, &m_viewPort[which]);
+
+    SDL_SetRenderDrawColor(m_renderer, 0xFF, 0xFF, 0xFF, 0xFF);
+    dst.x = 0;
+    dst.y = 0;
+    dst.w = m_viewPort[which].w;
+    dst.h = m_viewPort[which].h;
+    SDL_RenderFillRect(m_renderer, &dst);
+
+    // For each
+    for (auto it(scope.begin()); it != scope.end(); it++) {
+        // Skip if invalid texture
+        if ((*it)->getImgId() > m_pictureTab.size() || m_pictureTab[(*it)->getImgId()] == nullptr)
+            continue;
+        tex = m_pictureTab[(*it)->getImgId()];
+
+        // Rect set up
+        rel = (*it)->getPos() - center;
+        dst.x = (int) (rel.x * zoom) + m_viewPort[which].w / 2;
+        dst.y = (int) (rel.y * zoom) + m_viewPort[which].h / 2;
+        SDL_QueryTexture(tex, NULL, NULL, &dst.w, &dst.h);
+
+        // Zoom correction
+        dst.w = (int) (zoom * dst.w / DEFAULT_ZOOM);
+        dst.h = (int) (zoom * dst.h / DEFAULT_ZOOM);
+
+        // Center texture
+        dst.x -= dst.w / 2;
+        dst.y -= dst.h / 2;
+
+        // SDL rendering
+        SDL_RenderCopyEx(m_renderer, tex, NULL, &dst, (*it)->getAngle() * RAD_TO_DEG, NULL, SDL_FLIP_NONE);
+    }
+
+}
+
+void Renderer::presentWindow() {
+    // Activate display
+    SDL_RenderPresent(m_renderer);
+}
+
+bool Renderer::loadPicture(std::string name) {
+    SDL_Texture *texture = IMG_LoadTexture(m_renderer, name.c_str());
+
+    if (texture == nullptr) {
+        std::cout << "Renderer::loadPicture() > " << SDL_GetError() << std::endl << std::endl;
+        return false;
+    }
+
+    m_pictureTab.push_back(texture);
+    return true;
+}
+
+bool Renderer::loadEveryPicture() {
+    bool okay(true);
+    okay = okay && loadPicture("Pictures/NoPict.png");      // 0
+    okay = okay && loadPicture("Pictures/Ally.png");        // 1
+    okay = okay && loadPicture("Pictures/TinyWall1.png");   // 2
+    okay = okay && loadPicture("Pictures/TinyWall2.png");   // 3
+    okay = okay && loadPicture("Pictures/TinyWall3.png");   // 4
+    okay = okay && loadPicture("Pictures/TinyWall4.png");   // 5
+    okay = okay && loadPicture("Pictures/HighWall1.png");   // 6
+    okay = okay && loadPicture("Pictures/HighWall2.png");   // 7
+    okay = okay && loadPicture("Pictures/HighWall3.png");   // 8
+    okay = okay && loadPicture("Pictures/HighWall4.png");   // 9
+    okay = okay && loadPicture("Pictures/RedVisor.png");    // 10
+    okay = okay && loadPicture("Pictures/RedArrow.png");    // 11
+    okay = okay && loadPicture("Pictures/Bullet1.png");     // 12
+    okay = okay && loadPicture("Pictures/Foe.png");         // 13
+    okay = okay && loadPicture("Pictures/Bullet2.png");     // 14
+    okay = okay && loadPicture("Pictures/LifeBar1.png");     // 15
+    okay = okay && loadPicture("Pictures/LifeBar2.png");     // 16
+    okay = okay && loadPicture("Pictures/LifeBar3.png");     // 17
+    okay = okay && loadPicture("Pictures/LifeBar4.png");     // 18
+    okay = okay && loadPicture("Pictures/LifeBar5.png");     // 19
+    okay = okay && loadPicture("Pictures/LifeBar6.png");     // 20
+    okay = okay && loadPicture("Pictures/WideWall1.png");     // 21
+    okay = okay && loadPicture("Pictures/WideWall2.png");     // 22
+    okay = okay && loadPicture("Pictures/WideWall3.png");     // 23
+    okay = okay && loadPicture("Pictures/WideWall4.png");     // 24
+    okay = okay && loadPicture("Pictures/BigWall1.png");     // 25
+    okay = okay && loadPicture("Pictures/BigWall2.png");     // 26
+    okay = okay && loadPicture("Pictures/BigWall3.png");     // 27
+    okay = okay && loadPicture("Pictures/BigWall4.png");     // 28
+
+    return okay;
+}
+
+SDL_Window *Renderer::getWindow() const {
+    return m_window;
+}
+
+void Renderer::locateViews(int nbPlayers) {
+    switch (nbPlayers) {
+        default: // One player
+            // First and single screen
+            m_viewPort[0].x = 0;
+            m_viewPort[0].y = 0;
+            m_viewPort[0].w = m_screenWidth;
+            m_viewPort[0].h = m_screenHeight;
+            break;
+        case 2: // Two players
+            // First screen
+            m_viewPort[0].x = 0;
+            m_viewPort[0].y = 0;
+            m_viewPort[0].w = m_screenWidth / 2 - m_border;
+            m_viewPort[0].h = m_screenHeight;
+
+            // Second screen
+            m_viewPort[1].x = m_screenWidth / 2 + m_border;
+            m_viewPort[1].y = 0;
+            m_viewPort[1].w = m_screenWidth / 2;
+            m_viewPort[1].h = m_screenHeight;
+            break;
+        case 3: // Three players
+            // First screen
+            m_viewPort[0].x = 0;
+            m_viewPort[0].y = 0;
+            m_viewPort[0].w = m_screenWidth / 2 - m_border;
+            m_viewPort[0].h = m_screenHeight / 2;
+
+            // Second screen
+            m_viewPort[1].x = m_screenWidth / 2 + m_border;
+            m_viewPort[1].y = 0;
+            m_viewPort[1].w = m_screenWidth / 2;
+            m_viewPort[1].h = m_screenHeight / 2;
+
+            // Third screen
+            m_viewPort[2].x = m_screenWidth / 4;
+            m_viewPort[2].y = m_screenHeight / 2 + m_border;
+            m_viewPort[2].w = m_screenWidth / 2;
+            m_viewPort[2].h = m_screenHeight / 2;
+            break;
+        case 4: // Four players
+            // First screen
+            m_viewPort[0].x = 0;
+            m_viewPort[0].y = 0;
+            m_viewPort[0].w = m_screenWidth / 2 - m_border;
+            m_viewPort[0].h = m_screenHeight / 2;
+
+            // Second screen
+            m_viewPort[1].x = m_screenWidth / 2 + m_border;
+            m_viewPort[1].y = 0;
+            m_viewPort[1].w = m_screenWidth / 2;
+            m_viewPort[1].h = m_screenHeight / 2;
+
+            // Third screen
+            m_viewPort[2].x = 0;
+            m_viewPort[2].y = m_screenHeight / 2;
+            m_viewPort[2].w = m_screenWidth / 2 - m_border;
+            m_viewPort[2].h = m_screenHeight / 2;
+
+            // Fourth screen
+            m_viewPort[3].x = m_screenWidth / 2 + m_border;
+            m_viewPort[3].y = m_screenHeight / 2;
+            m_viewPort[3].w = m_screenWidth / 2;
+            m_viewPort[3].h = m_screenHeight / 2;
+            break;
+    }
+}
+
+b2Vec2 Renderer::computeDiago(float zoom, int which) {
+    // Test limits
+    if (which < 0 || which > 3)
+        return b2Vec2_zero;
+
+    // Compute with view-port dims and zoom
+    b2Vec2 rep;
+
+    rep.x = m_viewPort[which].w / 2;
+    rep.x /= zoom;
+
+    rep.y = m_viewPort[which].h / 2;
+    rep.y /= zoom;
+
+    return rep;
+}

Graphics/Renderer.h

@@ -0,0 +1,52 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_RENDERER_H
+#define TINYSHOOTER_RENDERER_H
+
+#include <SDL.h>
+#include <vector>
+#include "Visual.h"
+
+class Renderer {
+public :
+    Renderer();
+
+    virtual ~Renderer();
+
+    bool initialize(int nbPlayers = 1); // Initialize SDL and load features (return false if error)
+
+    void clearWindow(); // Clear all content
+    void renderScene(std::vector<Visual *> &scope, const b2Vec2 &center, float zoom, int which = 0); // Displays a view
+    void presentWindow(); // Refresh window
+
+    SDL_Window *getWindow() const;
+
+    /**
+     * Compute a useful distance for AABB sculling query
+     * @param zoom : Current zoom level
+     * @param which : Which viewport
+     * @return b2Vec2 double positive semi diagonale
+     */
+    b2Vec2 computeDiago(float zoom, int which = 0);
+
+private:
+    bool loadPicture(std::string name); // Load a single picture
+    bool loadEveryPicture(); // Load all contents needed in the game
+    void locateViews(int nbPlayers); // Locate viewports for splitscreen
+
+protected:
+    int m_screenWidth;
+    int m_screenHeight;
+
+    SDL_Window *m_window; // SDL main window
+    SDL_Renderer *m_renderer; // SDL main renderer
+    std::vector<SDL_Texture *> m_pictureTab; // Every game texture
+
+    const int m_border; // Split screen offset
+    SDL_Rect m_viewPort[4]; // Screen partition
+};
+
+
+#endif //TINYSHOOTER_RENDERER_H

Graphics/Visual.cpp

@@ -0,0 +1,31 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include "Visual.h"
+
+Visual::Visual(unsigned int imgId, const b2Vec2 &relPos, float angle)
+        : m_imgId(imgId), m_relPos(relPos), m_angle(angle) {}
+
+unsigned int Visual::getImgId() const {
+    return m_imgId;
+}
+
+const b2Vec2 &Visual::getPos() const {
+    return m_relPos;
+}
+
+float Visual::getAngle() const {
+    return m_angle;
+}
+
+void clearVisuals(std::vector<Visual *> &scope) {
+    while (!scope.empty()) {
+        if (scope.back() != nullptr) {
+            delete scope.back();
+            scope.back() = nullptr;
+        }
+
+        scope.pop_back();
+    }
+}

Graphics/Visual.h

@@ -0,0 +1,33 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_VISUAL_H
+#define TINYSHOOTER_VISUAL_H
+
+#include <Box2D/Box2D.h>
+
+/* class Visual :
+ * Describe something to show.
+ */
+
+#define DEFAULT_ZOOM 100.0f // Default Box2D/pixel scale
+
+class Visual {
+public :
+    Visual(unsigned int imgId, const b2Vec2 &relPos, float angle);
+
+    unsigned int getImgId() const;
+    const b2Vec2 &getPos() const;
+    float getAngle() const;
+
+protected:
+    unsigned int m_imgId; // Id of SDL texture
+    b2Vec2 m_relPos; // From left top corner
+    float m_angle; // Angle of object
+};
+
+void clearVisuals(std::vector<Visual*> &scope);
+
+
+#endif //TINYSHOOTER_VISUAL_H

Physics/AISoldier.cpp

@@ -0,0 +1,14 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include "AISoldier.h"
+
+AISoldier::AISoldier(TinyWorld *tinyWorld)
+:Soldier(FOE, nullptr, tinyWorld, 0, 1, 56) {
+    // todo : Set the AI ctrl
+}
+
+void AISoldier::update() {
+
+}

Physics/AISoldier.h

@@ -0,0 +1,19 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_FOE_H
+#define TINYSHOOTER_FOE_H
+
+#include "Soldier.h"
+
+class AISoldier : public Soldier {
+public:
+    AISoldier(TinyWorld *tinyWorld);
+
+    void update() override;
+
+};
+
+
+#endif //TINYSHOOTER_FOE_H

Physics/Bullet.cpp

@@ -0,0 +1,89 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include <iostream>
+#include "Bullet.h"
+#include "b2Angle.h"
+#define DEFAULT_TIME_LIFE 480
+
+
+Bullet::Bullet(const b2Vec2 &pos, b2World *physics, const b2Vec2 &dir, unsigned int camp)
+        : Entity(BULLET, 0, physics),
+          m_damageScale(0.015f), m_timeLife(DEFAULT_TIME_LIFE), m_camp(camp), m_aero(0.003f) {
+    // Creation of physical body
+    b2BodyDef bodyDef;
+    bodyDef.type = b2_dynamicBody;
+    bodyDef.position = pos;
+    bodyDef.angle = b2Angle(dir);
+    bodyDef.fixedRotation = false;
+    bodyDef.bullet = true;
+    bodyDef.angularDamping = 5.0f;
+    m_body = physics->CreateBody(&bodyDef);
+
+    // Creation of triangle shape
+    b2Vec2 vertices[3];
+    vertices[0].Set(-9.0f / DEFAULT_ZOOM, 10.0f / DEFAULT_ZOOM);
+    vertices[1].Set(9.8f / DEFAULT_ZOOM, 0.0f);
+    vertices[2].Set(-9.0f / DEFAULT_ZOOM, -10.0f / DEFAULT_ZOOM);
+
+    b2PolygonShape shape;
+    shape.Set(vertices, 3);
+
+    // Definition of fixture
+    b2FixtureDef fixtureDef;
+    fixtureDef.shape = &shape;
+    fixtureDef.density = 1.0f;
+    fixtureDef.friction = 0.03f;
+    fixtureDef.restitution = 0.1f;
+
+    // Fixture filtering
+    if (m_camp == 0)
+        fixtureDef.filter.categoryBits = 0b0010;
+    else if (m_camp == 1)
+        fixtureDef.filter.categoryBits = 0b1000;
+
+    fixtureDef.filter.maskBits = 0b1111;
+
+    // Creation of fixture
+    m_body->CreateFixture(&fixtureDef);
+
+    // Initial propulsion
+    m_body->SetLinearVelocity(42.0f * dir);
+
+    // Appearance
+    if (camp == 0)
+        m_imgId = 12;
+    else if (camp == 1)
+        m_imgId = 14;
+
+    // Link this bullet
+    establishPhysicalLink();
+}
+
+void Bullet::update() {
+    // Aerodynamic
+    b2Vec2 dir(m_body->GetLinearVelocity());
+    const float speed(dir.Length());
+
+    if (m_body->IsAwake() && speed > 0.0f) {
+        dir = 1.0f / speed * dir;
+
+        m_body->ApplyForce(-speed * speed * m_aero * dir, m_body->GetWorldPoint(b2Vec2(-0.2f, 0.0f)), true);
+    }
+
+    // Decrease CPU load when bullet is slower
+    if (m_body->IsBullet() && speed < 7.75f && m_timeLife < DEFAULT_TIME_LIFE) {
+        m_body->SetBullet(false);
+    }
+
+    // Existence
+    if (m_timeLife == 0 || m_body->GetPosition().y > 100.0f)
+        m_exist = false;
+    else //if (!m_body->IsAwake())
+        m_timeLife--;
+}
+
+int Bullet::getDamage() const {
+    return (int) (m_damageScale * m_body->GetLinearVelocity().LengthSquared()) + 1;
+}

Physics/Bullet.h

@@ -0,0 +1,27 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_BULLET_H
+#define TINYSHOOTER_BULLET_H
+
+#include "Entity.h"
+
+class Bullet : public Entity {
+public :
+    Bullet(const b2Vec2 &pos, b2World* physics, const b2Vec2 &dir, unsigned int camp);
+
+    void update() override;
+
+    int getDamage() const;
+
+protected:
+    float m_damageScale; // Damage multiplier on impact
+    unsigned int m_timeLife; // Number of ticks before dying
+    unsigned int m_camp; // The camp of the shooter
+
+    const float m_aero;
+};
+
+
+#endif //TINYSHOOTER_BULLET_H

Physics/Entity.cpp

@@ -0,0 +1,59 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include <iostream>
+#include "Entity.h"
+
+
+Entity::Entity(Faction faction, unsigned int imgId, b2World *physics)
+        : m_faction(faction), m_exist(true), m_physics(physics), m_body(nullptr), m_imgId(imgId) {
+
+}
+
+Entity::~Entity() {
+    if (m_body != nullptr)
+        m_physics->DestroyBody(m_body);
+}
+
+Visual *Entity::makeVisual() {
+    return new Visual(m_imgId, m_body->GetPosition(), m_body->GetAngle());
+}
+
+bool Entity::isExist() const {
+    return m_exist;
+}
+
+bool Entity::isTouching() const {
+    bool touch(false);
+
+    for (b2ContactEdge *ce(m_body->GetContactList()); ce && !touch; ce = ce->next)
+        touch = ce->contact->IsTouching();
+
+    return touch;
+}
+
+b2Vec2 Entity::getPos() const {
+    if (m_body == nullptr)
+        return b2Vec2(0.0f, 0.0f);
+    else
+        return m_body->GetPosition();
+}
+
+void Entity::establishPhysicalLink() {
+    if (m_body == nullptr) {
+        std::cout << "Entity::establishPhysicalLink() > Body is invalid for a " << m_faction << " object." << std::endl;
+        return;
+    } else {
+        m_body->SetUserData(this);
+    }
+}
+
+Faction Entity::getFaction() const {
+    return m_faction;
+}
+
+void Entity::setExistence(bool exist) {
+    Entity::m_exist = exist;
+}
+

Physics/Entity.h

@@ -0,0 +1,48 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_ENTITY_H
+#define TINYSHOOTER_ENTITY_H
+
+#include <Box2D/Box2D.h>
+#include <vector>
+#include "../Graphics/Visual.h"
+
+enum Faction {WALL, BULLET, ALLY, FOE};
+
+/* class Entity :
+ * Store interactive data of a game object.
+ */
+class Entity {
+    /// Methods :
+public :
+    Entity(Faction faction, unsigned int imgId, b2World* physics);
+    virtual ~Entity();
+
+    virtual void update() = 0; // Update physical and game entity
+    virtual Visual* makeVisual(); // Generate graphical description
+
+    bool isExist() const;
+    bool isTouching() const;
+    b2Vec2 getPos() const;
+    Faction getFaction() const;
+
+    void setExistence(bool exist);
+
+protected:
+    void establishPhysicalLink(); // Put entity data in body's user-data
+
+    /// Variables :
+protected:
+    Faction m_faction; // Allows identification in TinyWorld
+    bool m_exist; // Entity is destroyed if set to false
+
+    b2World* m_physics; // Link to physic world
+    b2Body* m_body; // Link to physic world
+
+    unsigned int m_imgId; // Current picture id
+};
+
+
+#endif //TINYSHOOTER_ENTITY_H

Physics/HumanSoldier.cpp

@@ -0,0 +1,27 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include "HumanSoldier.h"
+
+HumanSoldier::HumanSoldier(TinyWorld *tinyWorld, Controller *ctrl, b2Vec2 spawn, unsigned int camp)
+        : Soldier(ALLY, ctrl, tinyWorld, 0, camp, 100), m_zoom(DEFAULT_ZOOM) {
+    // Shape
+    createPhysicalShape(spawn);
+}
+
+void HumanSoldier::update() {
+    // Zoom
+    m_zoom = DEFAULT_ZOOM * m_ctrl->getZoomScale();
+
+    // Call Soldier update
+    Soldier::update();
+}
+
+Visual *HumanSoldier::makeLifeBar() {
+    return new Visual(15 + m_life / 17, m_body->GetPosition() + b2Vec2(0.0f, -0.75f), 0.0f);
+}
+
+float HumanSoldier::getZoom() const {
+    return m_zoom;
+}

Physics/HumanSoldier.h

@@ -0,0 +1,25 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_ALLY_H
+#define TINYSHOOTER_ALLY_H
+
+#include "Soldier.h"
+
+class HumanSoldier : public Soldier {
+public:
+    HumanSoldier(TinyWorld *tinyWorld, Controller *ctrl, b2Vec2 spawn = b2Vec2_zero, unsigned int camp = 0);
+
+    void update() override;
+
+    Visual* makeLifeBar();
+
+    float getZoom() const;
+
+protected:
+    float m_zoom; // Scale from Box2D to SDL2 length
+};
+
+
+#endif //TINYSHOOTER_ALLY_H

Physics/ScullingQuery.cpp

@@ -0,0 +1,15 @@
+//
+// Created by jovian on 15/08/17.
+//
+
+#include "ScullingQuery.h"
+
+bool ScullingQuery::ReportFixture(b2Fixture *fixture) {
+    m_tab.push_back(fixture->GetBody());
+
+    return true;
+}
+
+const std::vector<b2Body *> &ScullingQuery::getTab() const {
+    return m_tab;
+}

Physics/ScullingQuery.h

@@ -0,0 +1,21 @@
+//
+// Created by jovian on 15/08/17.
+//
+
+#ifndef TINYSHOOTER_SCULLINGQUERY_H
+#define TINYSHOOTER_SCULLINGQUERY_H
+
+#include <Box2D/Box2D.h>
+
+class ScullingQuery : public b2QueryCallback {
+public:
+    bool ReportFixture(b2Fixture *fixture) override;
+
+    const std::vector<b2Body *> &getTab() const;
+
+private:
+    std::vector<b2Body *> m_tab;
+};
+
+
+#endif //TINYSHOOTER_SCULLINGQUERY_H

Physics/Soldier.cpp

@@ -0,0 +1,134 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include <iostream>
+#include "Soldier.h"
+
+Soldier::Soldier(Faction faction, Controller *ctrl, TinyWorld *tinyWorld,
+                 unsigned int imgId, unsigned int camp, unsigned int life)
+        : Entity(faction, imgId, tinyWorld),
+          m_ctrl(ctrl), m_camp(camp), m_life(life), m_tinyWorld(tinyWorld), m_homeFixture(nullptr),
+          m_forceXScale(22.0f), m_forceYScale(5.0f), m_jumpVec(0.0f, -500.0f), m_jumpVelocityLimit(-0.5f),
+          m_cool(0), m_coolCeil(10) {
+    // Set the correct image
+    if (imgId == 0) {
+        if (m_camp == 0)
+            m_imgId = 1;
+        else if (m_camp == 1)
+            m_imgId = 13;
+    }
+
+}
+
+void Soldier::shoot(const b2Vec2 &dir) {
+    m_cool = 0;
+    m_tinyWorld->addEntity(new Bullet(m_body->GetPosition(), m_tinyWorld, dir, m_camp));
+}
+
+void Soldier::update() {
+    // Life exist
+    if (m_life == 0)
+        m_exist = false;
+
+    // A soldier fell out the world
+    if (m_body->GetPosition().y > 100.0f)
+        m_exist = false;
+
+    // Firing
+    m_cool++;
+    if (m_ctrl->isFiring() && m_cool > m_coolCeil)
+        shoot(m_ctrl->getVisor());
+
+    // todo Shield activation
+
+    // Movement
+    b2Vec2 move(m_ctrl->getMove());
+    move.x *= m_forceXScale;
+    move.y *= m_forceYScale;
+    m_body->ApplyForceToCenter(move, true);
+
+    // Jumping
+    if (isTouching()
+        && m_ctrl->isJumping()
+        && m_body->GetLinearVelocity().y > m_jumpVelocityLimit) {
+
+        m_body->ApplyForceToCenter(m_jumpVec, true);
+    }
+
+    // Damage taken by bullet
+    for (b2ContactEdge *ce = m_body->GetContactList(); ce; ce = ce->next) {
+        b2Contact *c = ce->contact;
+
+        // Get incoming fixture
+        b2Fixture *incomingFixture(c->GetFixtureA());
+
+        if (incomingFixture == m_homeFixture)
+            incomingFixture = c->GetFixtureB();
+
+        // Detect bullet presence
+        Entity *incomingEntity((Entity *) incomingFixture->GetBody()->GetUserData());
+
+        if (incomingEntity->getFaction() == BULLET) {
+            // Damage
+            Bullet *incomingBullet((Bullet*)incomingEntity);
+            int damage(incomingBullet->getDamage());
+
+            if (m_life < damage)
+                m_life = 0;
+            else
+                m_life -= damage;
+
+            // Bullet destroyed
+            incomingEntity->setExistence(false);
+        }
+    }
+}
+
+void Soldier::createPhysicalShape(b2Vec2 spawn) {
+    // Already exists ?
+    if (m_body != nullptr) {
+        std::cout << "Soldier::createPhysicalShape() > Body non null pointer. Creation aborted." << std::endl;
+        return;
+    }
+
+    // Creation of physical body
+    b2BodyDef bodyDef;
+    bodyDef.type = b2_dynamicBody;
+    bodyDef.position = spawn;
+    bodyDef.fixedRotation = true;
+    m_body = m_tinyWorld->CreateBody(&bodyDef);
+
+    // Creation of super shape
+    b2Vec2 vertices[5];
+    vertices[0].Set(0.0f, 40.0f / DEFAULT_ZOOM);
+    vertices[1].Set(20.0f / DEFAULT_ZOOM, -2.0f / DEFAULT_ZOOM);
+    vertices[2].Set(20.0f / DEFAULT_ZOOM, -38.0f / DEFAULT_ZOOM);
+    vertices[3].Set(-20.0f / DEFAULT_ZOOM, -38.0f / DEFAULT_ZOOM);
+    vertices[4].Set(-20.0f / DEFAULT_ZOOM, -2.0f / DEFAULT_ZOOM);
+
+    b2PolygonShape allyShape;
+    allyShape.Set(vertices, 5);
+
+    // Definition of fixture
+    b2FixtureDef fixtureDef;
+    fixtureDef.shape = &allyShape;
+    fixtureDef.density = 6.0f;
+    fixtureDef.friction = 0.3f;
+
+    // Fixture filtering
+    if (m_camp == 0) {
+        fixtureDef.filter.categoryBits = 0b0001;
+        fixtureDef.filter.maskBits = 0b1101;
+    } else if (m_camp == 1) {
+        fixtureDef.filter.categoryBits = 0b0100;
+        fixtureDef.filter.maskBits = 0b0111;
+    }
+
+    // Creation of fixture
+    m_homeFixture = m_body->CreateFixture(&fixtureDef);
+
+    // Link this soldier
+    establishPhysicalLink();
+}
+

Physics/Soldier.h

@@ -0,0 +1,43 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_SOLDIER_H
+#define TINYSHOOTER_SOLDIER_H
+
+#include "Entity.h"
+#include "Bullet.h"
+#include "TinyWorld.h"
+#include "../Control/Controller.h"
+
+class Soldier : public Entity {
+public:
+    Soldier(Faction faction, Controller *ctrl, TinyWorld* tinyWorld,
+            unsigned int imgId, unsigned int camp, unsigned int life = 100);
+
+    void shoot(const b2Vec2 &dir);
+
+    virtual void update();
+
+    void createPhysicalShape(b2Vec2 spawn = b2Vec2_zero);
+
+protected:
+    Controller *m_ctrl; // Decision interface
+    unsigned int m_camp; // 0 : ally, 1 : foe
+    unsigned int m_life; // alive if above 0
+    TinyWorld* m_tinyWorld; // Allows shooting (And allows AI to take decisions)
+    b2Fixture* m_homeFixture; // Allows bullet determination in contacts
+
+    // Movements
+    float m_forceXScale;
+    float m_forceYScale;
+    b2Vec2 m_jumpVec;
+    float m_jumpVelocityLimit;
+
+    // Weapon
+    unsigned int m_cool;
+    const unsigned int m_coolCeil;
+};
+
+
+#endif //TINYSHOOTER_SOLDIER_H

Physics/TinyWorld.cpp

@@ -0,0 +1,80 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include "TinyWorld.h"
+#include "ScullingQuery.h"
+#include "Wall.h"
+
+#define MAX_BLOCS_NUMBER 350
+#define MIN_BLOCS_NUMBER 6
+
+#define MAX_WIDTH 150
+#define MIN_WIDTH 50
+
+#define MAX_HEIGHT 60
+#define MIN_HEIGHT 10
+
+TinyWorld::TinyWorld(const b2Vec2 &gravity) : b2World(gravity) {}
+
+void TinyWorld::createProceduralWorld() {
+    // Determine number of blocs
+    int numberOfBlocs(MIN_BLOCS_NUMBER + rand() % (MAX_BLOCS_NUMBER - MIN_BLOCS_NUMBER));
+
+    // Dims
+    float width(MIN_WIDTH + rand() % (MAX_WIDTH - MIN_WIDTH));
+    float height(MIN_HEIGHT + rand() % (MAX_HEIGHT - MIN_HEIGHT));
+
+    // Bloc sizes
+    WallShape shapeTab[4] = {TINY, HIGH, WIDE, BIG};
+
+    // Generate
+    for (int k(0); k < numberOfBlocs; k++) {
+        addEntity(new Wall(b2Vec2(width * rand() / RAND_MAX, height * rand() / RAND_MAX), this, shapeTab[rand() % 4]));
+    }
+}
+
+void TinyWorld::addEntity(Entity *newcomer) {
+    m_entities.push_back(newcomer);
+}
+
+void TinyWorld::clearEveryEntity() {
+    auto it(m_entities.begin());
+    while (it != m_entities.end()) {
+        delete (*it);
+        it = m_entities.erase(it);
+    }
+}
+
+void TinyWorld::updateAll() {
+    for (auto it(m_entities.begin()); it != m_entities.end(); it++) {
+        // Clean dead entities
+        while (it != m_entities.end() && !(*it)->isExist()) {
+            delete (*it);
+            it = m_entities.erase(it);
+        }
+
+        // Update living entity
+        if (it != m_entities.end())
+            (*it)->update();
+    }
+}
+
+void TinyWorld::collectVisuals(std::vector<Visual *> &scope, b2Vec2 center, b2Vec2 diago) {
+    /*for (auto it(m_entities.begin()); it != m_entities.end(); it++) {
+        scope.push_back((*it)->makeVisual());
+    }*/
+
+    ScullingQuery callback;
+    b2AABB aabb;
+    aabb.lowerBound = center - diago;
+    aabb.upperBound = center + diago;
+    QueryAABB(&callback, aabb);
+
+    Entity *currentEntity;
+    for (auto it(callback.getTab().begin()); it != callback.getTab().end(); it++) {
+        currentEntity = (Entity *) (*it)->GetUserData();
+        scope.push_back(currentEntity->makeVisual());
+    }
+}
+

Physics/TinyWorld.h

@@ -0,0 +1,37 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_TINYWORLD_H
+#define TINYSHOOTER_TINYWORLD_H
+
+#include <Box2D/Box2D.h>
+#include <list>
+#include "../Graphics/Visual.h"
+#include "Entity.h"
+
+class TinyWorld : public b2World {
+public:
+    TinyWorld(const b2Vec2 &gravity);
+
+    // Build a procedural world
+    void createProceduralWorld();
+
+    // Add entity in physic world
+    void addEntity(Entity *newcomer);
+
+    // Delete every entity, be careful with your pointers !!!
+    void clearEveryEntity();
+
+    // Update every entity and make a cleanup : be careful with pointers !
+    void updateAll();
+
+    // Detect visuals in desired area
+    void collectVisuals(std::vector<Visual*> &scope, b2Vec2 center, b2Vec2 diago);
+
+protected:
+    std::list<Entity*> m_entities; // Store every entity
+};
+
+
+#endif //TINYSHOOTER_TINYWORLD_H

Physics/Wall.cpp

@@ -0,0 +1,53 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#include "Wall.h"
+#include <cstdlib>
+
+Wall::Wall(b2Vec2 pos, b2World* physics, WallShape shape)
+: Entity(WALL, 0, physics){
+    
+    // Creation of physical body
+    b2BodyDef bodyDef;
+    bodyDef.type = b2_staticBody;
+    bodyDef.position = pos;
+    m_body = physics->CreateBody(&bodyDef);
+
+    // Creation of shape
+    b2PolygonShape boxShape;
+    switch (shape)
+    {
+        case TINY :
+            boxShape.SetAsBox(80.0f / DEFAULT_ZOOM, 80.0f / DEFAULT_ZOOM);
+            m_imgId = (unsigned int) (2 + rand() % 4);
+            break;
+        case HIGH :
+            boxShape.SetAsBox(80.0f / DEFAULT_ZOOM, 160.0f / DEFAULT_ZOOM);
+            m_imgId = (unsigned int) (6 + rand() % 4);
+            break;
+        case WIDE :
+            boxShape.SetAsBox(160.0f / DEFAULT_ZOOM, 80.0f / DEFAULT_ZOOM);
+            m_imgId = (unsigned int) (21 + rand() % 4);
+            break;
+        case BIG :
+            boxShape.SetAsBox(160.0f / DEFAULT_ZOOM, 160.0f / DEFAULT_ZOOM);
+            m_imgId = (unsigned int) (25 + rand() % 4);
+            break;
+    }
+
+    // Definition of fixture
+    b2FixtureDef fixtureDef;
+    fixtureDef.shape = &boxShape;
+    fixtureDef.friction = 1.0f;
+
+    // Creation of fixture
+    m_body->CreateFixture(&fixtureDef);
+
+    // Link this wall
+    establishPhysicalLink();
+}
+
+void Wall::update() {
+    // Nothing happens ... the wall can't move !
+}

Physics/Wall.h

@@ -0,0 +1,21 @@
+//
+// Created by jovian on 18/07/17.
+//
+
+#ifndef TINYSHOOTER_WALL_H
+#define TINYSHOOTER_WALL_H
+
+#include "Entity.h"
+
+enum WallShape {TINY, HIGH, WIDE, BIG};
+
+class Wall : public Entity {
+public :
+    Wall(b2Vec2 pos, b2World* physics, WallShape shape = TINY);
+
+    void update() override;
+
+};
+
+
+#endif //TINYSHOOTER_WALL_H

Physics/b2Angle.cpp

@@ -0,0 +1,18 @@
+//
+// Created by jovian on 31/07/17.
+//
+
+#include "b2Angle.h"
+
+
+float b2Angle(const b2Vec2 &u, const b2Vec2 &v) {
+    float rep(std::acos(b2Dot(u, v)));
+    if ( b2Cross(u, v) > 0.0f )
+        rep *= -1.0f;
+
+    return rep;
+}
+
+float b2Angle(const b2Vec2 &u) {
+    return b2Angle(u, b2Vec2(1.0f, 0.0f));
+}

Physics/b2Angle.h

@@ -0,0 +1,25 @@
+//
+// Created by jovian on 31/07/17.
+//
+
+#ifndef TINYSHOOTER_B2ANGLE_H
+#define TINYSHOOTER_B2ANGLE_H
+
+#include <Box2D/Box2D.h>
+
+/**
+ * Give angle between u and v
+ * @param u : First vector
+ * @param v : Second vector
+ * @return Float angle in radians
+ */
+float b2Angle(const b2Vec2 &u, const b2Vec2 &v);
+
+/**
+ * Give angle between u and horizon
+ * @param u : Vector
+ * @return Float angle in radians
+ */
+float b2Angle(const b2Vec2 &u);
+
+#endif //TINYSHOOTER_B2ANGLE_H

main.cpp

@@ -0,0 +1,28 @@
+// Includes
+#include <iostream>
+#include "GameCore.h"
+
+using namespace std;
+
+int main() {
+    // Start
+    cout << "TinyShooter starts." << endl;
+
+    // Random start
+    srand((unsigned int) time(0));
+
+    // Initialisation
+    GameCore tinyShooter;
+
+    if (!tinyShooter.initialize()){
+        cout << "TinyShooter has encountered a problem." << endl;
+        cout << "Ask Jovian to debug his program ..." << endl;
+        return 1;
+    }
+
+    // QuickGame
+    tinyShooter.startQuickGame();
+
+    // End
+    return 0;
+}

modules/FindBox2D.cmake

@@ -0,0 +1,30 @@
+# source: http://breathe.git.sourceforge.net
+#
+# Locate Box2D library
+# This module defines
+# BOX2D_LIBRARY, the name of the library to link against
+# BOX2D_FOUND, if false, do not try to link to Box2D
+# BOX2D_INCLUDE_DIR, where to find Box2D headers
+#
+# Created by Sven-Hendrik Haase. Based on the FindZLIB.cmake module.
+
+IF(BOX2D_INCLUDE_DIR)
+  # Already in cache, be silent
+  SET(BOX2D_FIND_QUIETLY TRUE)
+ENDIF(BOX2D_INCLUDE_DIR)
+
+FIND_PATH(BOX2D_INCLUDE_DIR Box2D/Box2D.h)
+
+SET(BOX2D_NAMES box2d Box2d BOX2D Box2D)
+FIND_LIBRARY(BOX2D_LIBRARY NAMES ${BOX2D_NAMES})
+MARK_AS_ADVANCED(BOX2D_LIBRARY BOX2D_INCLUDE_DIR)
+
+# Per-recommendation
+SET(BOX2D_INCLUDE_DIRS "${BOX2D_INCLUDE_DIR}")
+SET(BOX2D_LIBRARIES    "${BOX2D_LIBRARY}")
+
+# handle the QUIETLY and REQUIRED arguments and set BOX2D_FOUND to TRUE if
+# all listed variables are TRUE
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Box2D DEFAULT_MSG BOX2D_LIBRARY BOX2D_INCLUDE_DIR)

modules/FindSDL2.cmake

@@ -0,0 +1,173 @@
+
+# This module defines
+# SDL2_LIBRARY, the name of the library to link against
+# SDL2_FOUND, if false, do not try to link to SDL2
+# SDL2_INCLUDE_DIR, where to find SDL.h
+#
+# This module responds to the the flag:
+# SDL2_BUILDING_LIBRARY
+# If this is defined, then no SDL2main will be linked in because
+# only applications need main().
+# Otherwise, it is assumed you are building an application and this
+# module will attempt to locate and set the the proper link flags
+# as part of the returned SDL2_LIBRARY variable.
+#
+# Don't forget to include SDLmain.h and SDLmain.m your project for the
+# OS X framework based version. (Other versions link to -lSDL2main which
+# this module will try to find on your behalf.) Also for OS X, this
+# module will automatically add the -framework Cocoa on your behalf.
+#
+#
+# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your configuration
+# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
+# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
+# Set SDL2_LIBRARY_TEMP to point to your SDL2 library, and configure again.
+# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
+# as appropriate. These values are used to generate the final SDL2_LIBRARY
+# variable, but when these values are unset, SDL2_LIBRARY does not get created.
+#
+#
+# $SDL2DIR is an environment variable that would
+# correspond to the ./configure --prefix=$SDL2DIR
+# used in building SDL2.
+# l.e.galup  9-20-02
+#
+# Modified by Eric Wing.
+# Added code to assist with automated building by using environmental variables
+# and providing a more controlled/consistent search behavior.
+# Added new modifications to recognize OS X frameworks and
+# additional Unix paths (FreeBSD, etc).
+# Also corrected the header search path to follow "proper" SDL guidelines.
+# Added a search for SDL2main which is needed by some platforms.
+# Added a search for threads which is needed by some platforms.
+# Added needed compile switches for MinGW.
+#
+# On OSX, this will prefer the Framework version (if found) over others.
+# People will have to manually change the cache values of
+# SDL2_LIBRARY to override this selection or set the CMake environment
+# CMAKE_INCLUDE_PATH to modify the search paths.
+#
+# Note that the header path has changed from SDL2/SDL.h to just SDL.h
+# This needed to change because "proper" SDL convention
+# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
+# reasons because not all systems place things in SDL2/ (see FreeBSD).
+
+#=============================================================================
+# Copyright 2003-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# message("<FindSDL2.cmake>")
+
+SET(SDL2_SEARCH_PATHS
+	~/Library/Frameworks
+	/Library/Frameworks
+	/usr/local
+	/usr
+	/sw # Fink
+	/opt/local # DarwinPorts
+	/opt/csw # Blastwave
+	/opt
+	${SDL2_PATH}
+)
+
+FIND_PATH(SDL2_INCLUDE_DIR SDL.h
+	HINTS
+	$ENV{SDL2DIR}
+	PATH_SUFFIXES include/SDL2 include
+	PATHS ${SDL2_SEARCH_PATHS}
+)
+
+if(CMAKE_SIZEOF_VOID_P EQUAL 8) 
+	set(PATH_SUFFIXES lib64 lib/x64 lib)
+else() 
+	set(PATH_SUFFIXES lib/x86 lib)
+endif() 
+
+FIND_LIBRARY(SDL2_LIBRARY_TEMP
+	NAMES SDL2
+	HINTS
+	$ENV{SDL2DIR}
+	PATH_SUFFIXES ${PATH_SUFFIXES}
+	PATHS ${SDL2_SEARCH_PATHS}
+)
+
+IF(NOT SDL2_BUILDING_LIBRARY)
+	IF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
+		# Non-OS X framework versions expect you to also dynamically link to
+		# SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
+		# seem to provide SDL2main for compatibility even though they don't
+		# necessarily need it.
+		FIND_LIBRARY(SDL2MAIN_LIBRARY
+			NAMES SDL2main
+			HINTS
+			$ENV{SDL2DIR}
+			PATH_SUFFIXES ${PATH_SUFFIXES}
+			PATHS ${SDL2_SEARCH_PATHS}
+		)
+	ENDIF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
+ENDIF(NOT SDL2_BUILDING_LIBRARY)
+
+# SDL2 may require threads on your system.
+# The Apple build may not need an explicit flag because one of the
+# frameworks may already provide it.
+# But for non-OSX systems, I will use the CMake Threads package.
+IF(NOT APPLE)
+	FIND_PACKAGE(Threads)
+ENDIF(NOT APPLE)
+
+# MinGW needs an additional link flag, -mwindows
+# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -mwindows
+IF(MINGW)
+	SET(MINGW32_LIBRARY mingw32 "-mwindows" CACHE STRING "mwindows for MinGW")
+ENDIF(MINGW)
+
+IF(SDL2_LIBRARY_TEMP)
+	# For SDL2main
+	IF(NOT SDL2_BUILDING_LIBRARY)
+		IF(SDL2MAIN_LIBRARY)
+			SET(SDL2_LIBRARY_TEMP ${SDL2MAIN_LIBRARY} ${SDL2_LIBRARY_TEMP})
+		ENDIF(SDL2MAIN_LIBRARY)
+	ENDIF(NOT SDL2_BUILDING_LIBRARY)
+
+	# For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
+	# CMake doesn't display the -framework Cocoa string in the UI even
+	# though it actually is there if I modify a pre-used variable.
+	# I think it has something to do with the CACHE STRING.
+	# So I use a temporary variable until the end so I can set the
+	# "real" variable in one-shot.
+	IF(APPLE)
+		SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
+	ENDIF(APPLE)
+
+	# For threads, as mentioned Apple doesn't need this.
+	# In fact, there seems to be a problem if I used the Threads package
+	# and try using this line, so I'm just skipping it entirely for OS X.
+	IF(NOT APPLE)
+		SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
+	ENDIF(NOT APPLE)
+
+	# For MinGW library
+	IF(MINGW)
+		SET(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
+	ENDIF(MINGW)
+
+	# Set the final string here so the GUI reflects the final state.
+	SET(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL2 Library can be found")
+	# Set the temp variable to INTERNAL so it is not seen in the CMake GUI
+	SET(SDL2_LIBRARY_TEMP "${SDL2_LIBRARY_TEMP}" CACHE INTERNAL "")
+ENDIF(SDL2_LIBRARY_TEMP)
+
+# message("</FindSDL2.cmake>")
+
+INCLUDE(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2 REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR)

modules/FindSDL2_image.cmake

@@ -0,0 +1,100 @@
+# Locate SDL_image library
+#
+# This module defines:
+#
+# ::
+#
+#   SDL2_IMAGE_LIBRARIES, the name of the library to link against
+#   SDL2_IMAGE_INCLUDE_DIRS, where to find the headers
+#   SDL2_IMAGE_FOUND, if false, do not try to link against
+#   SDL2_IMAGE_VERSION_STRING - human-readable string containing the version of SDL_image
+#
+#
+#
+# For backward compatibility the following variables are also set:
+#
+# ::
+#
+#   SDLIMAGE_LIBRARY (same value as SDL2_IMAGE_LIBRARIES)
+#   SDLIMAGE_INCLUDE_DIR (same value as SDL2_IMAGE_INCLUDE_DIRS)
+#   SDLIMAGE_FOUND (same value as SDL2_IMAGE_FOUND)
+#
+#
+#
+# $SDLDIR is an environment variable that would correspond to the
+# ./configure --prefix=$SDLDIR used in building SDL.
+#
+# Created by Eric Wing.  This was influenced by the FindSDL.cmake
+# module, but with modifications to recognize OS X frameworks and
+# additional Unix paths (FreeBSD, etc).
+
+#=============================================================================
+# Copyright 2005-2009 Kitware, Inc.
+# Copyright 2012 Benjamin Eikel
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+find_path(SDL2_IMAGE_INCLUDE_DIR SDL_image.h
+        HINTS
+        ENV SDL2IMAGEDIR
+        ENV SDL2DIR
+        PATH_SUFFIXES SDL2
+        # path suffixes to search inside ENV{SDLDIR}
+        include/SDL2 include
+        PATHS ${SDL2_IMAGE_PATH}
+        )
+
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(VC_LIB_PATH_SUFFIX lib/x64)
+else()
+    set(VC_LIB_PATH_SUFFIX lib/x86)
+endif()
+
+find_library(SDL2_IMAGE_LIBRARY
+        NAMES SDL2_image
+        HINTS
+        ENV SDL2IMAGEDIR
+        ENV SDL2DIR
+        PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
+        PATHS ${SDL2_IMAGE_PATH}
+        )
+
+if(SDL2_IMAGE_INCLUDE_DIR AND EXISTS "${SDL2_IMAGE_INCLUDE_DIR}/SDL_image.h")
+    file(STRINGS "${SDL2_IMAGE_INCLUDE_DIR}/SDL_image.h" SDL2_IMAGE_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL_IMAGE_MAJOR_VERSION[ \t]+[0-9]+$")
+    file(STRINGS "${SDL2_IMAGE_INCLUDE_DIR}/SDL_image.h" SDL2_IMAGE_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL_IMAGE_MINOR_VERSION[ \t]+[0-9]+$")
+    file(STRINGS "${SDL2_IMAGE_INCLUDE_DIR}/SDL_image.h" SDL2_IMAGE_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL_IMAGE_PATCHLEVEL[ \t]+[0-9]+$")
+    string(REGEX REPLACE "^#define[ \t]+SDL_IMAGE_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_IMAGE_VERSION_MAJOR "${SDL2_IMAGE_VERSION_MAJOR_LINE}")
+    string(REGEX REPLACE "^#define[ \t]+SDL_IMAGE_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_IMAGE_VERSION_MINOR "${SDL2_IMAGE_VERSION_MINOR_LINE}")
+    string(REGEX REPLACE "^#define[ \t]+SDL_IMAGE_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_IMAGE_VERSION_PATCH "${SDL2_IMAGE_VERSION_PATCH_LINE}")
+    set(SDL2_IMAGE_VERSION_STRING ${SDL2_IMAGE_VERSION_MAJOR}.${SDL2_IMAGE_VERSION_MINOR}.${SDL2_IMAGE_VERSION_PATCH})
+    unset(SDL2_IMAGE_VERSION_MAJOR_LINE)
+    unset(SDL2_IMAGE_VERSION_MINOR_LINE)
+    unset(SDL2_IMAGE_VERSION_PATCH_LINE)
+    unset(SDL2_IMAGE_VERSION_MAJOR)
+    unset(SDL2_IMAGE_VERSION_MINOR)
+    unset(SDL2_IMAGE_VERSION_PATCH)
+endif()
+
+set(SDL2_IMAGE_LIBRARIES ${SDL2_IMAGE_LIBRARY})
+set(SDL2_IMAGE_INCLUDE_DIRS ${SDL2_IMAGE_INCLUDE_DIR})
+
+include(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2_image
+        REQUIRED_VARS SDL2_IMAGE_LIBRARIES SDL2_IMAGE_INCLUDE_DIRS
+        VERSION_VAR SDL2_IMAGE_VERSION_STRING)
+
+# for backward compatibility
+set(SDLIMAGE_LIBRARY ${SDL2_IMAGE_LIBRARIES})
+set(SDLIMAGE_INCLUDE_DIR ${SDL2_IMAGE_INCLUDE_DIRS})
+set(SDLIMAGE_FOUND ${SDL2_IMAGE_FOUND})
+
+mark_as_advanced(SDL2_IMAGE_LIBRARY SDL2_IMAGE_INCLUDE_DIR)