V0.1.0 - First working demo with cleaned up code

.gitignore

@@ -1,4 +1,5 @@
-
 build
 debug
 .cache
+.vscode
+bin

CMakeLists.txt

@@ -5,15 +5,9 @@ cmake_minimum_required(VERSION 3.16)
 project(
   "Wiresmash"
   VERSION
-  1.0
+  0.1
   LANGUAGES
   CXX
 )
 
-file(GLOB_RECURSE SRC_FILES src/*.cpp)
-add_executable(app ${SRC_FILES})
-target_include_directories(app PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
-find_package(SFML 2 REQUIRED network audio graphics window system) 
-target_include_directories(app PUBLIC ${SFML_INCLUDE_DIR}) 
-target_link_libraries(app sfml-graphics)
-
+add_subdirectory(src)

README.md

@@ -1 +1,48 @@
-IniInitt
+# Wiresmash
+
+Wiresmash is a Smash-like game currently under development by the iScsc dev team.
+
+## Currently
+
+The game is currently a very simple demo containing:
+
+- simple physics system: gravity, collisions
+- simple graphic system: shapes using SFML
+- simple box system: only rectangles, used only for collisions so far
+- simple input system, with keybindings read from a file
+
+It consists of two red squares and a blue platform. The squares are controllable using (by default) the keys WASD/IJKL for up/left/down/right and Space/M for "jump".
+
+## Next Step
+
+- A simple combat prototype
+- Better jump system
+- Real kinematics system with management of velocity, more forces, ...
+
+## Launching
+
+Make sure to launch the executable from the `./bin` folder, or it will not find the keybinds and scream an error.
+
+## Build
+
+### Requirements
+
+- a `C++` compiler of your choice
+- `CMake`
+- `SFML`
+
+### Building with CMake
+
+Clone the project using `git`, then run the following commands:
+
+```bash
+cmake -S ./ -B ./build/
+```
+
+to generate a build system, then run:
+
+```bash
+cmake --build ./build/
+```
+
+to build the executable. You will find the build executable in the `./bin` folder.

include/engine/box/box.h

@@ -0,0 +1,101 @@
+/**
+ * @file box.h
+ * @author Grégory Brivady
+ * @brief Box template class definition
+ * @version 0.1.0
+ * @date 2022-08-25
+ * 
+ */
+#ifndef ENGINE_BOX_BOX_H
+#define ENGINE_BOX_BOX_H
+
+#include <cmath>
+#include <vector>
+// #include "engine/entity.h"
+typedef std::pair<double, double> point;
+
+// class Entity;
+
+/**
+ * @brief Container for all the information about an intersection of two boxes.
+ * 
+ * @tparam T behaviour of the boxes
+ */
+template <typename T>
+struct Intersection
+{
+    T* intersecting;
+    T* intersected ;
+    std::pair<double, double> intersectionVector = std::make_pair(0, 0); //Vector start from intersecting, towards intersected
+    Intersection() = default;
+};
+
+/**
+ * @brief Boxes are defined solely as geometrical objects. Their only purpose
+ * is to check if they intersect with other box-objects of the same type. By
+ * using the template parameter, one can specify the behaviour of such a box when it
+ * intersects with another box-object.
+ * 
+ * @tparam T behaviour of the box
+ */
+template <typename T>
+class Box
+{
+    friend T;
+
+public:
+
+    Box() = default;
+    ~Box() = default;
+
+    point* getPos() {return pos;};
+    std::vector<point> getVertices() {return relVertices;};
+    T* getOwner() {return owner;};
+
+    /**
+     * @brief Check if this box and another one intersects.
+     * 
+     * @param b 
+     * @return an @see Intersection<T>  object
+     */
+    virtual Intersection<T> checkIntersection(Box<T>* b) = 0;
+
+protected:
+    /**
+     * @brief direct link to owner's position
+     * 
+     */
+    std::pair<double, double>* pos;
+
+    /**
+     * @brief the behaviour who owns the box
+     * 
+     */
+    T* owner;
+
+   /**
+    * @brief Position of the vertices, relative to the box frame of reference.
+    * Vertices must be given in trigonometric order.
+   */
+    std::vector<point> relVertices;
+
+private:
+
+    /**
+     * @brief link the position of this box to the one of its owner.
+     * 
+     * @param pos 
+     */
+    void linkPos(std::pair<double, double>* pos);
+
+    /**
+     * @brief link the box to its owner.
+     * 
+     * @param t 
+     */
+    void linkOwner(T* t);
+};
+
+#include "../src/engine/box/box.tpp" //TODO : find a better way to include this
+
+#endif

include/engine/box/rectangle.h

@@ -0,0 +1,59 @@
+/**
+ * @file rectangle.h
+ * @author Grégory Brivady
+ * @brief A rectangle
+ * @version 0.1
+ * @date 2022-12-03
+ * 
+ */
+#ifndef ENGINE_BOX_RECTANGLE_H
+#define ENGINE_BOX_RECTANGLE_H
+
+#include <iostream>
+#include <algorithm>
+
+#include "engine/box/box.h"
+
+/**
+ * @brief A rectangle, defined by 4 vertices, starting from bottom-left, and then
+ * progressing in trigonometric order.
+ * @see Box<T>
+ * 
+ * @tparam T Behaviour of the rectangle-box
+ */
+template <typename T>
+class Rectangle: public Box<T>
+{
+public:
+
+    /**
+     * @brief Construct a new Rectangle object by using only its length
+     * and its height.
+     * 
+     * @param x Length of the rectangle on the x (horizontal) axis
+     * @param y Height of the rectangle on the y (vertical) axis
+     */
+    Rectangle(double x, double y);
+
+    /**
+     * @brief Construct a new Rectangle object by specifying all 4 points of the rectangle.
+     * 
+     * @details If x1 < x2 and y1 < y2, its bottom-left corner and top-right corner will be:
+     * (x1, y1) and (x2, y2).
+     * 
+     * 
+     * @param x1 
+     * @param y1 
+     * @param x2 
+     * @param y2 
+     */
+    Rectangle(double x1, double y1, double x2, double y2);
+
+    Intersection<T> checkIntersection(Rectangle<T>* ); //implemented by this class
+    //TODO : HORRIBLE
+    Intersection<T> checkIntersection(Box<T>* h) {return dynamic_cast<Rectangle<T>*>(h)->checkIntersection(this); }; //let the other class handle the collision
+};
+
+#include "../src/engine/box/rectangle.tpp" //Todo : same as box.tpp todo
+
+#endif