- [FIX] En Windows no se reemplaçaven correctament les barres

- [NEW] Afegit Makefile para mayor comodidad de los usuarios (linux, windows i macos)
- [NEW] El lagueirtofile adjunt pot recompilar lagueirto amb el propi lagueirto
- [NEW] Nova opció "compiler" per a especificar qué usar per a compilar ("g++", "clang++"...)
- [NEW] Compilació paralela amb threads (autodetecció de nombre de threads óptim)

.gitignore

@@ -1,3 +1,4 @@
 lagueirto
 .vscode/*
-lagueirto.exe
+*.exe
+*.zip

Makefile

@@ -0,0 +1,12 @@
+executable = lagueirto
+source = main.cpp
+
+windows:
+	@echo off
+	g++ $(source) -O3 -o "$(executable).exe"
+
+macos:
+	clang++ $(source) -O3 -o "$(executable)"
+
+linux:
+	g++ $(source) -O3 -o "$(executable)"

do_release.bat

@@ -8,6 +8,9 @@ IF "%1"=="" (
 
 set PARAM=%1
 
+echo Obteniendo última versión...
+git pull || exit /b 1
+
 echo Compilando windows...
 g++ main.cpp -O3 -o lagueirto.exe || exit /b 1
 

lagueirtofile

@@ -1,5 +1,4 @@
-libs = -lSDL2 -lSDL2_mixer
+cppflags = -O3
-cppflags = -D DEBUG -g
+executable = lagueirto
-executable = thepool_debug
+sourcepath = .
-sourcepath = source
 buildpath = build

main.cpp

@@ -7,6 +7,11 @@
 #include <chrono>
 #include <algorithm>
 #include <string.h>
+#include <thread>
+#include <mutex>
+#include <queue>
+#include <condition_variable>
+#include <atomic>
 
 #include "version.h"
 
@@ -16,19 +21,23 @@ std::string executable = "out";
 std::string source_path = "";
 std::vector<std::string> source_paths;
 std::string build_path = "";
+std::string compiler = "g++";
 #ifdef _WIN32
-std::string folder_char = "\\";
+char folder_char = '\\';
 #else
-std::string folder_char = "/";
+char folder_char = '/';
 #endif
+std::string loaded_section = "";
 
 std::vector<std::string> exclude;
-std::vector<std::string> keys = {"libs", "cppflags", "executable", "sourcepath", "buildpath", "exclude"};
+std::vector<std::string> keys = {"libs", "cppflags", "executable", "sourcepath", "buildpath", "exclude", "compiler"};
-enum tokens {LIBS, CPPFLAGS, EXECUTABLE, SOURCEPATH, BUILDPATH, EXCLUDE};
+enum tokens {LIBS, CPPFLAGS, EXECUTABLE, SOURCEPATH, BUILDPATH, EXCLUDE, COMPILER};
 
 bool must_link = false;
 bool must_recompile_all = false;
 
+std::mutex progress_mtx;
+
 struct FileInfo {
     std::string filename;
     std::filesystem::file_time_type time;
@@ -174,7 +183,7 @@ bool loadLagueirtoFile(const std::string &section_to_load)
             if (rest == "default") found_default = true;
             if (section_to_load.empty() && rest == "default") active = true;
             else active = (current_section == section_to_load);
-
+            if (active) loaded_section = current_section;
             continue;
         }
 
@@ -194,6 +203,7 @@ bool loadLagueirtoFile(const std::string &section_to_load)
         else if (key == "sourcepath") source_path = value;
         else if (key == "buildpath") build_path = value;
         else if (key == "exclude") exclude = split(value);
+        else if (key == "compiler") compiler = value;
     }
     return !(found_any_section && section_to_load.empty() && !found_default);
 }
@@ -310,9 +320,17 @@ bool HeadersNeedRecompile(FileInfo file, std::filesystem::file_time_type object_
     return false;
 }
 
-bool MustRecompile(FileInfo file) {
+std::string generate_object_file_name(std::string filename) {
-    std::string object_file = build_path + folder_char + std::filesystem::path(file.filename).stem().string() + ".o";
+    std::filesystem::path cwd    = std::filesystem::weakly_canonical(std::filesystem::current_path());
+    std::filesystem::path target = std::filesystem::weakly_canonical(filename);
+    std::string out = std::filesystem::relative(target, cwd).replace_extension("o").generic_string();
+    for (char& c : out) if (c == '/') c = '.';
+    return build_path + folder_char + out;
+}
 
+bool MustRecompile(FileInfo file) {
+    std::string object_file = generate_object_file_name(file.filename);
+    
     // si el objecte no existeix, fa falta recompilar
     if (!std::filesystem::exists(object_file)) {
         return true;
@@ -332,9 +350,9 @@ bool MustRecompile(FileInfo file) {
 }
 
 void Recompile(std::string source_file) {
-    std::string object_file = build_path + folder_char + std::filesystem::path(source_file).stem().string() + ".o";
+    std::string object_file = generate_object_file_name(source_file);
     must_link = true;
-    std::string command = "g++ " + source_file + " " + cppflags + " -c -o " + object_file;
+    std::string command = compiler + " " + source_file + " " + cppflags + " -c -o " + object_file;
     //std::cout << command << std::endl;
 
     if (system(command.c_str()) != 0) {
@@ -428,9 +446,79 @@ void processCommand(std::string arg) {
     if (arg == "-r") must_recompile_all = true;
 }
 
+void parallel_compile(int thread_count)
+{
+    std::queue<std::string> work;
+    std::mutex mtx;
+    std::condition_variable cv;
+    bool done = false;
+
+    // Omplim la cua amb els arxius que necessiten recompilarse
+    for (auto &file : cpp_files) {
+        if (MustRecompile(file)) {
+            work.push(file.filename);
+            must_link = true;
+        }
+    }
+
+    std::atomic<int> completed = 0;
+    int total = work.size();
+    progress_bar(0);
+
+    auto worker = [&]() {
+        while (true) {
+            std::string job;
+
+            // Extraure treball
+            {
+                std::unique_lock<std::mutex> lock(mtx);
+                cv.wait(lock, [&]() { return !work.empty() || done; });
+
+                if (work.empty()) return; // ja no hi ha res més que fer
+
+                job = work.front();
+                work.pop();
+            }
+
+            // Compilar
+            Recompile(job);
+
+            {
+                std::lock_guard<std::mutex> lock(progress_mtx);
+                int done_now = ++completed;
+                progress_bar(100 * done_now / total);
+            }
+        }
+    };
+
+    // Llançar threads
+    std::vector<std::thread> threads;
+    for (int i = 0; i < thread_count; i++)
+        threads.emplace_back(worker);
+
+    // Notificar als threads
+    {
+        std::lock_guard<std::mutex> lock(mtx);
+        done = true;
+    }
+    cv.notify_all();
+
+    // Esperem a que acaben
+    for (auto &t : threads)
+        t.join();
+
+    progress_bar(100);
+    printf("\n");
+}
+
 int main(int argc, char *argv[])
 {
-    std::cout << "Lagueirto v" << LAGUEIRTO_VERSION << std::endl;
+std::cout << " _                        _      _        " << std::endl;
+std::cout << "| | __ _  __ _ _   _  ___(_)_ __| |_ ___  " << std::endl;
+std::cout << "| |/ _` |/ _` | | | |/ _ \\ | '__| __/ _ \\ " << std::endl;
+std::cout << "| | (_| | (_| | |_| |  __/ | |  | || (_) |" << std::endl;
+std::cout << "|_|\\__,_|\\__, |\\__,_|\\___|_|_|   \\__\\___/ " << std::endl;
+std::cout << "         |___/ v" << LAGUEIRTO_VERSION << std::endl;
 
     std::string configuration_to_use;
     for (int i = 1; i < argc; ++i)
@@ -445,14 +533,29 @@ int main(int argc, char *argv[])
         exit(1);
     }
 
+    std::string last_config_file = build_path + folder_char + "last_config";
+    if (!std::filesystem::exists(last_config_file)) {
+        must_recompile_all = true;
+    } else {
+        std::ifstream in(last_config_file);
+        if (in) {
+            std::string word;
+            in >> word;
+            if (word != loaded_section) must_recompile_all = true;
+        }
+    }
+
     if (must_recompile_all) {
         std::cout << "remove: '" << build_path << "'" << std::endl;
         std::filesystem::remove_all(build_path);
     }
 
+    if (!std::filesystem::is_directory(build_path)) std::filesystem::create_directory(build_path);
+    std::ofstream out(last_config_file);
+    if (out) out << loaded_section;
+
     std::chrono::steady_clock::time_point begin_all = std::chrono::steady_clock::now();
 
-    if (!std::filesystem::is_directory(build_path)) std::filesystem::create_directory(build_path);
     source_paths = split(source_path);
 
     // Recopilem tots els arxius cpp i capçaleres
@@ -517,19 +620,25 @@ int main(int argc, char *argv[])
 
     //print_file_tree(0, cpp_files);
 
-    int i = 0;
+    int threads = std::thread::hardware_concurrency();
-    int total = cpp_files.size();
+    //printf("threads: %i\n", threads);
-    progress_bar(0);
+    if (threads == 0) threads = 4; // fallback
-    for (auto& file : cpp_files) {
+
-        if (MustRecompile(file)) Recompile(file.filename);
+    parallel_compile(threads);
-        progress_bar(100*float(float(i)/float(total)));
+
-        i++;
+//    int i = 0;
-    }
+//    int total = cpp_files.size();
-    progress_bar(100);
+//    progress_bar(0);
-    std::cout << std::endl;
+//    for (auto& file : cpp_files) {
+//        if (MustRecompile(file)) Recompile(file.filename);
+//        progress_bar(100*float(float(i)/float(total)));
+//        i++;
+//    }
+//    progress_bar(100);
+//    std::cout << std::endl;
 
     if (must_link) {
-        std::string command = "g++ " + build_path + folder_char + "*.o " + libs + " -o " + executable;
+        std::string command = compiler + " " + build_path + folder_char + "*.o " + libs + " -o " + executable;
         //std::cout << command << std::endl;
         std::cout << "Linking..."; fflush(stdout);
         if (system(command.c_str()) != 0) {

publish_gitea.sh

@@ -6,7 +6,7 @@ set -e
 #    exit 1
 #fi
 
-GITEA_TOKEN="eb44d9c0142f5038c61c5afd17f5a41177bfaedc"
+#GITEA_TOKEN=""
 
 if [ -z "$GITEA_TOKEN" ]; then
     echo "ERROR: Debes exportar GITEA_TOKEN"
@@ -43,7 +43,7 @@ echo "Release creado con ID: $RELEASE_ID"
 echo "=== Subiendo artefactos ==="
 
 for f in lagueirto_v${VERSION}_linux.tar.gz \
-         lagueirto_v${VERSION}_win32-x64.zip \
+         lagueirto_v${VERSION}_win32-x64.zip
 do
     echo "Subiendo $f..."
     curl -s -X POST \

version.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define LAGUEIRTO_VERSION "2.0.1"
+#define LAGUEIRTO_VERSION "2.1.3"