fix exec path

.gitignore

@@ -17,3 +17,8 @@ doc/mockups/*
 data/pieces/*.bin
 data/config/*.bin
 data/config/keybinds/*.bin
+
+# flatpak files
+flatpak/.flatpak-builder
+flatpak/builddir
+flatpak/repo

flatpak/FlatpakLaunch.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+JMINOS_DATA="/app/share" JMINOS_CONFIG=$XDG_CONFIG_HOME /app/bin/graph

flatpak/org.zulianc.jminos.desktop

@@ -0,0 +1,9 @@
+[Desktop Entry]
+Type=Application
+Version=1.0
+Name=Jminos
+Exec=/usr/bin/graph
+Icon=org.zulianc.jminos
+Terminal=false
+Categories=Game;
+Comment=Amazing stacker game by the J

flatpak/org.zulianc.jminos.metainfo.xml

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component type="desktop-application">
+  <id>org.zulianc.jminos</id>
+  <launchable type="desktop-id">org.zulianc.jminos.desktop</launchable>
+  <name>jminos</name>
+  <developer_name>Zulianc</developer_name>
+  <summary>Amazing stacker game by the J </summary>
+  <!-- <metadata_license>CC0-1.0</metadata_license>
+  <project_license>GPL-3.0-only</project_license> -->
+  <url type="homepage">https://git.ale-pri.com/TetrisNerd/jminos</url>
+  <description>
+    <p>
+      Modern stacker game with every polyominoes from size 1 to 15, made in C++ with SFML 3!
+    </p>
+    <p>Features</p>
+    <ul>
+      <li>Every polyominoes up to pentedecaminoes!</li>
+      <li>7bag with proportionnality for each polyomino size!</li>
+      <li>AutoRS as the Rotation System!</li>
+      <li>0° rotations!</li>
+      <li>All spin!</li>
+      <li>IRS, IHS, infinite hold, and other leniency mechanics!</li>
+      <li>Customizable board size!</li>
+      <li>Customizable keybinds!</li>
+      <li>Very bland interface!! (i'm not a designer)</li>
+    </ul>
+    <p>Available gamemodes</p>
+    <ul>
+      <li>SPRINT : clear 40 lines as fast as possible!</li>
+      <li>MARATHON : clear 200 lines with increasing gravity!</li>
+      <li>ULTRA : scores as much as possible in only 2 minutes!</li>
+      <li>MASTER : clear 200 lines at levels higher than maximum gravity!</li>
+      <li>INVISIBLE : get 1000 grade while not being able to see the board!</li>
+      <li>ZEN : practice indefinitely in this mode with no gravity!</li>
+    </ul>
+  </description>
+
+  <launchable type="desktop-id">
+    org.zulianc.jminos.desktop
+  </launchable>
+  <categories>
+    <category>Game</category>
+  </categories>
+  <screenshots>
+    <screenshot type="default">
+      <caption>Big piece</caption>
+      <image>https://git.ale-pri.com/TetrisNerd/jminos/raw/branch/main/doc/readme/big_piece.png</image>
+    </screenshot>
+    <screenshot>
+      <caption>Pieces selection</caption>
+      <image>https://git.ale-pri.com/TetrisNerd/jminos/media/branch/main/doc/readme/pieces_selection.png</image>
+    </screenshot>
+    <screenshot>
+      <caption>Rotations</caption>
+      <image>https://git.ale-pri.com/TetrisNerd/jminos/media/branch/main/doc/readme/rotations.gif</image>
+    </screenshot>
+    <screenshot>
+      <caption>Rotation_0</caption>
+      <image>https://git.ale-pri.com/TetrisNerd/jminos/media/branch/main/doc/readme/rotation_0.gif</image>
+    </screenshot>
+  </screenshots>
+  <releases>
+    <release version="1.0" date="2025-07-02">
+      <url>https://git.ale-pri.com/TetrisNerd/jminos/src/tag/v1.0/</url>
+      <description>
+        Inital release
+      </description>
+    </release>
+  </releases>
+  <content_rating type="oars-1.1" />
+</component>

flatpak/org.zulianc.jminos.yml

@@ -0,0 +1,31 @@
+app-id: org.zulianc.jminos
+runtime: org.freedesktop.Platform
+runtime-version: "24.08"
+sdk: org.freedesktop.Sdk
+command: FlatpakLaunch.sh
+
+finish-args:
+  - --socket=x11
+  - --device=dri
+
+modules:
+  - xmake.yml
+
+  - name: jminos
+    buildsystem: simple
+    build-options:
+      build-args:
+        - --share=network
+    build-commands:
+      - xmake f --policies=package.install_locally --external_build=y -m release -y
+      - xmake
+      - xmake install -o output
+      - install -D output/bin/* /app/bin
+      - cp -r output/data /app/share
+      - install -D flatpak/FlatpakLaunch.sh /app/bin
+      - install -D -t /app/share/applications flatpak/${FLATPAK_ID}.desktop
+      - install -Dm644 flatpak/${FLATPAK_ID}.metainfo.xml /app/share/metainfo/${FLATPAK_ID}.metainfo.xml
+      - install -D flatpak/${FLATPAK_ID}.png /app/share/icons/hicolor/512x512/apps/${FLATPAK_ID}.png
+    sources:
+      - type: dir
+        path: ..

flatpak/xmake.yml

@@ -0,0 +1,12 @@
+name: xmake
+buildsystem: simple
+no-autogen: true
+cleanup: ['*']
+build-commands:
+  - ./configure --prefix=/app
+  - make -j $(FLATPAK_BUILDER_N_JOBS)
+  - prefix=/app ./scripts/get.sh __local__ __install_only__ 
+sources:
+  - type: git
+    url: https://github.com/xmake-io/xmake.git
+    tag: v3.0.1

src/Core/Bag.cpp

@@ -35,7 +35,7 @@ Bag::Bag(const std::shared_ptr<PiecesList>& piecesList) :
         }
 
         for (const auto& piece : this->selectedPieces) {
-            int pieceSize = this->piecesList->lookAtPiece(piece).getPositions().getSize();
+            int pieceSize = this->piecesList->lookAtPiece(piece).getPositions().size();
             this->currentBags.at(pieceSize).push_back(piece);
         }
     }

src/Core/Board.cpp

@@ -20,10 +20,10 @@ Board::Board(int width, int height) :
 }
 
 void Board::changeBlock(const Position& position, Block block) {
-    if (position.x < 0 || static_cast<unsigned>(position.x) >= this->width || position.y < 0) return;
+    if (position.x < 0 || position.x >= this->width || position.y < 0) return;
 
     // resize the grid if needed
-    if (static_cast<unsigned>(position.y) >= this->grid.size()) {
+    if (position.y >= this->grid.size()) {
         for (int j = this->grid.size(); j <= position.y; j++) {
             this->grid.push_back(this->emptyRow);
         }
@@ -34,7 +34,7 @@ void Board::changeBlock(const Position& position, Block block) {
 
 void Board::insertRow(int height, int holePosition, Block blockType) {
     std::vector<Block> insertedRow;
-    for (unsigned i = 0; i < this->width; i++) {
+    for (int i = 0; i < this->width; i++) {
         if (i == holePosition) {
             insertedRow.push_back(NOTHING);
         }
@@ -51,7 +51,7 @@ int Board::clearRows() {
     int clearedLines = 0;
     for (int j = this->grid.size() - 1; j >= 0; j--) {
         bool lineIsFull = true;
-        unsigned i = 0;
+        int i = 0;
         while (lineIsFull && (i < width)) {
             if (this->grid.at(j).at(i) == NOTHING) {
                 lineIsFull = false;

src/Core/Board.h

@@ -13,8 +13,8 @@ class Board {
     private:
         std::vector<std::vector<Block>> grid; // the grid, (0,0) is downleft
         std::vector<Block> emptyRow;          // an empty row of blocks
-        unsigned width;                            // the width of the grid
-        unsigned height;                           // the base height of the grid, which can extend indefinitely
+        int width;                            // the width of the grid
+        int height;                           // the base height of the grid, which can extend indefinitely
 
     public:
         /**

src/Core/GameBoard.cpp

@@ -44,7 +44,7 @@ void GameBoard::initialize() {
 bool GameBoard::moveLeft() {
     this->movedLeftLast = true;
 
-    if (this->activePieceInWall(Position(-1, 0))) {
+    if (this->activePieceInWall(Position{-1, 0})) {
         return false;
     }
     else {
@@ -57,7 +57,7 @@ bool GameBoard::moveLeft() {
 bool GameBoard::moveRight() {
     this->movedLeftLast = false;
 
-    if (this->activePieceInWall(Position(1, 0))) {
+    if (this->activePieceInWall(Position{1, 0})) {
         return false;
     }
     else {
@@ -68,7 +68,7 @@ bool GameBoard::moveRight() {
 }
 
 bool GameBoard::moveDown() {
-    if (this->activePieceInWall(Position(0, -1))) {
+    if (this->activePieceInWall(Position{0, -1})) {
         return false;
     }
     else {
@@ -100,10 +100,10 @@ bool GameBoard::rotate(Rotation rotation) {
     for (Position position : stored.getPositions()) {
         Position positionInGrid(position + this->activePiecePosition);
         safePositions.insert(positionInGrid);
-        safePositions.insert(positionInGrid + Position(0, 1));
-        safePositions.insert(positionInGrid + Position(1, 0));
-        safePositions.insert(positionInGrid + Position(0, -1));
-        safePositions.insert(positionInGrid + Position(-1, 0));
+        safePositions.insert(positionInGrid + Position{0, 1});
+        safePositions.insert(positionInGrid + Position{1, 0});
+        safePositions.insert(positionInGrid + Position{0, -1});
+        safePositions.insert(positionInGrid + Position{-1, 0});
     }
 
     // first try kicking the piece down
@@ -147,18 +147,18 @@ bool GameBoard::tryKicking(bool testingBottom, const std::set<Position>& safePos
             // we first check the side to which the player moved last
             if (movedLeftLast) {
                 if (overlapsLeft) {
-                    if (this->tryFittingKickedPiece(safePositions, Position(-i, j), overlapsLeft)) return true;
+                    if (this->tryFittingKickedPiece(safePositions, Position({-i, j}), overlapsLeft)) return true;
                 }
                 if (overlapsRight) {
-                    if (this->tryFittingKickedPiece(safePositions, Position(+i, j), overlapsRight)) return true;
+                    if (this->tryFittingKickedPiece(safePositions, Position({+i, j}), overlapsRight)) return true;
                 }
             }
             else {
                 if (overlapsRight) {
-                    if (this->tryFittingKickedPiece(safePositions, Position(+i, j), overlapsRight)) return true;
+                    if (this->tryFittingKickedPiece(safePositions, Position({+i, j}), overlapsRight)) return true;
                 }
                 if (overlapsLeft) {
-                    if (this->tryFittingKickedPiece(safePositions, Position(-i, j), overlapsLeft)) return true;
+                    if (this->tryFittingKickedPiece(safePositions, Position({-i, j}), overlapsLeft)) return true;
                 }
             }
 
@@ -265,11 +265,11 @@ bool GameBoard::activePieceInWall(const Position& shift) const {
 }
 
 bool GameBoard::touchesGround() const {
-    return this->activePieceInWall(Position(0, -1));
+    return this->activePieceInWall(Position{0, -1});
 }
 
 Position GameBoard::lowestPosition() const {
-    Position shift = Position(0, -1);
+    Position shift = Position{0, -1};
     while (!activePieceInWall(shift)) {
         shift.y -= 1;
     }
@@ -278,8 +278,8 @@ Position GameBoard::lowestPosition() const {
 }
 
 LineClear GameBoard::lockPiece() {
-    bool isLockedInPlace = (this->activePieceInWall(Position(0, 1)) && this->activePieceInWall(Position(1, 0))
-        && this->activePieceInWall(Position(-1, 0)) && this->activePieceInWall(Position(0, -1)));
+    bool isLockedInPlace = (this->activePieceInWall(Position{0, 1}) && this->activePieceInWall(Position{1, 0})
+        && this->activePieceInWall(Position{-1, 0}) && this->activePieceInWall(Position{0, -1}));
 
     for (Position position : this->activePiece->getPositions()) {
         this->board.changeBlock(position + this->activePiecePosition, this->activePiece->getBlockType());
@@ -345,7 +345,7 @@ std::ostream& operator<<(std::ostream& os, const GameBoard& gameboard) {
         // print only the position were the active piece is
         for (int y = gameboard.activePiecePosition.y + gameboard.activePiece->getLength() - 1; y >= gameboard.board.getBaseHeight(); y--) {
             for (int x = 0; x < gameboard.board.getWidth(); x++) {
-                bool hasActivePiece = gameboard.activePiece->containsSquare(Position(x, y) - gameboard.activePiecePosition);
+                bool hasActivePiece = gameboard.activePiece->getPositions().contains(Position{x, y} - gameboard.activePiecePosition);
                 if (hasActivePiece) {
                     os << "*";
                 }
@@ -361,7 +361,7 @@ std::ostream& operator<<(std::ostream& os, const GameBoard& gameboard) {
     Block pieceBlockType = (gameboard.activePiece == nullptr) ? NOTHING : gameboard.activePiece->getBlockType();
     for (int y = gameboard.board.getBaseHeight() - 1; y >= 0; y--) {
         for (int x = 0; x < gameboard.board.getWidth(); x++) {
-            bool hasActivePiece = (gameboard.activePiece == nullptr) ? false : gameboard.activePiece->containsSquare(Position(x, y) - gameboard.activePiecePosition);
+            bool hasActivePiece = (gameboard.activePiece == nullptr) ? false : gameboard.activePiece->getPositions().contains(Position{x, y} - gameboard.activePiecePosition);
 
             // the active piece takes visual priority over the board
             if (hasActivePiece) {
@@ -369,7 +369,7 @@ std::ostream& operator<<(std::ostream& os, const GameBoard& gameboard) {
                 os << "*";
             }
             else {
-                Block block = gameboard.board.getBlock(Position(x, y));
+                Block block = gameboard.board.getBlock(Position{x, y});
                 os << getConsoleColorCode(block);
                 if (block != NOTHING) {
                     os << "*";

src/Core/GameBoard.h

@@ -84,7 +84,7 @@ class GameBoard {
          * Check if one of the active piece's positions shifted by a specified position would overlap with a set of positions
          * @return If the shifted active piece overlaps with one of the position
          */
-        bool activePieceOverlaps(const std::set<Position>& safePositions, const Position& shift = Position(0, 0)) const;
+        bool activePieceOverlaps(const std::set<Position>& safePositions, const Position& shift = Position{0, 0}) const;
 
     public:
         /**
@@ -103,7 +103,7 @@ class GameBoard {
          * Checks if one of the active piece's positions touches a wall in the board
          * @return If the active piece is in a wall
          */
-        bool activePieceInWall(const Position& shift = Position(0, 0)) const;
+        bool activePieceInWall(const Position& shift = Position{0, 0}) const;
 
         /**
          * Checks is the active piece as a wall directly below one of its position

src/Core/PiecesList.cpp

@@ -27,12 +27,12 @@ PiecesList::PiecesList() {
     this->pushBackEmptyVectors();
 }
 
-bool PiecesList::loadPieces(unsigned max_size) {
+bool PiecesList::loadPieces(int max_size) {
     if (max_size < 1) return false;
     if (max_size <= this->highestLoadedSize) return true;
 
     PiecesFiles piecesFiles;
-    for (unsigned i = this->highestLoadedSize + 1; i <= max_size; i++) {
+    for (int i = this->highestLoadedSize + 1; i <= max_size; i++) {
         if (!piecesFiles.loadPieces(i, this->loadedPieces.at(i), this->convexPieces.at(i), this->holelessPieces.at(i), this->otherPieces.at(i))) {
             return false;
         }
@@ -45,14 +45,14 @@ bool PiecesList::loadPieces(unsigned max_size) {
     return true;
 }
 
-bool PiecesList::selectPiece(unsigned size, unsigned number) {
+bool PiecesList::selectPiece(int size, int number) {
     if (size < 1 || size > this->highestLoadedSize || number >= this->loadedPieces.at(size).size()) return false;
 
     this->selectedPieces.push_back(std::pair<int, int>(size, number));
     return true;
 }
 
-bool PiecesList::selectAllPieces(unsigned size) {
+bool PiecesList::selectAllPieces(int size) {
     if (size < 1 || size > this->highestLoadedSize) return false;
 
     for (int i = 0; i < this->loadedPieces.at(size).size(); i++) {

src/Core/PiecesList.h

@@ -13,7 +13,7 @@
  */
 class PiecesList {
     private:
-        unsigned highestLoadedSize;                           // the highest size of pieces currently loaded
+        int highestLoadedSize;                           // the highest size of pieces currently loaded
         std::vector<std::vector<Piece>> loadedPieces;    // every loaded pieces by size
         std::vector<std::vector<int>> convexPieces;      // the list of convex loaded pieces by size
         std::vector<std::vector<int>> holelessPieces;    // the list of holeless loaded pieces by size
@@ -33,19 +33,19 @@ class PiecesList {
          * Makes the list load all pieces up to the specified size
          * @return If all pieces up to the specified size are correctly loaded
          */
-        [[nodiscard]] bool loadPieces(unsigned max_size);
+        [[nodiscard]] bool loadPieces(int max_size);
 
         /**
          * Selects the specified piece
          * @return If the piece could be selected
          */
-        bool selectPiece(unsigned size, unsigned number);
+        bool selectPiece(int size, int number);
 
         /**
          * Selects all pieces of the specified size
          * @return If the pieces could be selected
          */
-        bool selectAllPieces(unsigned size);
+        bool selectAllPieces(int size);
 
         /**
          * Selects all convex pieces of the specified size

src/GraphicalUI/AppMenus/AppMenu.cpp

@@ -15,9 +15,7 @@ AppMenu::AppMenu(std::shared_ptr<MenuStack> menuStack, std::shared_ptr<Settings>
 	settings(settings),
 	renderWindow(renderWindow) {
 
-	const Asset& file = getResource(AssetName::data_fonts_pressstart_prstartk_ttf);
-
-	this->pressStartFont = sf::Font(file.data, file.size);
+	this->pressStartFont = sf::Font(AssetManager::getResourcePath("data/fonts/pressstart/prstart.ttf"));
 }
 
 void AppMenu::updateMetaBinds() {

src/GraphicalUI/AppMenus/GamePlayingAppMenu.cpp

@@ -117,7 +117,7 @@ void GamePlayingAppMenu::drawFrame() const {
     // board
     for (int y = this->game.getBoard().getBaseHeight() + 9; y >= 0; y--) {
         for (int x = 0; x < this->game.getBoard().getWidth(); x++) {
-            Block block = this->game.getBoard().getBlock(Position(x, y));
+            Block block = this->game.getBoard().getBlock(Position{x, y});
             if (isBoardInvisible) block = NOTHING;
 
             sf::RectangleShape cell(cellSize);
@@ -196,7 +196,7 @@ void GamePlayingAppMenu::drawFrame() const {
         for (int y = 0; y < this->game.getNextPieces().at(i).getLength(); y++) {
             for (int x = 0; x < this->game.getNextPieces().at(i).getLength(); x++) {
                 sf::RectangleShape cell(nextCellSize);
-                if (this->game.getNextPieces().at(i).containsSquare(Position(x, y))) {
+                if (this->game.getNextPieces().at(i).getPositions().contains(Position{x, y})) {
                     cell.setFillColor(pieceColor);
                     lowestRank = y;
                 }
@@ -223,7 +223,7 @@ void GamePlayingAppMenu::drawFrame() const {
         for (int y = 0; y < this->game.getHeldPiece()->getLength(); y++) {
             for (int x = 0; x < this->game.getHeldPiece()->getLength(); x++) {
                 sf::RectangleShape cell(holdCellSize);
-                if (this->game.getHeldPiece()->containsSquare(Position(x, y))) {
+                if (this->game.getHeldPiece()->getPositions().contains(Position{x, y})) {
                     cell.setFillColor(color);
                 }
                 else {

src/GraphicalUI/AppMenus/SettingsKeybindsAppMenu.cpp

@@ -23,9 +23,7 @@ SettingsKeybindsAppMenu::SettingsKeybindsAppMenu(std::shared_ptr<MenuStack> menu
         std::string textureName = ACTION_NAMES[action];
         textureName = std::regex_replace(textureName, std::regex(" "), "");
 
-        const Asset& textureData = getResource("data/images/keybinds/" + textureName + ".png");
-
-        this->iconTextures[action] = sf::Texture(textureData.data, textureData.size, false, {{0, 0}, {16, 16}});
+        this->iconTextures[action] = sf::Texture(AssetManager::getResourcePath("data/images/keybinds/" + textureName + ".png"), false, {{0, 0}, {16, 16}});
     }
 }
 

src/GraphicalUI/Keybinds.cpp

@@ -6,6 +6,7 @@
 #include <set>
 #include <fstream>
 #include <SFML/Graphics.hpp>
+#include "../Utils/AssetManager.h"
 
 
 Keybinds::Keybinds(int layoutNumber) :
@@ -20,7 +21,7 @@ Keybinds::Keybinds(int layoutNumber) :
 }
 
 void Keybinds::loadKeybindsFromFile() {
-    std::ifstream layoutFile("data/config/keybinds/layout" + std::to_string(this->layoutNumber) + ".bin", std::ios::binary);
+    std::ifstream layoutFile(AssetManager::getConfigPath("data/config/keybinds/layout" + std::to_string(this->layoutNumber) + ".bin"), std::ios::binary);
 
     for (Action action : ACTION_LIST_IN_ORDER) {
         this->keybinds.at(action).clear();
@@ -47,7 +48,7 @@ void Keybinds::loadKeybindsFromFile() {
 void Keybinds::saveKeybindsToFile() const {
     if (!this->modifiable) return;
 
-    std::ofstream layoutFile("data/config/keybinds/layout" + std::to_string(this->layoutNumber) + ".bin", std::ios::trunc | std::ios::binary);
+    std::ofstream layoutFile(AssetManager::getConfigPath("data/config/keybinds/layout" + std::to_string(this->layoutNumber) + ".bin"), std::ios::trunc | std::ios::binary);
 
     char byte;
     for (Action action : ACTION_LIST_IN_ORDER) {

src/GraphicalUI/Settings.cpp

@@ -3,6 +3,7 @@
 #include "../Core/Menu.h"
 #include "Keybinds.h"
 #include "PiecesType.h"
+#include "../Utils/AssetManager.h"
 
 #include <vector>
 #include <optional>
@@ -49,7 +50,7 @@ void Settings::loadPieces(int loadablePiecesSizeRequest) {
 }
 
 void Settings::loadSettingsFromFile(bool loadPieces, std::optional<int> loadablePiecesSizeRequest) {
-    std::ifstream settingsFile("data/config/settings.bin", std::ios::binary);
+    std::ifstream settingsFile(AssetManager::getConfigPath("data/config/settings.bin"), std::ios::binary);
     char byte;
 
     // file format version
@@ -158,7 +159,7 @@ void Settings::saveSettingsToFile() const {
 
     this->keybinds.at(CUSTOMIZABLE_KEYBINDS).saveKeybindsToFile();
 
-    std::ofstream settingsFile("data/config/settings.bin", std::ios::trunc | std::ios::binary);
+    std::ofstream settingsFile(AssetManager::getConfigPath("data/config/settings.bin"), std::ios::trunc | std::ios::binary);
     char byte;
 
     // file format version

src/GraphicalUI/main.cpp

@@ -4,11 +4,13 @@
 #include <filesystem>
 #include <fstream>
 
+#include "../Utils/AssetManager.h"
+
 [[nodiscard]] bool resetSettingsFile();
 [[nodiscard]] bool resetKeybindFile(int layout);
 
 
-int main() {
+int main(int arc, char** args) {
     std::srand(std::time(NULL));
 
     bool everythingIsOK = true;
@@ -18,7 +20,7 @@ int main() {
     PiecesFiles pf;
     bool warned = false;
     for (int i = 1; i <= MAXIMUM_PIECES_SIZE; i++) {
-        if (!std::filesystem::exists("data/pieces/" + std::to_string(i) + "minos.bin")) {
+        if (!std::filesystem::exists(AssetManager::getResourcePath("data/pieces/" + std::to_string(i) + "minos.bin"))) {
             #ifndef DEBUG
                 if (!warned && i > DEBUG_PIECES_SIZE) {
                     std::cout << "IMPORTANT: You are currently in release mode, if you do not wish to generate big pieces (can take several minutes), type 'xmake f -m debug'." << std::endl;
@@ -36,7 +38,7 @@ int main() {
     
         bool releasePiecesGenerated = true;
         for (int i = DEBUG_PIECES_SIZE + 1; i <= RELEASE_PIECES_SIZE; i++) {
-            if (!std::filesystem::exists("data/pieces/" + std::to_string(i) + "minos.bin")) {
+            if (!std::filesystem::exists(AssetManager::getResourcePath("data/pieces/" + std::to_string(i) + "minos.bin"))) {
                 releasePiecesGenerated = false;
             }
         }
@@ -47,29 +49,29 @@ int main() {
 
     bool everythingGenerated = true;
     for (int i = 1; i <= MAXIMUM_PIECES_SIZE; i++) {
-        std::string filePath = "data/pieces/" + std::to_string(i) + "minos.bin";
+        auto filePath = AssetManager::getResourcePath("data/pieces/" + std::to_string(i) + "minos.bin");
 
         if (!std::filesystem::exists(filePath)) {
-            std::cout << "ERROR: Could not open file " + filePath << std::endl;
+            std::cout << "ERROR: Could not open file " << filePath << std::endl;
             everythingIsOK &= false;
         }
     }
 
     // CHECK CONFIG FILES
 
-    if (!std::filesystem::exists("data/config/settings.bin")) {
+    if (!std::filesystem::exists(AssetManager::getConfigPath("data/config/settings.bin"))) {
         std::cout << "INFO: Settings file not found, generating..." << std::endl;
         everythingIsOK &= resetSettingsFile();
 
         for (int i = 0; i < NUMBER_OF_KEYBINDS; i++) {
-            if (!std::filesystem::exists("data/config/keybinds/layout" + std::to_string(i) + ".bin")) {
+            if (!std::filesystem::exists(AssetManager::getConfigPath("data/config/keybinds/layout" + std::to_string(i) + ".bin"))) {
                 std::cout << "INFO: Keybind file number " << (i + 1) << "/" << NUMBER_OF_KEYBINDS << " not found, generating..." << std::endl;
                 everythingIsOK &= resetKeybindFile(i);
             }
         }
     }
     else {
-        std::ifstream settingsFile("data/config/settings.bin", std::ios::binary);
+        std::ifstream settingsFile(AssetManager::getConfigPath("data/config/settings.bin"), std::ios::binary);
         char byte;
 
         settingsFile.get(byte);
@@ -99,14 +101,14 @@ int main() {
 
 
 bool resetSettingsFile() {
-    if (!std::filesystem::exists("data/config")) {
-        std::filesystem::create_directories("data/config");
+    if (!std::filesystem::exists(AssetManager::getConfigPath("data/config"))) {
+        std::filesystem::create_directories(AssetManager::getConfigPath("data/config"));
     }
     
-    std::string filePath ="data/config/settings.bin";
+    auto filePath = AssetManager::getConfigPath("data/config/settings.bin");
     std::ofstream settingsFile(filePath, std::ios::trunc | std::ios::binary);
     if (!settingsFile.good()) {
-        std::cerr << "ERROR: Could not open file " + filePath << std::endl;
+        std::cerr << "ERROR: Could not open file " << filePath << std::endl;
         return false;
     }
 
@@ -180,14 +182,14 @@ bool resetKeybindFile(int layout) {
         return false;
     }
 
-    if (!std::filesystem::exists("data/config/keybinds")) {
-        std::filesystem::create_directories("data/config/keybinds");
+    if (!std::filesystem::exists(AssetManager::getConfigPath("data/config/keybinds"))) {
+        std::filesystem::create_directories(AssetManager::getConfigPath("data/config/keybinds"));
     }
 
-    std::string filePath = "data/config/keybinds/layout" + std::to_string(layout) + ".bin";
+    auto filePath = AssetManager::getConfigPath("data/config/keybinds/layout" + std::to_string(layout) + ".bin");
     std::ofstream layoutFile(filePath, std::ios::trunc | std::ios::binary);
     if (!layoutFile.good()) {
-        std::cerr << "ERROR: Could not open file " + filePath << std::endl;
+        std::cerr << "ERROR: Could not open file " << filePath << std::endl;
         return false;
     }
 

src/Pieces/Generator.cpp

@@ -11,25 +11,25 @@
 Generator::Generator() {
 }
 
-std::vector<Polyomino>&& Generator::generatePolyominoes(int polyominoSize) {
+std::vector<Polyomino> Generator::generatePolyominoes(int polyominoSize) {
     this->validPolyominoes.clear();
     this->currentTestedShape.clear();
 
     // a polyomino has at least 1 square
-    if (polyominoSize < 1) return std::move(this->validPolyominoes);
+    if (polyominoSize < 1) return this->validPolyominoes;
 
     // always place the first cell at (0, 0)
-    this->currentTestedShape.insert(Position(0, 0));
+    this->currentTestedShape.insert(Position{0, 0});
     
     std::map<Position, int> candidatePositions;
     this->generate(polyominoSize, 0, 1, candidatePositions);
-    return std::move(this->validPolyominoes);
+    return this->validPolyominoes;
 }
 
-void Generator::generate(unsigned polyominoSize, int lastAddedPositionNumber, int nextAvaibleNumber, std::map<Position, int> candidatePositions) {
+void Generator::generate(int polyominoSize, int lastAddedPositionNumber, int nextAvaibleNumber, std::map<Position, int> candidatePositions) {
     // recursion stop
     if (polyominoSize == this->currentTestedShape.size()) {
-        Polyomino candidate(std::move(this->currentTestedShape));
+        Polyomino candidate(this->currentTestedShape);
 
         // we sort the rotations of the polyominoes
         std::vector<Polyomino> candidateRotations;
@@ -51,14 +51,14 @@ void Generator::generate(unsigned polyominoSize, int lastAddedPositionNumber, in
 
     // generate the list of candidate positions
     for (const Position position : this->currentTestedShape) {
-        this->tryToAddCandidatePosition(Position(position.x, position.y + 1), nextAvaibleNumber, candidatePositions);
-        this->tryToAddCandidatePosition(Position(position.x + 1, position.y), nextAvaibleNumber, candidatePositions);
-        this->tryToAddCandidatePosition(Position(position.x, position.y - 1), nextAvaibleNumber, candidatePositions);
-        this->tryToAddCandidatePosition(Position(position.x - 1, position.y), nextAvaibleNumber, candidatePositions);
+        this->tryToAddCandidatePosition(Position{position.x, position.y + 1}, nextAvaibleNumber, candidatePositions);
+        this->tryToAddCandidatePosition(Position{position.x + 1, position.y}, nextAvaibleNumber, candidatePositions);
+        this->tryToAddCandidatePosition(Position{position.x, position.y - 1}, nextAvaibleNumber, candidatePositions);
+        this->tryToAddCandidatePosition(Position{position.x - 1, position.y}, nextAvaibleNumber, candidatePositions);
     }
     
     // try adding a square only to positions with a higher number than the last one
-    for (const auto& [key, val] : candidatePositions) {
+    for (const auto [key, val] : candidatePositions) {
         if (val > lastAddedPositionNumber) {
             this->currentTestedShape.insert(key);
             this->generate(polyominoSize, val, nextAvaibleNumber, (polyominoSize == this->currentTestedShape.size()) ? std::map<Position, int>() : candidatePositions);

src/Pieces/Generator.h

@@ -25,13 +25,13 @@ class Generator {
          * Generates the list of all one-sided polyominoes of the specified size
          * @return The list of polyominoes
          */
-        std::vector<Polyomino>&& generatePolyominoes(int polyominoSize);
+        std::vector<Polyomino> generatePolyominoes(int polyominoSize);
 
     private:
         /**
          * Generates all one-sided polyominoes of the specified size using the current tested shape
          */
-        void generate(unsigned polyominoSize, int lastAddedPositionNumber, int nextAvaibleNumber, std::map<Position, int> candidatePositions);
+        void generate(int polyominoSize, int lastAddedPositionNumber, int nextAvaibleNumber, std::map<Position, int> candidatePositions);
 
         /**
          * Checks wheter a candidate position can be added to the current tested shape

src/Pieces/Piece.cpp

@@ -9,10 +9,11 @@
 #include <string>
 
 
-Piece::Piece(Polyomino&& polyomino, Block blockType) :
+Piece::Piece(const Polyomino& polyomino, Block blockType) :
     polyomino(polyomino),
-    blockType(blockType),
-    rotationState(NONE) {
+    blockType(blockType) {
+
+    this->rotationState = NONE;
 }
 
 void Piece::rotate(Rotation rotation) {
@@ -37,8 +38,8 @@ void Piece::defaultRotation() {
     this->rotationState = NONE;
 }
 
-const Polyomino& Piece::getPositions() const {
-    return this->polyomino;
+const std::set<Position>& Piece::getPositions() const {
+    return this->polyomino.getPositions();
 }
 
 int Piece::getLength() const {
@@ -53,7 +54,3 @@ std::ostream& operator<<(std::ostream& os, const Piece& piece) {
     os << getConsoleColorCode(piece.blockType) << piece.polyomino << getResetConsoleColorCode();
     return os;
 }
-
-bool Piece::containsSquare(const Position& position) const {
-    return polyomino.contains(position);
-}

src/Pieces/Piece.h

@@ -21,7 +21,7 @@ class Piece {
         /**
          * Creates a piece with a specified shape and block type
          */
-        Piece(Polyomino&& piece, Block blockType);
+        Piece(const Polyomino& piece, Block blockType);
 
         /**
          * Rotates the piece in the specified direction
@@ -36,13 +36,7 @@ class Piece {
         /**
          * @return The list of positions of the piece
          */
-        const Polyomino& getPositions() const;
-
-        /**
-         * @param the position of the square
-         * @return false if there is a hole
-         */
-        bool containsSquare(const Position& position) const;
+        const std::set<Position>& getPositions() const;
 
         /**
          * @return The length of the piece

src/Pieces/PiecesFiles.cpp

@@ -11,6 +11,7 @@
 #include <algorithm>
 
 #include "../Common/Compression.h"
+#include "../Utils/AssetManager.h"
 
 
 PiecesFiles::PiecesFiles() {
@@ -50,18 +51,11 @@ bool PiecesFiles::savePieces(int polyominoSize, std::vector<Polyomino>& polyomin
         std::uint8_t infoByte = (isConvex << 7) + (hasHole << 6) + polyomino.getLength();
         buffer << infoByte;
 
-        const int bitsNeeded = polyomino.getLength() * polyomino.getLength();
-        const int bytesNeeded = bitsNeeded / 8 + 1;
-
-        static const Polyomino::PolyominoData byteMask = 0xFF;
-        const Polyomino::PolyominoData& polyominoData = polyomino.getPositionsData();
-
         // write the positions of the piece
-        for (int i = 0; i < bytesNeeded; i++) {
-            Polyomino::PolyominoData pData = polyominoData >> (i * 8);
-            unsigned long data = 
-                (pData & byteMask).to_ulong();
-            buffer << static_cast<std::uint8_t>(data);
+        std::uint8_t positionByte;
+        for (const Position position : polyomino.getPositions()) {
+            positionByte = (position.x << 4) + position.y;
+            buffer << positionByte;
         }
     }
 
@@ -98,12 +92,13 @@ bool PiecesFiles::loadPieces(int polyominoSize, std::vector<Piece>& pieces, std:
         nextPieceBlockType(pieceBlock);
     }
 
-    constexpr char convexMask = 0b1000'0000;
-    constexpr char holeMask = 0b0100'0000;
-    constexpr char lengthMask = 0b0011'1111;
+    char convexMask = 0b1000'0000;
+    char holeMask = 0b0100'0000;
+    char lengthMask = 0b0011'1111;
+    char xMask = 0b1111'0000;
+    char yMask = 0b0000'1111;
 
     std::uint8_t infoByte;
-    std::uint8_t positionByte;
     int i = 0;
     while (!buffer.IsFinished()) {
         // if (piecesFile.eof()) break;
@@ -114,22 +109,21 @@ bool PiecesFiles::loadPieces(int polyominoSize, std::vector<Piece>& pieces, std:
         bool hasHole = (infoByte & holeMask) >> 6;
         int length = (infoByte & lengthMask);
 
-        const int bitsNeeded = length * length;
-        const int bytesNeeded = bitsNeeded / 8 + 1;
-
         // read positions
-        Polyomino::PolyominoData polyominoData{};
-
-        for (int j = 0; j < bytesNeeded; j++) {
+        std::set<Position> piecePositions;
+        std::uint8_t positionByte;
+        for (int i = 0; i < polyominoSize; i++) {
             buffer >> positionByte;
-            Polyomino::PolyominoData tempByte(positionByte);
-            polyominoData |= (tempByte << (j * 8));
+            int x = ((unsigned char) positionByte & xMask) >> 4;
+            int y = positionByte & yMask;
+            piecePositions.insert(Position{x, y});
         }
 
-        pieces.emplace_back(Polyomino(std::move(polyominoData), length), pieceBlock);
-
+        // create piece
+        Piece readPiece(Polyomino(piecePositions, length), pieceBlock);
         nextPieceBlockType(pieceBlock);
-
+        
+        pieces.push_back(readPiece);
         if (isConvex) {
             convexPieces.push_back(i);
         }
@@ -147,7 +141,7 @@ bool PiecesFiles::loadPieces(int polyominoSize, std::vector<Piece>& pieces, std:
 }
 
 bool PiecesFiles::getFilePath(int polyominoSize, std::string& filePath) const {
-    std::string dataFolderPath = "data/pieces/";
+    auto dataFolderPath = AssetManager::getResourcePath("data/pieces");
 
     if (!std::filesystem::exists(dataFolderPath)) {
         std::filesystem::create_directories(dataFolderPath);
@@ -157,6 +151,6 @@ bool PiecesFiles::getFilePath(int polyominoSize, std::string& filePath) const {
         return false;
     }
 
-    filePath = dataFolderPath + std::to_string(polyominoSize) + "minos.bin";
+    filePath = (dataFolderPath / (std::to_string(polyominoSize) + "minos.bin")).string();
     return true;
 }

src/Pieces/Polyomino.cpp

@@ -8,9 +8,9 @@
 #include <climits>
 #include <algorithm>
 #include <utility>
-#include <cassert>
 
-Polyomino::Polyomino(std::set<Position>&& positions) : positions(0) {
+
+Polyomino::Polyomino(const std::set<Position>& positions) {
     int minX = INT_MAX;
     int maxX = INT_MIN;
     int minY = INT_MAX;
@@ -25,64 +25,71 @@ Polyomino::Polyomino(std::set<Position>&& positions) : positions(0) {
     this->length = std::max(maxX - minX + 1, maxY - minY + 1);
 
     // we normalize here instead of calling this->normalize() to reduce the number of calculations for the generation algorithm
-    Polyomino newPolyomino({}, this->length);
+    std::set<Position> newPositions;
     for (Position position : positions) {
-        newPolyomino.insert(Position(position.x - minX, position.y - minY));
+        newPositions.insert(Position{position.x - minX, position.y - minY});
     }
-    this->positions = std::move(newPolyomino.positions);
+    this->positions = std::move(newPositions);
 }
 
-Polyomino::Polyomino(PolyominoData&& positions, std::int8_t length) :
-    positions(std::move(positions)),
+Polyomino::Polyomino(const std::set<Position>& positions, int length) :
+    positions(positions),
     length(length) {
 }
 
 void Polyomino::normalize() {
     int minX = INT_MAX;
     int minY = INT_MAX;
-    for (const Position position : *this) {
+    for (const Position position : this->positions) {
         if (position.x < minX) minX = position.x;
         if (position.y < minY) minY = position.y;
     }
 
-    Polyomino newPolyomino({}, this->length);
-    for (const Position position : *this) {
-        newPolyomino.insert(Position(position.x - minX, position.y - minY));
+    std::set<Position> newPositions;
+    for (const Position position : this->positions) {
+        newPositions.insert(Position{position.x - minX, position.y - minY});
     }
-    this->positions = std::move(newPolyomino.positions);
+    this->positions = std::move(newPositions);
 }
 
 void Polyomino::rotateCW() {
-    Polyomino temp({}, this->length);
-    for (const Position position : *this) {
-        temp.insert(Position(position.y, (length - 1) - (position.x)));
+    std::set<Position> newPositions;
+    for (const Position position : this->positions) {
+        newPositions.insert(Position{position.y, (length - 1) - (position.x)});
     }
-    this->positions = std::move(temp.positions);
+    this->positions = std::move(newPositions);
 }
 
 void Polyomino::rotate180() {
-    Polyomino temp({}, this->length);
-    for (const Position position : *this) {
-        temp.insert(Position((length - 1) - (position.x), (length - 1) - (position.y)));
+    std::set<Position> newPositions;
+    for (const Position position : this->positions) {
+        newPositions.insert(Position{(length - 1) - (position.x), (length - 1) - (position.y)});
     }
-    this->positions = std::move(temp.positions);
+    this->positions = std::move(newPositions);
 }
 
 void Polyomino::rotateCCW() {
-    Polyomino temp({}, this->length);
-    for (const Position position : *this) {
-        temp.insert(Position((length - 1) - (position.y), position.x));
+    std::set<Position> newPositions;
+    for (const Position position : this->positions) {
+        newPositions.insert(Position{(length - 1) - (position.y), position.x});
     }
-    this->positions = std::move(temp.positions);
+    this->positions = std::move(newPositions);
 }
 
 void Polyomino::goToSpawnPosition() {
     // initialize array
-    std::vector<int> empty(this->length, 0);
-    std::vector<std::vector<int>> linesCompleteness(4, empty);
+    std::vector<std::vector<int>> linesCompleteness;
+    linesCompleteness.reserve(4);
+    std::vector<int> empty;
+    for (int j = 0; j < this->length; j++) {
+        empty.push_back(0);
+    }
+    for (int i = 0; i < 4; i++) {
+        linesCompleteness.push_back(empty);
+    }
 
     // calculates amount of squares per rows and columns
-    for (const Position position : *this) {
+    for (const Position position : this->positions) {
         linesCompleteness.at(0).at(position.y) += 1;                // 0 = bottom to top = no rotation
         linesCompleteness.at(1).at((length - 1) - position.x) += 1; // 1 = right to left = CW
         linesCompleteness.at(2).at((length - 1) - position.y) += 1; // 2 = top to bottom = 180
@@ -148,21 +155,20 @@ void Polyomino::goToSpawnPosition() {
     if (sideToBeOn % 2 == 1) {
         std::swap(verticalEmptyLines, horizontalEmptyLines);
     }
-
     
     int minX = INT_MAX;
     int minY = INT_MAX;
-    for (const Position position : *this) {
+    for (const Position position : this->positions) {
         if (position.x < minX) minX = position.x;
         if (position.y < minY) minY = position.y;
     }
 
     // center the piece with an up bias
-    Polyomino temp({}, this->length);
-    for (const Position position : *this) {
-        temp.insert(Position((position.x - minX) + (verticalEmptyLines / 2), (position.y - minY) + ((horizontalEmptyLines + 1) / 2)));
+    std::set<Position> newPositions;
+    for (const Position position : positions) {
+        newPositions.insert(Position{(position.x - minX) + (verticalEmptyLines / 2), (position.y - minY) + ((horizontalEmptyLines + 1) / 2)});
     }
-    this->positions = std::move(temp.positions);
+    this->positions = std::move(newPositions);
 }
 
 void Polyomino::checkForFlattestSide(const std::vector<std::vector<int>>& linesCompleteness, bool currentFlattestSides[4], int& sideToBeOn, bool checkLeftSide) const {
@@ -210,7 +216,7 @@ bool Polyomino::isConvex() const {
         bool startedColumn = false;
         bool completedColumn = false;
         for (int i = 0; i < this->length; i++) {
-            if (this->contains(Position(i, j))) {
+            if (this->positions.contains(Position{i, j})) {
                 if (completedLine) return false;
                 else startedLine = true;
             }
@@ -218,7 +224,7 @@ bool Polyomino::isConvex() const {
                 if (startedLine) completedLine = true;
             }
 
-            if (this->contains(Position(j, i))) {
+            if (this->positions.contains(Position{j, i})) {
                 if (completedColumn) return false;
                 else startedColumn = true;
             }
@@ -232,31 +238,31 @@ bool Polyomino::isConvex() const {
 
 bool Polyomino::hasHole() const {
     // add every empty square on the outer of the box containing the polyomino
-    Polyomino temp({}, this->length);
+    std::set<Position> emptyPositions;
     for (int i = 0; i < this->length - 1; i++) {
-        this->tryToInsertPosition(temp, Position(i, 0));                                   // up row
-        this->tryToInsertPosition(temp, Position(this->length - 1, i));                    // rigth column
-        this->tryToInsertPosition(temp, Position(this->length - 1 - i, this->length - 1)); // bottom row
-        this->tryToInsertPosition(temp, Position(0, this->length - 1 - i));                // left column
+        this->tryToInsertPosition(emptyPositions, Position{i, 0});                                   // up row
+        this->tryToInsertPosition(emptyPositions, Position{this->length - 1, i});                    // rigth column
+        this->tryToInsertPosition(emptyPositions, Position{this->length - 1 - i, this->length - 1}); // bottom row
+        this->tryToInsertPosition(emptyPositions, Position{0, this->length - 1 - i});                // left column
     }
 
     // if we didn't reached all empty squares in the box then there was some contained within the polyomino, i.e. there was a hole
-    return (temp.getSize() < (this->length * this->length) - this->positions.size());
+    return (emptyPositions.size() < (this->length * this->length) - this->positions.size());
 }
 
-void Polyomino::tryToInsertPosition(Polyomino& emptyPositions, const Position& candidate) const {
+void Polyomino::tryToInsertPosition(std::set<Position>& emptyPositions, const Position& candidate) const {
     if (candidate.x >= this->length || candidate.x < 0 || candidate.y >= this->length || candidate.y < 0) return;
-    if (this->contains(candidate) || emptyPositions.contains(candidate)) return;
+    if (this->positions.contains(candidate) || emptyPositions.contains(candidate)) return;
 
     // if it's a new empty square, try its neighbors
     emptyPositions.insert(candidate);
-    tryToInsertPosition(emptyPositions, Position(candidate.x, candidate.y + 1));
-    tryToInsertPosition(emptyPositions, Position(candidate.x + 1, candidate.y));
-    tryToInsertPosition(emptyPositions, Position(candidate.x, candidate.y - 1));
-    tryToInsertPosition(emptyPositions, Position(candidate.x - 1, candidate.y));
+    tryToInsertPosition(emptyPositions, Position{candidate.x, candidate.y + 1});
+    tryToInsertPosition(emptyPositions, Position{candidate.x + 1, candidate.y});
+    tryToInsertPosition(emptyPositions, Position{candidate.x, candidate.y - 1});
+    tryToInsertPosition(emptyPositions, Position{candidate.x - 1, candidate.y});
 }
 
-const Polyomino::PolyominoData& Polyomino::getPositionsData() const {
+const std::set<Position>& Polyomino::getPositions() const {
     return this->positions;
 }
 
@@ -271,19 +277,13 @@ int Polyomino::getPolyominoSize() const {
 bool Polyomino::operator<(const Polyomino& other) const {
     if (this->length != other.length) return this->length < other.length;
 
-    assert(other.positions.any() && "The other polyomino is empty !");
-
-    static const PolyominoData longMask = 0xFFFFFFFFFFFFFFFF;
-    const int longsNeeded = this->length * this->length / 64 + 1;
-
-    for (int i = 0; i < longsNeeded; i++) {
-        unsigned long l1 = (this->positions >> (i * sizeof(std::uint64_t)) & longMask).to_ulong();
-        unsigned long l2 = (other.positions >> (i * sizeof(std::uint64_t)) & longMask).to_ulong();
-        if (l1 != l2) {
-            return l1 < l2;
+    for (int y = this->length - 1; y >= 0; y--) {
+        for (int x = 0; x < this->length; x++) {
+            bool hasThisPosition = this->positions.contains(Position{x, y});
+            bool hasOtherPosition = other.positions.contains(Position{x, y});
+            if (hasThisPosition != hasOtherPosition) return hasThisPosition;
         }
     }
-
     return false;
 }
 
@@ -294,7 +294,7 @@ bool Polyomino::operator==(const Polyomino& other) const {
 std::ostream& operator<<(std::ostream& os, const Polyomino& polyomino) {
     for (int y = polyomino.length - 1; y >= 0; y--) {
         for (int x = 0; x < polyomino.length; x++) {
-            if (polyomino.contains(Position(x, y))) {
+            if (polyomino.positions.contains(Position{x, y})) {
                 os << "*";
             }
             else {
@@ -305,31 +305,3 @@ std::ostream& operator<<(std::ostream& os, const Polyomino& polyomino) {
     }
     return os;
 }
-
-int Polyomino::getSize() const {
-    return positions.count();
-}
-
-bool Polyomino::contains(const Position& position) const {
-    return this->positions[getBitIndex(position)];
-}
-
-void Polyomino::insert(const Position& position) {
-    this->positions.set(getBitIndex(position), true);
-}
-
-void Polyomino::erase(const Position& position) {
-    this->positions.set(getBitIndex(position), false);
-}
-
-std::size_t Polyomino::getBitIndex(const Position& position) const {
-    return position.y * this->length + position.x;
-}
-
-Polyomino::ConstIterator Polyomino::begin() const {
-    return ConstIterator(*this, positions._Find_first());
-}
-
-Polyomino::ConstIterator Polyomino::end() const {
-    return ConstIterator(*this, positions.size());
-}

src/Pieces/Polyomino.h

@@ -5,68 +5,26 @@
 #include <vector>
 #include <set>
 #include <iostream>
-#include <array>
-#include <bitset>
 
 
 /**
  * A mathematical object consisting of touching squares on a 2D grid
  */
 class Polyomino {
-    public:
-        static const std::size_t MAX_LENGTH = 16;
-        using PolyominoData = std::bitset<MAX_LENGTH * MAX_LENGTH>;
-
-        class ConstIterator {
-            public:
-                using iterator_category = std::forward_iterator_tag;
-                using difference_type   = std::ptrdiff_t;
-                using value_type        = Position;
-                using const_pointer     = const Position*;  // or also value_type*
-                using const_reference   = const Position&;  // or also value_type&
-            public:
-                ConstIterator(const Polyomino& polyomino, std::size_t index) : m_Polyomino(polyomino), m_Index(index) {
-                    updatePosition();
-                }
-
-                const_reference operator*() const { return m_Position; }
-                const_pointer operator->() { return &m_Position; }
-
-                // Prefix increment
-                ConstIterator& operator++() { 
-                    m_Index = m_Polyomino.getPositionsData()._Find_next(m_Index);
-                    updatePosition();
-                    return *this; 
-                }  
-
-
-                friend bool operator== (const ConstIterator& a, const ConstIterator& b) { return a.m_Index == b.m_Index; };
-                friend bool operator!= (const ConstIterator& a, const ConstIterator& b) { return a.m_Index != b.m_Index; };  
-
-            private:
-                void updatePosition() {
-                    m_Position = Position(m_Index % m_Polyomino.getLength(), m_Index / m_Polyomino.getLength());
-                }
-
-                const Polyomino& m_Polyomino;
-                std::size_t m_Index;
-                Position m_Position;
-        };
-
     private:
-        PolyominoData positions; // the squares composing the polyomino, stored in binary. MSB is downleft
-        std::int8_t length;      // the size of the smallest square box in which the polyomino can fit on any rotation
-    
-    public:
-        /**
-         * Creates a polyomino with the specified positions and length, wheter it is actually a polyonimo of this length is not checked
-         */
-        Polyomino(PolyominoData&& positions, std::int8_t length);
+        std::set<Position> positions; // the squares composing the polyomino, (0,0) is downleft
+        int length;                   // the size of the smallest square box in which the polyomino can fit on any rotation
 
+    public:
         /**
          * Creates a polyomino with the specified positions and normalizes it, wheter it is actually a polyonimo is not checked
          */
-        Polyomino(std::set<Position>&& positions);
+        Polyomino(const std::set<Position>& positions);
+
+        /**
+         * Creates a polyomino with the specified positions and length, wheter it is actually a polyonimo of this length is not checked
+         */
+        Polyomino(const std::set<Position>& positions, int length);
 
         /**
          * Translates the polyomino to the lowest unsigned values (lower row on y = 0, and left-most column on x = 0)
@@ -112,33 +70,23 @@ class Polyomino {
          */
         bool hasHole() const;
     
-    private:
+    private :
         /**
          * Auxiliary method of hasHole()
          */
-        void tryToInsertPosition(Polyomino& emptypositions, const Position& candidate) const;
+        void tryToInsertPosition(std::set<Position>& emptypositions, const Position& candidate) const;
 
     public:
         /**
-         * @return The positions data of the polyomino
+         * @return The positions of the polyomino
          */
-        const PolyominoData& getPositionsData() const;
+        const std::set<Position>& getPositions() const;
 
         /**
          * @return The length of the polyomino
          */
         int getLength() const;
 
-        /**
-         * 
-         */
-        int getSize() const;
-
-        /**
-         * 
-         */
-        std::size_t getBitIndex(const Position& position) const;
-
         /**
          * @return The number of squares in the polyomino
          */
@@ -162,23 +110,4 @@ class Polyomino {
          * @return A reference to the output stream
          */
         friend std::ostream& operator<<(std::ostream& os, const Polyomino& polyomino);
-
-        /**
-         * @return True if it contains the position
-         */
-        bool contains(const Position& position) const;
-
-        /**
-         * @brief Insert a square at the position
-         */
-        void insert(const Position& position);
-
-        /**
-         * @brief Removes a square at the position
-         */
-        void erase(const Position& position);
-
-        ConstIterator begin() const;
-
-        ConstIterator end() const;
 };

src/Pieces/Position.h

@@ -1,14 +1,14 @@
 #pragma once
 
 #include <iostream>
-#include <cstdint>
+
 
 /**
  * A position on a 2D grid
  */
 struct Position {
-    std::int8_t x; // x position
-    std::int8_t y; // y position
+    int x; // x position
+    int y; // y position
 };
 
 
@@ -17,7 +17,7 @@ struct Position {
  * @return The sums of the coordinates of both positions
  */
 inline Position operator+(const Position& left, const Position& right) {
-    return Position(left.x + right.x, left.y + right.y);
+    return Position{left.x + right.x, left.y + right.y};
 }
 
 /**
@@ -34,7 +34,7 @@ inline Position& operator+=(Position& left, const Position& right) {
  * @return The difference of the coordinate between the left and right position
  */
 inline Position operator-(const Position& left, const Position& right) {
-    return Position(left.x - right.x, left.y - right.y);
+    return Position{left.x - right.x, left.y - right.y};
 }
 
 /**

src/TextUI/TextApp.cpp

@@ -250,9 +250,9 @@ void TextApp::printGame(const Game& game) const {
     for (int y = maxHeight; y >= 0; y--) {
         for (int x = 0; x < game.getBoard().getWidth(); x++) {
             /* BOARD PRINTING */
-            bool isActivePieceHere = (game.getActivePiece() != nullptr) && (game.getActivePiece()->getPositions().contains(Position(x, y) - game.getActivePiecePosition()));
-            bool isGhostPieceHere = (game.getActivePiece() != nullptr) && (game.getActivePiece()->getPositions().contains(Position(x, y) - game.getGhostPiecePosition()));
-            Block block = (isActivePieceHere || isGhostPieceHere) ? game.getActivePiece()->getBlockType() : game.getBoard().getBlock(Position(x, y));
+            bool isActivePieceHere = (game.getActivePiece() != nullptr) && (game.getActivePiece()->getPositions().contains(Position{x, y} - game.getActivePiecePosition()));
+            bool isGhostPieceHere = (game.getActivePiece() != nullptr) && (game.getActivePiece()->getPositions().contains(Position{x, y} - game.getGhostPiecePosition()));
+            Block block = (isActivePieceHere || isGhostPieceHere) ? game.getActivePiece()->getBlockType() : game.getBoard().getBlock(Position{x, y});
 
             if (isActivePieceHere || isGhostPieceHere) {
                 std::cout << getConsoleColorCode(block);
@@ -294,7 +294,7 @@ void TextApp::printGame(const Game& game) const {
                 }
                 else {
                     for (int i = 0; i < game.getHeldPiece()->getLength(); i++) {
-                        if (game.getHeldPiece()->getPositions().contains(Position(i, printedPieceLineHeight))) {
+                        if (game.getHeldPiece()->getPositions().contains(Position{i, printedPieceLineHeight})) {
                             std::cout << getConsoleColorCode(game.getHeldPiece()->getBlockType()) << "*";
                         }
                         else {
@@ -316,7 +316,7 @@ void TextApp::printGame(const Game& game) const {
                 }
                 else {
                     for (int i = 0; i < game.getNextPieces().at(nextQueuePrintedPiece).getLength(); i++) {
-                        if (game.getNextPieces().at(nextQueuePrintedPiece).getPositions().contains(Position(i, printedPieceLineHeight))) {
+                        if (game.getNextPieces().at(nextQueuePrintedPiece).getPositions().contains(Position{i, printedPieceLineHeight})) {
                             std::cout << getConsoleColorCode(game.getNextPieces().at(nextQueuePrintedPiece).getBlockType()) << "*";
                         }
                         else {

src/TextUI/main.cpp

@@ -1,6 +1,7 @@
 #include "../Pieces/Generator.h"
 #include "../Pieces/PiecesFiles.h"
 #include "TextApp.h"
+#include "../Utils/AssetManager.h"
 
 #include <chrono>
 #include <filesystem>
@@ -22,7 +23,7 @@ int main(int argc, char** argv) {
     PiecesFiles pf;
     bool warned = false;
     for (int i = 1; i <= MAXIMUM_PIECES_SIZE; i++) {
-        if (!std::filesystem::exists("data/pieces/" + std::to_string(i) + "minos.bin")) {
+        if (!std::filesystem::exists(AssetManager::getResourcePath("data/pieces/" + std::to_string(i) + "minos.bin"))) {
             if (!warned) {
                 std::cout << "INFO: Pieces files for size " << i << " not found, generating..." << std::endl;
                 warned = true;

src/Utils/AssetManager.cpp

@@ -1,97 +1,42 @@
-#include "./AssetManager.h"
+#include "AssetManager.h"
 
-#include <map>
+#ifdef _WIN32
+#include <windows.h>    //GetModuleFileNameW
+#else
+#include <limits.h>
+#include <unistd.h>     //readlink
+#endif
 
-static const unsigned char data_fonts_pressstart_prstart_ttf[] = {
-	#include <data/fonts/pressstart/prstart.ttf.h>
-};
+namespace fs = std::filesystem;
 
-static const unsigned char data_fonts_pressstart_prstartk_ttf[] = {
-	#include <data/fonts/pressstart/prstartk.ttf.h>
-};
-
-static const unsigned char data_images_keybinds_Harddrop_png[] = {
-	#include <data/images/keybinds/Harddrop.png.h>
-};
-
-static const unsigned char data_images_keybinds_Moveleft_png[] = {
-	#include <data/images/keybinds/Moveleft.png.h>
-};
-
-static const unsigned char data_images_keybinds_RotateCW_png[] = {
-	#include <data/images/keybinds/RotateCW.png.h>
-};
-
-static const unsigned char data_images_keybinds_RotateCCW_png[] = {
-	#include <data/images/keybinds/RotateCCW.png.h>
-};
-
-static const unsigned char data_images_keybinds_Softdrop_png[] = {
-	#include <data/images/keybinds/Softdrop.png.h>
-};
-
-static const unsigned char data_images_keybinds_Moveright_png[] = {
-	#include <data/images/keybinds/Moveright.png.h>
-};
-
-static const unsigned char data_images_keybinds_Rotate180_png[] = {
-	#include <data/images/keybinds/Rotate180.png.h>
-};
-
-static const unsigned char data_images_keybinds_Hold_png[] = {
-	#include <data/images/keybinds/Hold.png.h>
-};
-
-static const unsigned char data_images_keybinds_Rotate0_png[] = {
-	#include <data/images/keybinds/Rotate0.png.h>
-};
-
-static const unsigned char data_images_keybinds_Retry_png[] = {
-	#include <data/images/keybinds/Retry.png.h>
-};
-
-static const unsigned char data_images_keybinds_Pause_png[] = {
-	#include <data/images/keybinds/Pause.png.h>
-};
-
-static const Asset assets[] = {
-	{data_fonts_pressstart_prstart_ttf, sizeof(data_fonts_pressstart_prstart_ttf)},
-	{data_fonts_pressstart_prstartk_ttf, sizeof(data_fonts_pressstart_prstartk_ttf)},
-	{data_images_keybinds_Harddrop_png, sizeof(data_images_keybinds_Harddrop_png)},
-	{data_images_keybinds_Moveleft_png, sizeof(data_images_keybinds_Moveleft_png)},
-	{data_images_keybinds_RotateCW_png, sizeof(data_images_keybinds_RotateCW_png)},
-	{data_images_keybinds_RotateCCW_png, sizeof(data_images_keybinds_RotateCCW_png)},
-	{data_images_keybinds_Softdrop_png, sizeof(data_images_keybinds_Softdrop_png)},
-	{data_images_keybinds_Moveright_png, sizeof(data_images_keybinds_Moveright_png)},
-	{data_images_keybinds_Rotate180_png, sizeof(data_images_keybinds_Rotate180_png)},
-	{data_images_keybinds_Hold_png, sizeof(data_images_keybinds_Hold_png)},
-	{data_images_keybinds_Rotate0_png, sizeof(data_images_keybinds_Rotate0_png)},
-	{data_images_keybinds_Retry_png, sizeof(data_images_keybinds_Retry_png)},
-	{data_images_keybinds_Pause_png, sizeof(data_images_keybinds_Pause_png)},
-
-};
-
-static const std::map<std::string, AssetName> assetMap = {
-	{"data/fonts/pressstart/prstart.ttf", AssetName::data_fonts_pressstart_prstart_ttf},
-	{"data/fonts/pressstart/prstartk.ttf", AssetName::data_fonts_pressstart_prstartk_ttf},
-	{"data/images/keybinds/Harddrop.png", AssetName::data_images_keybinds_Harddrop_png},
-	{"data/images/keybinds/Moveleft.png", AssetName::data_images_keybinds_Moveleft_png},
-	{"data/images/keybinds/RotateCW.png", AssetName::data_images_keybinds_RotateCW_png},
-	{"data/images/keybinds/RotateCCW.png", AssetName::data_images_keybinds_RotateCCW_png},
-	{"data/images/keybinds/Softdrop.png", AssetName::data_images_keybinds_Softdrop_png},
-	{"data/images/keybinds/Moveright.png", AssetName::data_images_keybinds_Moveright_png},
-	{"data/images/keybinds/Rotate180.png", AssetName::data_images_keybinds_Rotate180_png},
-	{"data/images/keybinds/Hold.png", AssetName::data_images_keybinds_Hold_png},
-	{"data/images/keybinds/Rotate0.png", AssetName::data_images_keybinds_Rotate0_png},
-	{"data/images/keybinds/Retry.png", AssetName::data_images_keybinds_Retry_png},
-	{"data/images/keybinds/Pause.png", AssetName::data_images_keybinds_Pause_png},
-
-};
-
-const Asset& getResource(AssetName fileName) {
-	return assets[static_cast<std::size_t>(fileName)];
+static fs::path getExeDirectory(){
+	#ifdef _WIN32
+    wchar_t path[MAX_PATH] = { 0 };
+    GetModuleFileNameW(NULL, path, MAX_PATH);
+    return path;
+#else
+    char result[PATH_MAX];
+    ssize_t count = readlink("/proc/self/exe", result, PATH_MAX);
+    return std::string(result, (count > 0) ? count : 0);
+#endif
 }
 
-const Asset& getResource(const std::string& fileName) {
-	return getResource(assetMap.at(fileName));
+
+
+static fs::path getEnv(const std::string& var) {
+	char* env = std::getenv(var.c_str());
+	return env ? env : 
+#ifdef JMINOS_IGNORE_WORKDIR
+	getExeDirectory().parent_path().parent_path();
+#else
+	"";
+#endif
 }
+
+fs::path AssetManager::getResourcePath(const std::string& resource) {
+	return fs::path{getEnv("JMINOS_DATA")} / resource;
+}
+
+fs::path AssetManager::getConfigPath(const std::string& resource) {
+	return fs::path{getEnv("JMINOS_CONFIG")} / resource;
+}

src/Utils/AssetManager.h

@@ -2,29 +2,17 @@
 
 #include <cstdint>
 #include <string>
+#include <filesystem>
 
-struct Asset {
-	const unsigned char* data;
-	std::size_t size;
-};
+class AssetManager {
+	public:
+		/**
+		 * @brief Used to load things (might be read-only)
+		 */
+		static std::filesystem::path getResourcePath(const std::string& resource);
 
-enum class AssetName {
-	data_fonts_pressstart_prstart_ttf,
-	data_fonts_pressstart_prstartk_ttf,
-	data_images_keybinds_Harddrop_png,
-	data_images_keybinds_Moveleft_png,
-	data_images_keybinds_RotateCW_png,
-	data_images_keybinds_RotateCCW_png,
-	data_images_keybinds_Softdrop_png,
-	data_images_keybinds_Moveright_png,
-	data_images_keybinds_Rotate180_png,
-	data_images_keybinds_Hold_png,
-	data_images_keybinds_Rotate0_png,
-	data_images_keybinds_Retry_png,
-	data_images_keybinds_Pause_png,
-
-};
-
-const Asset& getResource(AssetName fileName);
-
-const Asset& getResource(const std::string& fileName);
+		/**
+		 * @brief Used to save things
+		 */
+		static std::filesystem::path getConfigPath(const std::string& resource);
+};

xmake.lua

@@ -1,8 +1,20 @@
 add_rules("mode.debug", "mode.release")
 
-includes("xmake/bin2c.lua")
+set_version("1.0.0")
+set_project("org.zulianc.jminos")
 
-add_requires("sfml 3.0.0", "zlib")
+includes("@builtin/xpack")
+
+option("external_build")
+    set_default(false)
+option_end()
+
+if has_config("external_build") then
+    add_requires("sfml 3.0.0", "zlib", {system = false})
+    add_defines("JMINOS_IGNORE_WORKDIR")
+else
+    add_requires("sfml 3.0.0", "zlib")
+end
 
 set_languages("c++20")
 
@@ -10,7 +22,7 @@ set_rundir(".")
 
 target("core")
     set_kind("$(kind)")
-    add_files("src/Pieces/*.cpp", "src/Core/*.cpp", "src/Common/*.cpp")
+    add_files("src/Pieces/*.cpp", "src/Core/*.cpp", "src/Common/*.cpp", "src/Utils/*.cpp")
     add_packages("zlib")
 
 target("text")
@@ -27,16 +39,11 @@ target("bmark")
 
 target("graph")
     set_default(true)
-    add_rules("bin2c", {
-        extensions = {".png", ".ttf"}, 
-        outputSource = {"src/Utils/AssetManager.cpp"},
-        outputHeader = {"src/Utils/AssetManager.h"}
-    })
     set_kind("binary")
     add_files("./src/GraphicalUI/**.cpp")
-    add_files("data/fonts/**.ttf", "data/images/**.png")
     add_deps("core")
     add_packages("sfml")
+    add_installfiles("(data/**)")
 
 if is_mode("debug") then 
     add_defines("DEBUG")
@@ -46,6 +53,7 @@ if is_plat("mingw") then
     add_ldflags("-static-libstdc++", "-static")
 end
 
+includes("xmake/xpack.lua")
 
 --
 -- If you want to known more usage about xmake, please see https://xmake.io

xmake/xpack.lua

@@ -0,0 +1,36 @@
+if is_os("linux") then
+
+xpack("jminos")
+    set_formats("flatpak")
+    set_extension("flatpak")
+    set_title("jminos")
+    set_author("zulianc")
+    set_description("A test installer.")
+    set_homepage("https://git.ale-pri.com/TetrisNerd/jminos")
+    set_company("org.zulianc")
+    on_package(function (package)
+        os.cd("flatpak")
+        os.exec("flatpak install org.flatpak.Builder --user -y")
+        os.exec("flatpak run org.flatpak.Builder --force-clean --user --install-deps-from=flathub --repo=repo --install builddir org.zulianc.jminos.yml")
+        os.exec("flatpak build-bundle repo jminos.flatpak org.zulianc.jminos --runtime-repo=https://flathub.org/repo/flathub.flatpakrepo")
+        os.mv("jminos.flatpak", package:outputdir())
+    end)
+    on_load(function (package)
+        package:set("basename", package:name() .. "-v" .. package:version() .. "-" .. package:arch())
+    end)
+
+else
+
+xpack("jminos")
+    set_formats("zip", "nsis")
+    add_targets("graph")
+    add_installfiles("(data/**.png)")
+    set_iconfile("../flatpak/org.zulianc.jminos.ico")
+    on_load(function (package)
+        package:set("basename", package:name() .. "-v" .. package:version() .. "-" .. package:arch())
+    end)
+    after_installcmd(function (package, batchcmds)
+        batchcmds:rm(package:installdir("**/.gitkeep"))
+    end)
+
+end