claude: mogut initBalloonFormations() a un fitxer extern

clang-format

.clang-format

@@ -10,3 +10,10 @@ AlignOperands: false
 AlignAfterOpenBracket: DontAlign
 BinPackArguments: false
 BinPackParameters: false
+
+SortIncludes: CaseSensitive
+IncludeBlocks: Merge
+IncludeCategories:
+  - Regex: '.*'
+    Priority: 1
+    SortPriority: -1

data/config/balloon_formations.txt

@@ -0,0 +1,277 @@
+# Archivo de configuración de formaciones de globos
+# Formato por línea: x, y, vel_x, tipo, tamaño, tiempo_creacion
+# Variables disponibles:
+# X1_0, X1_50, X1_100, X2_0, X2_100, X3_0, X3_100, X4_0, X4_100
+# QUARTER1_X4, QUARTER3_X4, Y_BASE
+# BALLOON_SIZE_0, BALLOON_SIZE_1, BALLOON_SIZE_2, BALLOON_SIZE_3
+# VEL_POSITIVE, VEL_NEGATIVE
+
+formation: 0
+# Dos enemigos BALLOON4 uno a cada extremo
+X4_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE4, 300
+X4_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE4, 300
+
+formation: 1
+# Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro
+QUARTER1_X4, Y_BASE, VEL_POSITIVE, BALLOON, SIZE4, 300
+QUARTER3_X4, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE4, 300
+
+formation: 2
+# Cuatro enemigos BALLOON2 uno detrás del otro. A la izquierda y hacia el centro
+X2_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 300
+X2_0 + BALLOON_SIZE_1 + 1, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 290
+X2_0 + (BALLOON_SIZE_1 + 1) * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 280
+X2_0 + (BALLOON_SIZE_1 + 1) * 3, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 270
+
+formation: 3
+# Cuatro enemigos BALLOON2 uno detrás del otro. A la derecha y hacia el centro
+X2_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 300
+X2_100 - BALLOON_SIZE_1 - 1, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 290
+X2_100 - (BALLOON_SIZE_1 + 1) * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 280
+X2_100 - (BALLOON_SIZE_1 + 1) * 3, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 270
+
+formation: 4
+# Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha
+X3_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 300
+X3_0 + BALLOON_SIZE_2 * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 290
+X3_0 + BALLOON_SIZE_2 * 4, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 280
+
+formation: 5
+# Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda
+X3_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 300
+X3_100 - BALLOON_SIZE_2 * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 290
+X3_100 - BALLOON_SIZE_2 * 4, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 280
+
+formation: 6
+# Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha
+X3_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 300
+X3_0 + BALLOON_SIZE_2 + 1, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 290
+X3_0 + (BALLOON_SIZE_2 + 1) * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 280
+
+formation: 7
+# Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda
+X3_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 300
+X3_100 - BALLOON_SIZE_2 - 1, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 290
+X3_100 - (BALLOON_SIZE_2 + 1) * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 280
+
+formation: 8
+# Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha
+X1_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 300
+X1_0 + BALLOON_SIZE_0 + 1, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 290
+X1_0 + (BALLOON_SIZE_0 + 1) * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 280
+X1_0 + (BALLOON_SIZE_0 + 1) * 3, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 270
+X1_0 + (BALLOON_SIZE_0 + 1) * 4, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 260
+X1_0 + (BALLOON_SIZE_0 + 1) * 5, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 250
+
+formation: 9
+# Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda
+X1_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 300
+X1_100 - BALLOON_SIZE_0 - 1, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 290
+X1_100 - (BALLOON_SIZE_0 + 1) * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 280
+X1_100 - (BALLOON_SIZE_0 + 1) * 3, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 270
+X1_100 - (BALLOON_SIZE_0 + 1) * 4, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 260
+X1_100 - (BALLOON_SIZE_0 + 1) * 5, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 250
+
+formation: 10
+# Tres enemigos BALLOON4 seguidos desde la izquierda. Hacia la derecha
+X4_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE4, 300
+X4_0 + BALLOON_SIZE_3 + 1, Y_BASE, VEL_POSITIVE, BALLOON, SIZE4, 285
+X4_0 + (BALLOON_SIZE_3 + 1) * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE4, 270
+
+formation: 11
+# Tres enemigos BALLOON4 seguidos desde la derecha. Hacia la izquierda
+X4_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE4, 300
+X4_100 - BALLOON_SIZE_3 - 1, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE4, 285
+X4_100 - (BALLOON_SIZE_3 + 1) * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE4, 270
+
+formation: 12
+# Seis enemigos BALLOON2 uno detrás del otro. A la izquierda y hacia el centro
+X2_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 300
+X2_0 + BALLOON_SIZE_1 + 1, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 290
+X2_0 + (BALLOON_SIZE_1 + 1) * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 280
+X2_0 + (BALLOON_SIZE_1 + 1) * 3, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 270
+X2_0 + (BALLOON_SIZE_1 + 1) * 4, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 260
+X2_0 + (BALLOON_SIZE_1 + 1) * 5, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 250
+
+formation: 13
+# Seis enemigos BALLOON2 uno detrás del otro. A la derecha y hacia el centro
+X2_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 300
+X2_100 - BALLOON_SIZE_1 - 1, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 290
+X2_100 - (BALLOON_SIZE_1 + 1) * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 280
+X2_100 - (BALLOON_SIZE_1 + 1) * 3, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 270
+X2_100 - (BALLOON_SIZE_1 + 1) * 4, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 260
+X2_100 - (BALLOON_SIZE_1 + 1) * 5, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 250
+
+formation: 14
+# Cinco enemigos BALLOON3. Hacia la derecha. Separados
+X3_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 300
+X3_0 + BALLOON_SIZE_2 * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 290
+X3_0 + BALLOON_SIZE_2 * 4, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 280
+X3_0 + BALLOON_SIZE_2 * 6, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 270
+X3_0 + BALLOON_SIZE_2 * 8, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 260
+
+formation: 15
+# Cinco enemigos BALLOON3. Hacia la izquierda. Separados
+X3_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 300
+X3_100 - BALLOON_SIZE_2 * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 290
+X3_100 - BALLOON_SIZE_2 * 4, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 280
+X3_100 - BALLOON_SIZE_2 * 6, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 270
+X3_100 - BALLOON_SIZE_2 * 8, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 260
+
+formation: 16
+# Cinco enemigos BALLOON3. Hacia la derecha. Juntos
+X3_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 300
+X3_0 + BALLOON_SIZE_2 + 1, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 290
+X3_0 + (BALLOON_SIZE_2 + 1) * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 280
+X3_0 + (BALLOON_SIZE_2 + 1) * 3, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 270
+X3_0 + (BALLOON_SIZE_2 + 1) * 4, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 260
+
+formation: 17
+# Cinco enemigos BALLOON3. Hacia la izquierda. Juntos
+X3_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 300
+X3_100 - BALLOON_SIZE_2 - 1, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 290
+X3_100 - (BALLOON_SIZE_2 + 1) * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 280
+X3_100 - (BALLOON_SIZE_2 + 1) * 3, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 270
+X3_100 - (BALLOON_SIZE_2 + 1) * 4, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 260
+
+formation: 18
+# Doce enemigos BALLOON1. Hacia la derecha. Juntos
+X1_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 300
+X1_0 + BALLOON_SIZE_0 + 1, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 290
+X1_0 + (BALLOON_SIZE_0 + 1) * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 280
+X1_0 + (BALLOON_SIZE_0 + 1) * 3, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 270
+X1_0 + (BALLOON_SIZE_0 + 1) * 4, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 260
+X1_0 + (BALLOON_SIZE_0 + 1) * 5, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 250
+X1_0 + (BALLOON_SIZE_0 + 1) * 6, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 240
+X1_0 + (BALLOON_SIZE_0 + 1) * 7, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 230
+X1_0 + (BALLOON_SIZE_0 + 1) * 8, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 220
+X1_0 + (BALLOON_SIZE_0 + 1) * 9, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 210
+X1_0 + (BALLOON_SIZE_0 + 1) * 10, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 200
+X1_0 + (BALLOON_SIZE_0 + 1) * 11, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 190
+
+formation: 19
+# Doce enemigos BALLOON1. Hacia la izquierda. Juntos
+X1_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 300
+X1_100 - BALLOON_SIZE_0 - 1, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 290
+X1_100 - (BALLOON_SIZE_0 + 1) * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 280
+X1_100 - (BALLOON_SIZE_0 + 1) * 3, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 270
+X1_100 - (BALLOON_SIZE_0 + 1) * 4, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 260
+X1_100 - (BALLOON_SIZE_0 + 1) * 5, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 250
+X1_100 - (BALLOON_SIZE_0 + 1) * 6, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 240
+X1_100 - (BALLOON_SIZE_0 + 1) * 7, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 230
+X1_100 - (BALLOON_SIZE_0 + 1) * 8, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 220
+X1_100 - (BALLOON_SIZE_0 + 1) * 9, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 210
+X1_100 - (BALLOON_SIZE_0 + 1) * 10, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 200
+X1_100 - (BALLOON_SIZE_0 + 1) * 11, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 190
+
+formation: 20
+# Cuatro enemigos BALLOON4 seguidos desde la izquierda/derecha. Simétricos
+X4_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE4, 300
+X4_0 + BALLOON_SIZE_3 + 1, Y_BASE, VEL_POSITIVE, BALLOON, SIZE4, 300
+X4_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE4, 300
+X4_100 - BALLOON_SIZE_3 - 1, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE4, 300
+
+formation: 21
+# Diez enemigos BALLOON2 uno detrás del otro. Izquierda/derecha. Simétricos
+X2_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 300
+X2_0 + BALLOON_SIZE_1 + 1, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 297
+X2_0 + (BALLOON_SIZE_1 + 1) * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 294
+X2_0 + (BALLOON_SIZE_1 + 1) * 3, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 291
+X2_0 + (BALLOON_SIZE_1 + 1) * 4, Y_BASE, VEL_POSITIVE, BALLOON, SIZE2, 288
+X2_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 300
+X2_100 - BALLOON_SIZE_1 - 1, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 297
+X2_100 - (BALLOON_SIZE_1 + 1) * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 294
+X2_100 - (BALLOON_SIZE_1 + 1) * 3, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 291
+X2_100 - (BALLOON_SIZE_1 + 1) * 4, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE2, 288
+
+formation: 22
+# Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simétricos
+X3_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 300
+X3_0 + BALLOON_SIZE_2 * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 290
+X3_0 + BALLOON_SIZE_2 * 4, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 280
+X3_0 + BALLOON_SIZE_2 * 6, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 270
+X3_0 + BALLOON_SIZE_2 * 8, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 260
+X3_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 300
+X3_100 - BALLOON_SIZE_2 * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 290
+X3_100 - BALLOON_SIZE_2 * 4, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 280
+X3_100 - BALLOON_SIZE_2 * 6, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 270
+X3_100 - BALLOON_SIZE_2 * 8, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 260
+
+formation: 23
+# Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simétricos
+X3_0, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 300
+X3_0 + BALLOON_SIZE_2 + 1, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 290
+X3_0 + (BALLOON_SIZE_2 + 1) * 2, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 280
+X3_0 + (BALLOON_SIZE_2 + 1) * 3, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 270
+X3_0 + (BALLOON_SIZE_2 + 1) * 4, Y_BASE, VEL_POSITIVE, BALLOON, SIZE3, 260
+X3_100, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 300
+X3_100 - BALLOON_SIZE_2 - 1, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 290
+X3_100 - (BALLOON_SIZE_2 + 1) * 2, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 280
+X3_100 - (BALLOON_SIZE_2 + 1) * 3, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 270
+X3_100 - (BALLOON_SIZE_2 + 1) * 4, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE3, 260
+
+formation: 24
+# Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simétricos
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 300
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 305
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 310
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 315
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 320
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 325
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 330
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 335
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 340
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 345
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 350
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 355
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 300
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 305
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 310
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 315
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 320
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 325
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 330
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 335
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 340
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 345
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 350
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 355
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 360
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 360
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 365
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 365
+X1_50, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 370
+X1_50, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 370
+
+formation: 25
+# Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simétricos
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 300
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 295
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 290
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 285
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 280
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 275
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 270
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 265
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 260
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 255
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 250
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 245
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 300
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 295
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 290
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 285
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 280
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 275
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 270
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 265
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 260
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 255
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 250
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 245
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 240
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 240
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 235
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 235
+X1_50 + 20, Y_BASE, VEL_NEGATIVE, BALLOON, SIZE1, 230
+X1_50 - 20, Y_BASE, VEL_POSITIVE, BALLOON, SIZE1, 230

linux_utils/run_iwyu.sh

@@ -16,5 +16,11 @@ cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -S "$BASE_DIR" -B "$BUILD_DIR"
 # 🛠️ Ejecutar IWYU con fix_includes.py
 echo "🚀 Ejecutando IWYU..."
 iwyu_tool.py -p "$BUILD_DIR" -- -Xiwyu --mapping_file="$MAPPING_FILE" -Xiwyu --verbose=3 \
-| python3 /usr/bin/fix_includes.py --update_comments --reorder --nosafe_headers --dry_run
+| python3 /usr/bin/fix_includes.py --update_comments --reorder --nosafe_headers
 
+# 🧹 Reemplazar // for por // Para en líneas de #include
+echo "✍️ Corrigiendo comentarios en includes..."
+find "$BASE_DIR" -type f \( -name "*.cpp" -o -name "*.h" \) -exec \
+sed -i '/^#include .*\/\/ for/s/\/\/ for/\/\/ Para/' {} +
+
+echo "✅ Script completado."

linux_utils/run_iwyu_dry_run.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# 🏁 Ruta base del proyecto
+BASE_DIR="/home/sergio/gitea/coffee_crisis_arcade_edition"
+
+# 📁 Ruta al build
+BUILD_DIR="$BASE_DIR/build"
+
+# 📄 Archivo de mapping personalizado
+MAPPING_FILE="$BASE_DIR/linux_utils/sdl3_mapping.imp"
+
+# 📦 Generar compile_commands.json
+echo "🔧 Generando compile_commands.json..."
+cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -S "$BASE_DIR" -B "$BUILD_DIR"
+
+# 🛠️ Ejecutar IWYU con fix_includes.py
+echo "🚀 Ejecutando IWYU..."
+iwyu_tool.py -p "$BUILD_DIR" -- -Xiwyu --mapping_file="$MAPPING_FILE" -Xiwyu --verbose=3 \
+| python3 /usr/bin/fix_includes.py --update_comments --reorder --nosafe_headers --dry_run
+
+# 🧹 Reemplazar // for por // Para en líneas de #include
+echo "✍️ Corrigiendo comentarios en includes..."
+find "$BASE_DIR" -type f \( -name "*.cpp" -o -name "*.h" \) -exec \
+sed -i '/^#include .*\/\/ for/s/\/\/ for/\/\/ Para/' {} +
+
+echo "✅ Script completado."

source/asset.cpp

@@ -1,10 +1,12 @@
 #include "asset.h"
 
-#include <SDL3/SDL.h>  // Para SDL_LogInfo, SDL_LogCategory, SDL_LogError
+#include <SDL3/SDL.h>  // Para SDL_LogInfo, SDL_LogCategory, SDL_LogError, SDL_LogWarn
 
-#include <algorithm>  // Para find_if, max
+#include <algorithm>   // Para max
 #include <fstream>     // Para basic_ifstream, ifstream
-#include <string>     // Para allocator, string, char_traits, operator+
+#include <functional>  // Para identity
+#include <ranges>      // Para __find_if_fn, find_if
+#include <string>      // Para allocator, string, operator==, operator+, char_traits, basic_string
 
 #include "utils.h"  // Para getFileName
 

source/background.cpp

@@ -1,11 +1,10 @@
 #define _USE_MATH_DEFINES
 #include "background.h"
 
-#include <SDL3/SDL.h>  // Para SDL_SetRenderTarget, SDL_FRect, SDL_Creat...
+#include <SDL3/SDL.h>  // Para SDL_FRect, SDL_SetRenderTarget, SDL_CreateTexture, SDL_DestroyTexture, SDL_GetRenderTarget, SDL_RenderTexture, SDL_SetTextureAlphaMod, SDL_SetTextureBlendMode, SDL_BLENDMODE_BLEND, SDL_PixelFormat, SDL_RenderClear, SDL_SetRenderDrawColor, SDL_TextureAccess, SDL_FPoint
 
 #include <algorithm>  // Para clamp, max
-#include <cmath>      // Para cos, sin, M_PI
+#include <cmath>      // Para M_PI, cos, sin
-#include <string>     // Para basic_string
 
 #include "moving_sprite.h"  // Para MovingSprite
 #include "param.h"          // Para Param, ParamBackground, param

source/balloon_formations.cpp

@@ -1,333 +1,256 @@
+#include "asset.h"
+#include "balloon.h"  // Para BalloonType, BalloonSize, BALLOON_SIZE, BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
 #include "balloon_formations.h"
-
+#include "param.h"  // Para Param, ParamGame, param
-#include "balloon.h"  // Para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
+#include "utils.h"  // Para Zone, BLOCK
-#include "param.h"    // Para param
+#include <array>    // Para array
-#include "utils.h"    // Para ParamGame, Param, Zone, BLOCK
+#include <fstream>
+#include <map>
+#include <sstream>
+#include <string>
 
 void BalloonFormations::initBalloonFormations() {
-    constexpr int Y4 = -BLOCK;
+    // Calcular posiciones base
+    constexpr int Y_BASE = -BLOCK;
+
     const int X4_0 = param.game.play_area.rect.x;
     const int X4_100 = param.game.play_area.rect.w - BALLOON_SIZE[3];
-
-    constexpr int Y3 = -BLOCK;
     const int X3_0 = param.game.play_area.rect.x;
     const int X3_100 = param.game.play_area.rect.w - BALLOON_SIZE[2];
-
-    constexpr int Y2 = -BLOCK;
     const int X2_0 = param.game.play_area.rect.x;
     const int X2_100 = param.game.play_area.rect.w - BALLOON_SIZE[1];
-
-    constexpr int Y1 = -BLOCK;
     const int X1_0 = param.game.play_area.rect.x;
     const int X1_50 = param.game.play_area.center_x - (BALLOON_SIZE[0] / 2);
     const int X1_100 = param.game.play_area.rect.w - BALLOON_SIZE[0];
 
+    // Variables calculadas para posiciones especiales
+    const int QUARTER1_X4 = param.game.play_area.first_quarter_x - (BALLOON_SIZE[3] / 2);
+    const int QUARTER3_X4 = param.game.play_area.third_quarter_x - (BALLOON_SIZE[3] / 2);
+
+    // Mapa de variables para reemplazar en el archivo
+    std::map<std::string, int> variables = {
+        {"X1_0", X1_0},
+        {"X1_50", X1_50},
+        {"X1_100", X1_100},
+        {"X2_0", X2_0},
+        {"X2_100", X2_100},
+        {"X3_0", X3_0},
+        {"X3_100", X3_100},
+        {"X4_0", X4_0},
+        {"X4_100", X4_100},
+        {"QUARTER1_X4", QUARTER1_X4},
+        {"QUARTER3_X4", QUARTER3_X4},
+        {"Y_BASE", Y_BASE},
+        {"BALLOON_SIZE_0", BALLOON_SIZE[0]},
+        {"BALLOON_SIZE_1", BALLOON_SIZE[1]},
+        {"BALLOON_SIZE_2", BALLOON_SIZE[2]},
+        {"BALLOON_SIZE_3", BALLOON_SIZE[3]},
+        {"VEL_POSITIVE", BALLOON_VELX_POSITIVE},
+        {"VEL_NEGATIVE", BALLOON_VELX_NEGATIVE}};
+
     balloon_formation_.reserve(NUMBER_OF_BALLOON_FORMATIONS);
 
-    constexpr int CREATION_TIME = 300;
+    if (!loadFormationsFromFile(Asset::get()->get("balloon_formations.txt"), variables)) {
-
+        // Fallback: cargar formaciones por defecto si falla la carga del archivo
-    // #00 - Dos enemigos BALLOON4 uno a cada extremo
+        loadDefaultFormations();
-    {
+    }
-        std::vector<BalloonFormationParams> init_params = {
-            BalloonFormationParams(X4_0, Y4, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME),
-            BalloonFormationParams(X4_100, Y4, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME)};
-        balloon_formation_.emplace_back(2, init_params);
 }
 
-    // #01 - Dos enemigos BALLOON4 uno a cada cuarto. Ambos van hacia el centro
+auto BalloonFormations::loadFormationsFromFile(const std::string& filename, const std::map<std::string, int>& variables) -> bool {
-    {
+    std::ifstream file(filename);
-        std::vector<BalloonFormationParams> init_params = {
+    if (!file.is_open()) {
-            BalloonFormationParams(param.game.play_area.first_quarter_x - (BALLOON_SIZE[3] / 2), Y4, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME),
+        return false;
-            BalloonFormationParams(param.game.play_area.third_quarter_x - (BALLOON_SIZE[3] / 2), Y4, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME)};
-        balloon_formation_.emplace_back(2, init_params);
     }
 
-    // #02 - Cuatro enemigos BALLOON2 uno detrás del otro. A la izquierda y hacia el centro
+    std::string line;
-    {
+    int current_formation = -1;
-        std::vector<BalloonFormationParams> init_params;
+    std::vector<BalloonFormationParams> current_params;
-        for (int i = 0; i < 4; ++i) {
+
-            init_params.emplace_back(X2_0 + (i * (BALLOON_SIZE[1] + 1)), Y2, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (10 * i));
+    while (std::getline(file, line)) {
-        }
+        // Eliminar espacios en blanco al inicio y final
-        balloon_formation_.emplace_back(4, init_params);
+        line = trim(line);
+
+        // Saltar líneas vacías y comentarios
+        if (line.empty() || line[0] == '#') {
+            continue;
         }
 
-    // #03 - Cuatro enemigos BALLOON2 uno detrás del otro. A la derecha y hacia el centro
+        // Verificar si es una nueva formación
-    {
+        if (line.substr(0, 10) == "formation:") {
-        std::vector<BalloonFormationParams> init_params;
+            // Guardar formación anterior si existe
-        for (int i = 0; i < 4; ++i) {
+            if (current_formation >= 0 && !current_params.empty()) {
-            init_params.emplace_back(X2_100 - (i * (BALLOON_SIZE[1] + 1)), Y2, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (10 * i));
+                balloon_formation_.emplace_back(current_params.size(), current_params);
-        }
-        balloon_formation_.emplace_back(4, init_params);
             }
 
-    // #04 - Tres enemigos BALLOON3. 0, 25, 50. Hacia la derecha
+            // Iniciar nueva formación
-    {
+            current_formation = std::stoi(line.substr(10));
-        std::vector<BalloonFormationParams> init_params;
+            current_params.clear();
-        for (int i = 0; i < 3; ++i) {
+            continue;
-            init_params.emplace_back(X3_0 + (i * (BALLOON_SIZE[2] * 2)), Y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
-        }
-        balloon_formation_.emplace_back(3, init_params);
         }
 
-    // #05 - Tres enemigos BALLOON3. 50, 75, 100. Hacia la izquierda
+        // Procesar línea de parámetros de balloon
-    {
+        if (current_formation >= 0) {
-        std::vector<BalloonFormationParams> init_params;
+            auto params = parseBalloonLine(line, variables);
-        for (int i = 0; i < 3; ++i) {
+            if (params.has_value()) {
-            init_params.emplace_back(X3_100 - (i * (BALLOON_SIZE[2] * 2)), Y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+                current_params.push_back(params.value());
+            }
         }
-        balloon_formation_.emplace_back(3, init_params);
     }
 
-    // #06 - Tres enemigos BALLOON3. 0, 0, 0. Hacia la derecha
+    // Guardar última formación
-    {
+    if (current_formation >= 0 && !current_params.empty()) {
-        std::vector<BalloonFormationParams> init_params;
+        balloon_formation_.emplace_back(current_params.size(), current_params);
-        for (int i = 0; i < 3; ++i) {
-            init_params.emplace_back(X3_0 + (i * (BALLOON_SIZE[2] + 1)), Y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
-        }
-        balloon_formation_.emplace_back(3, init_params);
     }
 
-    // #07 - Tres enemigos BALLOON3. 100, 100, 100. Hacia la izquierda
+    // Crear variantes flotantes (formaciones 50-99)
-    {
+    createFloaterVariants();
-        std::vector<BalloonFormationParams> init_params;
+
-        for (int i = 0; i < 3; ++i) {
+    // Añadir formación de prueba
-            init_params.emplace_back(X3_100 - (i * (BALLOON_SIZE[2] + 1)), Y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
+    addTestFormation();
-        }
+
-        balloon_formation_.emplace_back(3, init_params);
+    file.close();
+    return true;
 }
 
-    // #08 - Seis enemigos BALLOON1. 0, 0, 0, 0, 0, 0. Hacia la derecha
+auto BalloonFormations::parseBalloonLine(const std::string& line, const std::map<std::string, int>& variables) -> std::optional<BalloonFormationParams> {
-    {
+    std::istringstream iss(line);
-        std::vector<BalloonFormationParams> init_params;
+    std::string token;
-        for (int i = 0; i < 6; ++i) {
+    std::vector<std::string> tokens;
-            init_params.emplace_back(X1_0 + (i * (BALLOON_SIZE[0] + 1)), Y1, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (10 * i));
+
-        }
+    // Dividir por comas
-        balloon_formation_.emplace_back(6, init_params);
+    while (std::getline(iss, token, ',')) {
+        tokens.push_back(trim(token));
     }
 
-    // #09 - Seis enemigos BALLOON1. 100, 100, 100, 100, 100, 100. Hacia la izquierda
+    if (tokens.size() != 6) {
-    {
+        return std::nullopt;
-        std::vector<BalloonFormationParams> init_params;
-        for (int i = 0; i < 6; ++i) {
-            init_params.emplace_back(X1_100 - (i * (BALLOON_SIZE[0] + 1)), Y1, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (10 * i));
-        }
-        balloon_formation_.emplace_back(6, init_params);
     }
 
-    // #10 - Tres enemigos BALLOON4 seguidos desde la izquierda. Hacia la derecha
+    try {
-    {
+        int x = evaluateExpression(tokens[0], variables);
-        std::vector<BalloonFormationParams> init_params;
+        int y = evaluateExpression(tokens[1], variables);
-        for (int i = 0; i < 3; ++i) {
+        int vel_x = evaluateExpression(tokens[2], variables);
-            init_params.emplace_back(X4_0 + (i * (BALLOON_SIZE[3] + 1)), Y4, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME - (15 * i));
-        }
-        balloon_formation_.emplace_back(3, init_params);
-    }
 
-    // #11 - Tres enemigos BALLOON4 seguidos desde la derecha. Hacia la izquierda
+        BalloonType type = (tokens[3] == "BALLOON") ? BalloonType::BALLOON : BalloonType::FLOATER;
-    {
-        std::vector<BalloonFormationParams> init_params;
-        for (int i = 0; i < 3; ++i) {
-            init_params.emplace_back(X4_100 - (i * (BALLOON_SIZE[3] + 1)), Y4, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME - (15 * i));
-        }
-        balloon_formation_.emplace_back(3, init_params);
-    }
 
-    // #12 - Seis enemigos BALLOON2 uno detrás del otro. A la izquierda y hacia el centro
+        BalloonSize size;
-    {
+        if (tokens[4] == "SIZE1") {
-        std::vector<BalloonFormationParams> init_params;
+            size = BalloonSize::SIZE1;
-        for (int i = 0; i < 6; ++i) {
+        } else if (tokens[4] == "SIZE2") {
-            init_params.emplace_back(X2_0 + (i * (BALLOON_SIZE[1] + 1)), Y2, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (10 * i));
+            size = BalloonSize::SIZE2;
-        }
+        } else if (tokens[4] == "SIZE3") {
-        balloon_formation_.emplace_back(6, init_params);
+            size = BalloonSize::SIZE3;
-    }
+        } else if (tokens[4] == "SIZE4") {
-
+            size = BalloonSize::SIZE4;
-    // #13 - Seis enemigos BALLOON2 uno detrás del otro. A la derecha y hacia el centro
-    {
-        std::vector<BalloonFormationParams> init_params;
-        for (int i = 0; i < 6; ++i) {
-            init_params.emplace_back(X2_100 - (i * (BALLOON_SIZE[1] + 1)), Y2, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (10 * i));
-        }
-        balloon_formation_.emplace_back(6, init_params);
-    }
-
-    // #14 - Cinco enemigos BALLOON3. Hacia la derecha. Separados
-    {
-        std::vector<BalloonFormationParams> init_params;
-        for (int i = 0; i < 5; ++i) {
-            init_params.emplace_back(X3_0 + (i * (BALLOON_SIZE[2] * 2)), Y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
-        }
-        balloon_formation_.emplace_back(5, init_params);
-    }
-
-    // #15 - Cinco enemigos BALLOON3. Hacia la izquierda. Separados
-    {
-        std::vector<BalloonFormationParams> init_params;
-        for (int i = 0; i < 5; ++i) {
-            init_params.emplace_back(X3_100 - (i * (BALLOON_SIZE[2] * 2)), Y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
-        }
-        balloon_formation_.emplace_back(5, init_params);
-    }
-
-    // #16 - Cinco enemigos BALLOON3. Hacia la derecha. Juntos
-    {
-        std::vector<BalloonFormationParams> init_params;
-        for (int i = 0; i < 5; ++i) {
-            init_params.emplace_back(X3_0 + (i * (BALLOON_SIZE[2] + 1)), Y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
-        }
-        balloon_formation_.emplace_back(5, init_params);
-    }
-
-    // #17 - Cinco enemigos BALLOON3. Hacia la izquierda. Juntos
-    {
-        std::vector<BalloonFormationParams> init_params;
-        for (int i = 0; i < 5; ++i) {
-            init_params.emplace_back(X3_100 - (i * (BALLOON_SIZE[2] + 1)), Y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
-        }
-        balloon_formation_.emplace_back(5, init_params);
-    }
-
-    // #18 - Doce enemigos BALLOON1. Hacia la derecha. Juntos
-    {
-        std::vector<BalloonFormationParams> init_params;
-        for (int i = 0; i < 12; ++i) {
-            init_params.emplace_back(X1_0 + (i * (BALLOON_SIZE[0] + 1)), Y1, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (10 * i));
-        }
-        balloon_formation_.emplace_back(12, init_params);
-    }
-
-    // #19 - Doce enemigos BALLOON1. Hacia la izquierda. Juntos
-    {
-        std::vector<BalloonFormationParams> init_params;
-        for (int i = 0; i < 12; ++i) {
-            init_params.emplace_back(X1_100 - (i * (BALLOON_SIZE[0] + 1)), Y1, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (10 * i));
-        }
-        balloon_formation_.emplace_back(12, init_params);
-    }
-
-    // #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simétricos
-    {
-        std::vector<BalloonFormationParams> init_params;
-        const int HALF = 4 / 2;
-        for (int i = 0; i < 4; ++i) {
-            if (i < HALF) {
-                init_params.emplace_back(X4_0 + (i * (BALLOON_SIZE[3] + 1)), Y4, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME + (0 * i));
         } else {
-                init_params.emplace_back(X4_100 - ((i - HALF) * (BALLOON_SIZE[3] + 1)), Y4, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME + (0 * i));
+            return std::nullopt;
-            }
-        }
-        balloon_formation_.emplace_back(4, init_params);
         }
 
-    // #20 - Dos enemigos BALLOON4 seguidos desde la izquierda/derecha. Simétricos
+        int creation_time = evaluateExpression(tokens[5], variables);
-    {
+
-        std::vector<BalloonFormationParams> init_params;
+        return BalloonFormationParams(x, y, vel_x, type, size, creation_time);
-        const int HALF = 4 / 2;
+    } catch (const std::exception&) {
-        for (int i = 0; i < 4; ++i) {
+        return std::nullopt;
-            if (i < HALF) {
-                init_params.emplace_back(X4_0 + (i * (BALLOON_SIZE[3] + 1)), Y4, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME + (0 * i));
-            } else {
-                init_params.emplace_back(X4_100 - ((i - HALF) * (BALLOON_SIZE[3] + 1)), Y4, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME + (0 * i));
     }
 }
-        balloon_formation_.emplace_back(4, init_params);
-    }
 
-    // #21 - Diez enemigos BALLOON2 uno detrás del otro. Izquierda/derecha. Simétricos
+auto BalloonFormations::evaluateExpression(const std::string& expr, const std::map<std::string, int>& variables) -> int {
-    {
+    std::string trimmed_expr = trim(expr);
-        std::vector<BalloonFormationParams> init_params;
+
-        const int HALF = 10 / 2;
+    // Si es un número directo
-        for (int i = 0; i < 10; ++i) {
+    if ((std::isdigit(trimmed_expr[0]) != 0) || (trimmed_expr[0] == '-' && trimmed_expr.length() > 1)) {
-            if (i < HALF) {
+        return std::stoi(trimmed_expr);
-                init_params.emplace_back(X2_0 + (i * (BALLOON_SIZE[1] + 1)), Y2, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (3 * i));
-            } else {
-                init_params.emplace_back(X2_100 - ((i - HALF) * (BALLOON_SIZE[1] + 1)), Y2, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE2, CREATION_TIME - (3 * (i - HALF)));
-            }
-        }
-        balloon_formation_.emplace_back(10, init_params);
     }
 
-    // #22 - Diez enemigos BALLOON3. Hacia la derecha/izquierda. Separados. Simétricos
+    // Si es una variable simple
-    {
+    if (variables.find(trimmed_expr) != variables.end()) {
-        std::vector<BalloonFormationParams> init_params;
+        return variables.at(trimmed_expr);
-        const int HALF = 10 / 2;
-        for (int i = 0; i < 10; ++i) {
-            if (i < HALF) {
-                init_params.emplace_back(X3_0 + (i * (BALLOON_SIZE[2] * 2)), Y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
-            } else {
-                init_params.emplace_back(X3_100 - ((i - HALF) * (BALLOON_SIZE[2] * 2)), Y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * (i - HALF)));
-            }
-        }
-        balloon_formation_.emplace_back(10, init_params);
     }
 
-    // #23 - Diez enemigos BALLOON3. Hacia la derecha. Juntos. Simétricos
+    // Evaluación de expresiones simples (suma, resta, multiplicación)
-    {
+    return evaluateSimpleExpression(trimmed_expr, variables);
-        std::vector<BalloonFormationParams> init_params;
-        const int HALF = 10 / 2;
-        for (int i = 0; i < 10; ++i) {
-            if (i < HALF) {
-                init_params.emplace_back(X3_0 + (i * (BALLOON_SIZE[2] + 1)), Y3, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * i));
-            } else {
-                init_params.emplace_back(X3_100 - ((i - HALF) * (BALLOON_SIZE[2] + 1)), Y3, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE3, CREATION_TIME - (10 * (i - HALF)));
-            }
-        }
-        balloon_formation_.emplace_back(10, init_params);
 }
 
-    // #24 - Treinta enemigos BALLOON1. Del centro hacia los extremos. Juntos. Simétricos
+auto BalloonFormations::evaluateSimpleExpression(const std::string& expr, const std::map<std::string, int>& variables) -> int {
-    {
+    // Buscar operadores (+, -, *, /)
-        std::vector<BalloonFormationParams> init_params;
+    for (size_t i = 1; i < expr.length(); ++i) {
-        const int HALF = 30 / 2;
+        char op = expr[i];
-        for (int i = 0; i < 30; ++i) {
+        if (op == '+' || op == '-' || op == '*' || op == '/') {
-            if (i < HALF) {
+            std::string left = trim(expr.substr(0, i));
-                init_params.emplace_back(X1_50, Y1, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME + (5 * i));
+            std::string right = trim(expr.substr(i + 1));
-            } else {
+
-                init_params.emplace_back(X1_50, Y1, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME + (5 * (i - HALF)));
+            int left_val = evaluateExpression(left, variables);
+            int right_val = evaluateExpression(right, variables);
+
+            switch (op) {
+                case '+':
+                    return left_val + right_val;
+                case '-':
+                    return left_val - right_val;
+                case '*':
+                    return left_val * right_val;
+                case '/':
+                    return right_val != 0 ? left_val / right_val : 0;
             }
         }
-        balloon_formation_.emplace_back(30, init_params);
     }
 
-    // #25 - Treinta enemigos BALLOON1. Del centro hacia adentro. Juntos. Simétricos
+    // Si no se encuentra operador, intentar como variable o número
-    {
+    return variables.find(expr) != variables.end() ? variables.at(expr) : std::stoi(expr);
-        std::vector<BalloonFormationParams> init_params;
-        const int HALF = 30 / 2;
-        for (int i = 0; i < 30; ++i) {
-            if (i < HALF) {
-                init_params.emplace_back(X1_50 + 20, Y1, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (5 * i));
-            } else {
-                init_params.emplace_back(X1_50 - 20, Y1, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE1, CREATION_TIME - (5 * (i - HALF)));
-            }
-        }
-        balloon_formation_.emplace_back(30, init_params);
 }
 
-    // Reservar espacio para el vector
+auto BalloonFormations::trim(const std::string& str) -> std::string {
+    size_t start = str.find_first_not_of(" \t\r\n");
+    if (start == std::string::npos) {
+        return "";
+    }
+    size_t end = str.find_last_not_of(" \t\r\n");
+    return str.substr(start, end - start + 1);
+}
+
+void BalloonFormations::createFloaterVariants() {
     balloon_formation_.resize(100);
 
-    // Crea las mismas formaciones pero con hexágonos a partir de la posición 50 del vector
+    // Crear variantes flotantes de las primeras 50 formaciones
-    for (int k = 0; k < 50; k++) {
+    for (size_t k = 0; k < 50 && k < balloon_formation_.size(); k++) {
-        std::vector<BalloonFormationParams> init_params;
+        std::vector<BalloonFormationParams> floater_params;
-        for (int i = 0; i < balloon_formation_.at(k).number_of_balloons; i++) {
+        floater_params.reserve(balloon_formation_[k].number_of_balloons);
-            init_params.emplace_back(
+
-                balloon_formation_.at(k).init.at(i).x,
+        for (int i = 0; i < balloon_formation_[k].number_of_balloons; i++) {
-                balloon_formation_.at(k).init.at(i).y,
+            const auto& original = balloon_formation_[k].init[i];
-                balloon_formation_.at(k).init.at(i).vel_x,
+            floater_params.emplace_back(
-                BalloonType::FLOATER,
+                original.x, original.y, original.vel_x, BalloonType::FLOATER, original.size, original.creation_counter);
-                balloon_formation_.at(k).init.at(i).size,
-                balloon_formation_.at(k).init.at(i).creation_counter);
-        }
-        balloon_formation_.at(k + 50) = BalloonFormationUnit(balloon_formation_.at(k).number_of_balloons, init_params);
         }
 
-    // TEST
+        balloon_formation_[k + 50] = BalloonFormationUnit(
+            balloon_formation_[k].number_of_balloons, floater_params);
+    }
+}
+
+void BalloonFormations::addTestFormation() {
     std::vector<BalloonFormationParams> test_params = {
-        {10, Y1, 0, BalloonType::FLOATER, BalloonSize::SIZE1, 200},
+        {10, -BLOCK, 0, BalloonType::FLOATER, BalloonSize::SIZE1, 200},
-        {50, Y1, 0, BalloonType::FLOATER, BalloonSize::SIZE2, 200},
+        {50, -BLOCK, 0, BalloonType::FLOATER, BalloonSize::SIZE2, 200},
-        {90, Y1, 0, BalloonType::FLOATER, BalloonSize::SIZE3, 200},
+        {90, -BLOCK, 0, BalloonType::FLOATER, BalloonSize::SIZE3, 200},
-        {140, Y1, 0, BalloonType::FLOATER, BalloonSize::SIZE4, 200}};
+        {140, -BLOCK, 0, BalloonType::FLOATER, BalloonSize::SIZE4, 200}};
 
-    balloon_formation_.at(99) = BalloonFormationUnit(4, test_params);
+    balloon_formation_[99] = BalloonFormationUnit(4, test_params);
+}
+
+void BalloonFormations::loadDefaultFormations() {
+    // Código de fallback con algunas formaciones básicas hardcodeadas
+    // para que el juego funcione aunque falle la carga del archivo
+
+    const int Y_BASE = -BLOCK;
+    const int X4_0 = param.game.play_area.rect.x;
+    const int X4_100 = param.game.play_area.rect.w - BALLOON_SIZE[3];
+    constexpr int CREATION_TIME = 300;
+
+    // Formación básica #00
+    std::vector<BalloonFormationParams> basic_formation = {
+        BalloonFormationParams(X4_0, Y_BASE, BALLOON_VELX_POSITIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME),
+        BalloonFormationParams(X4_100, Y_BASE, BALLOON_VELX_NEGATIVE, BalloonType::BALLOON, BalloonSize::SIZE4, CREATION_TIME)};
+    balloon_formation_.emplace_back(2, basic_formation);
 }
 
 // Inicializa los conjuntos de formaciones
@@ -337,41 +260,131 @@ void BalloonFormations::initBalloonFormationPools() {
 
     // Set #0
     balloon_formation_pool_.at(0) = {
-        &balloon_formation_.at(0), &balloon_formation_.at(1), &balloon_formation_.at(2), &balloon_formation_.at(3), &balloon_formation_.at(4), &balloon_formation_.at(5), &balloon_formation_.at(6), &balloon_formation_.at(7), &balloon_formation_.at(8), &balloon_formation_.at(9)};
+        &balloon_formation_.at(0),
+        &balloon_formation_.at(1),
+        &balloon_formation_.at(2),
+        &balloon_formation_.at(3),
+        &balloon_formation_.at(4),
+        &balloon_formation_.at(5),
+        &balloon_formation_.at(6),
+        &balloon_formation_.at(7),
+        &balloon_formation_.at(8),
+        &balloon_formation_.at(9)};
 
     // Set #1
     balloon_formation_pool_.at(1) = {
-        &balloon_formation_.at(10), &balloon_formation_.at(11), &balloon_formation_.at(12), &balloon_formation_.at(13), &balloon_formation_.at(14), &balloon_formation_.at(15), &balloon_formation_.at(16), &balloon_formation_.at(17), &balloon_formation_.at(18), &balloon_formation_.at(19)};
+        &balloon_formation_.at(10),
+        &balloon_formation_.at(11),
+        &balloon_formation_.at(12),
+        &balloon_formation_.at(13),
+        &balloon_formation_.at(14),
+        &balloon_formation_.at(15),
+        &balloon_formation_.at(16),
+        &balloon_formation_.at(17),
+        &balloon_formation_.at(18),
+        &balloon_formation_.at(19)};
 
     // Set #2
     balloon_formation_pool_.at(2) = {
-        &balloon_formation_.at(0), &balloon_formation_.at(1), &balloon_formation_.at(2), &balloon_formation_.at(3), &balloon_formation_.at(4), &balloon_formation_.at(55), &balloon_formation_.at(56), &balloon_formation_.at(57), &balloon_formation_.at(58), &balloon_formation_.at(59)};
+        &balloon_formation_.at(0),
+        &balloon_formation_.at(1),
+        &balloon_formation_.at(2),
+        &balloon_formation_.at(3),
+        &balloon_formation_.at(4),
+        &balloon_formation_.at(55),
+        &balloon_formation_.at(56),
+        &balloon_formation_.at(57),
+        &balloon_formation_.at(58),
+        &balloon_formation_.at(59)};
 
     // Set #3
     balloon_formation_pool_.at(3) = {
-        &balloon_formation_.at(50), &balloon_formation_.at(51), &balloon_formation_.at(52), &balloon_formation_.at(53), &balloon_formation_.at(54), &balloon_formation_.at(5), &balloon_formation_.at(6), &balloon_formation_.at(7), &balloon_formation_.at(8), &balloon_formation_.at(9)};
+        &balloon_formation_.at(50),
+        &balloon_formation_.at(51),
+        &balloon_formation_.at(52),
+        &balloon_formation_.at(53),
+        &balloon_formation_.at(54),
+        &balloon_formation_.at(5),
+        &balloon_formation_.at(6),
+        &balloon_formation_.at(7),
+        &balloon_formation_.at(8),
+        &balloon_formation_.at(9)};
 
     // Set #4
     balloon_formation_pool_.at(4) = {
-        &balloon_formation_.at(60), &balloon_formation_.at(61), &balloon_formation_.at(62), &balloon_formation_.at(63), &balloon_formation_.at(64), &balloon_formation_.at(65), &balloon_formation_.at(66), &balloon_formation_.at(67), &balloon_formation_.at(68), &balloon_formation_.at(69)};
+        &balloon_formation_.at(60),
+        &balloon_formation_.at(61),
+        &balloon_formation_.at(62),
+        &balloon_formation_.at(63),
+        &balloon_formation_.at(64),
+        &balloon_formation_.at(65),
+        &balloon_formation_.at(66),
+        &balloon_formation_.at(67),
+        &balloon_formation_.at(68),
+        &balloon_formation_.at(69)};
 
     // Set #5
     balloon_formation_pool_.at(5) = {
-        &balloon_formation_.at(10), &balloon_formation_.at(61), &balloon_formation_.at(12), &balloon_formation_.at(63), &balloon_formation_.at(14), &balloon_formation_.at(65), &balloon_formation_.at(16), &balloon_formation_.at(67), &balloon_formation_.at(18), &balloon_formation_.at(69)};
+        &balloon_formation_.at(10),
+        &balloon_formation_.at(61),
+        &balloon_formation_.at(12),
+        &balloon_formation_.at(63),
+        &balloon_formation_.at(14),
+        &balloon_formation_.at(65),
+        &balloon_formation_.at(16),
+        &balloon_formation_.at(67),
+        &balloon_formation_.at(18),
+        &balloon_formation_.at(69)};
 
     // Set #6
     balloon_formation_pool_.at(6) = {
-        &balloon_formation_.at(60), &balloon_formation_.at(11), &balloon_formation_.at(62), &balloon_formation_.at(13), &balloon_formation_.at(64), &balloon_formation_.at(15), &balloon_formation_.at(66), &balloon_formation_.at(17), &balloon_formation_.at(68), &balloon_formation_.at(19)};
+        &balloon_formation_.at(60),
+        &balloon_formation_.at(11),
+        &balloon_formation_.at(62),
+        &balloon_formation_.at(13),
+        &balloon_formation_.at(64),
+        &balloon_formation_.at(15),
+        &balloon_formation_.at(66),
+        &balloon_formation_.at(17),
+        &balloon_formation_.at(68),
+        &balloon_formation_.at(19)};
 
     // Set #7
     balloon_formation_pool_.at(7) = {
-        &balloon_formation_.at(20), &balloon_formation_.at(21), &balloon_formation_.at(22), &balloon_formation_.at(23), &balloon_formation_.at(24), &balloon_formation_.at(65), &balloon_formation_.at(66), &balloon_formation_.at(67), &balloon_formation_.at(68), &balloon_formation_.at(69)};
+        &balloon_formation_.at(20),
+        &balloon_formation_.at(21),
+        &balloon_formation_.at(22),
+        &balloon_formation_.at(23),
+        &balloon_formation_.at(24),
+        &balloon_formation_.at(65),
+        &balloon_formation_.at(66),
+        &balloon_formation_.at(67),
+        &balloon_formation_.at(68),
+        &balloon_formation_.at(69)};
 
     // Set #8
     balloon_formation_pool_.at(8) = {
-        &balloon_formation_.at(70), &balloon_formation_.at(71), &balloon_formation_.at(72), &balloon_formation_.at(73), &balloon_formation_.at(74), &balloon_formation_.at(15), &balloon_formation_.at(16), &balloon_formation_.at(17), &balloon_formation_.at(18), &balloon_formation_.at(19)};
+        &balloon_formation_.at(70),
+        &balloon_formation_.at(71),
+        &balloon_formation_.at(72),
+        &balloon_formation_.at(73),
+        &balloon_formation_.at(74),
+        &balloon_formation_.at(15),
+        &balloon_formation_.at(16),
+        &balloon_formation_.at(17),
+        &balloon_formation_.at(18),
+        &balloon_formation_.at(19)};
 
     // Set #9
     balloon_formation_pool_.at(9) = {
-        &balloon_formation_.at(20), &balloon_formation_.at(21), &balloon_formation_.at(22), &balloon_formation_.at(23), &balloon_formation_.at(24), &balloon_formation_.at(70), &balloon_formation_.at(71), &balloon_formation_.at(72), &balloon_formation_.at(73), &balloon_formation_.at(74)};
+        &balloon_formation_.at(20),
+        &balloon_formation_.at(21),
+        &balloon_formation_.at(22),
+        &balloon_formation_.at(23),
+        &balloon_formation_.at(24),
+        &balloon_formation_.at(70),
+        &balloon_formation_.at(71),
+        &balloon_formation_.at(72),
+        &balloon_formation_.at(73),
+        &balloon_formation_.at(74)};
 }

source/balloon_formations.h

@@ -1,8 +1,12 @@
 #pragma once
 
-#include <vector>
-
 #include "balloon.h"  // Para BALLOON_VELX_NEGATIVE, BALLOON_VELX_POSITIVE
+#include <fstream>
+#include <map>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <vector>
 
 // --- Constantes de configuración ---
 constexpr int NUMBER_OF_BALLOON_FORMATIONS = 100;
@@ -62,6 +66,14 @@ class BalloonFormations {
         std::vector<BalloonFormationPool> balloon_formation_pool_;  // Conjuntos de formaciones enemigas
 
         // --- Métodos internos de inicialización ---
-        void initBalloonFormations();
+        void initBalloonFormations();                                                                                                  // Inicializa la lista principal de formaciones de globos disponibles
-        void initBalloonFormationPools();
+        void initBalloonFormationPools();                                                                                              // Prepara las estructuras de agrupamiento o reutilización de formaciones (pools)
+        auto loadFormationsFromFile(const std::string& filename, const std::map<std::string, int>& variables) -> bool;                 // Carga las formaciones desde un archivo, evaluando variables dinámicas
+        auto parseBalloonLine(const std::string& line, const std::map<std::string, int>& variables) -> std::optional<BalloonFormationParams>;  // Parsea una línea individual del archivo y genera parámetros de formación
+        auto evaluateExpression(const std::string& expr, const std::map<std::string, int>& variables) -> int;                                  // Evalúa expresiones matemáticas con variables definidas (complejas)
+        auto evaluateSimpleExpression(const std::string& expr, const std::map<std::string, int>& variables) -> int;                            // Evalúa expresiones más sencillas (sin paréntesis o operadores avanzados)
+        static auto trim(const std::string& str) -> std::string;                                                                               // Elimina espacios en blanco al inicio y fin de una cadena
+        void createFloaterVariants();                                                                                                  // Genera variantes de globos flotantes según configuración o aleatoriedad
+        void addTestFormation();                                                                                                       // Añade una formación de prueba para debug o validación en tiempo de desarrollo
+        void loadDefaultFormations();                                                                                                  // Carga las formaciones por defecto incluidas en el juego si no hay archivo externo
 };

source/balloon_manager.h

@@ -2,11 +2,12 @@
 
 #include <SDL3/SDL.h>  // Para SDL_FRect
 
+#include <array>   // Para array
 #include <memory>  // Para shared_ptr, unique_ptr
 #include <string>  // Para string
 #include <vector>  // Para vector
 
-#include "balloon.h"             // Para BALLOON_SPEED, Balloon
+#include "balloon.h"             // Para BALLOON_SPEED, Balloon, BalloonSize (ptr only), BalloonType (ptr only)
 #include "balloon_formations.h"  // Para BalloonFormations
 #include "explosions.h"          // Para Explosions
 #include "param.h"               // Para Param, ParamGame, param

source/bullet.h

@@ -3,6 +3,7 @@
 #include <SDL3/SDL.h>  // Para Uint8
 
 #include <memory>  // Para unique_ptr
+#include <string>  // Para string
 
 #include "animated_sprite.h"  // Para AnimatedSprite
 #include "utils.h"            // Para Circle

source/define_buttons.cpp

@@ -1,10 +1,11 @@
 #include "define_buttons.h"
 
-#include <ranges>
+#include <algorithm>   // Para max, __all_of_fn, all_of
+#include <functional>  // Para identity
 
 #include "input.h"     // Para Input, InputAction
 #include "lang.h"      // Para getText
-#include "options.h"   // Para OptionsController, Options, options
+#include "options.h"   // Para GamepadOptions, controllers
 #include "param.h"     // Para Param, param, ParamGame, ParamTitle
 #include "resource.h"  // Para Resource
 #include "text.h"      // Para Text

source/director.cpp

@@ -258,6 +258,7 @@ void Director::setFileList() {
     Asset::get()->add(PREFIX + "/data/config/demo1.bin", AssetType::DEMODATA);
     Asset::get()->add(PREFIX + "/data/config/demo2.bin", AssetType::DEMODATA);
     Asset::get()->add(PREFIX + "/data/config/gamecontrollerdb.txt", AssetType::DATA);
+    Asset::get()->add(PREFIX + "/data/config/balloon_formations.txt", AssetType::DATA);
 
     // Musicas
     Asset::get()->add(PREFIX + "/data/music/intro.ogg", AssetType::MUSIC);

source/director.h

@@ -14,7 +14,7 @@ class Director {
         ~Director();
 
         // --- Bucle principal ---
-        auto run() -> int;
+        static auto run() -> int;
 
     private:
         // --- Variables internas ---

source/external/gif.cpp

@@ -1,7 +1,6 @@
 #include "gif.h"
 
 #include <SDL3/SDL.h>  // Para SDL_LogError, SDL_LogCategory, SDL_LogInfo
-
 #include <cstring>    // Para memcpy, size_t
 #include <stdexcept>  // Para runtime_error
 #include <string>     // Para char_traits, operator==, basic_string, string

source/external/jail_shader.cpp

@@ -2,7 +2,6 @@
 
 #include <SDL3/SDL.h>  // Para SDL_GL_GetProcAddress, SDL_LogError
 #include <stdint.h>    // Para uintptr_t
-
 #include <cstring>    // Para strncmp
 #include <stdexcept>  // Para runtime_error
 #include <vector>     // Para vector

source/external/jail_shader.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <SDL3/SDL.h>  // Para SDL_Texture, SDL_Window
-
 #include <string>  // Para basic_string, string
 
 namespace shader {

source/game_logo.cpp

@@ -1,9 +1,8 @@
 #include "game_logo.h"
 
-#include <SDL3/SDL.h>  // Para SDL_SetTextureScaleMode, SDL_FlipMode
+#include <SDL3/SDL.h>  // Para SDL_SetTextureScaleMode, SDL_FlipMode, SDL_ScaleMode
 
 #include <algorithm>  // Para max
-#include <string>     // Para basic_string
 
 #include "animated_sprite.h"  // Para AnimatedSprite
 #include "audio.h"            // Para Audio

source/item.cpp

@@ -192,8 +192,7 @@ auto Item::getCoffeeMachineSpawn(int player_x, int item_width, int area_width, i
     if (can_spawn_right) {
         // Solo lado derecho disponible
         return rand() % (RIGHT_BOUND - exclude_right) + exclude_right;
-    } else {
+    }  // No hay espacio suficiente lejos del jugador
-        // No hay espacio suficiente lejos del jugador
     // Por ahora, intentar spawn en el extremo más lejano posible
     int distance_to_left = abs(player_x - LEFT_BOUND);
     int distance_to_right = abs(RIGHT_BOUND - player_x);
@@ -203,4 +202,3 @@ auto Item::getCoffeeMachineSpawn(int player_x, int item_width, int area_width, i
     }
     return RIGHT_BOUND - item_width;
 }
-}

source/main.cpp

@@ -8,6 +8,7 @@ Actualizando a la versión "Arcade Edition" en 08/05/2024
 */
 
 #include <memory>  // Para make_unique, unique_ptr
+#include <span>    // Para span
 
 #include "director.h"  // Para Director
 

source/notifier.cpp

@@ -58,7 +58,7 @@ void Notifier::update() {
 
 auto Notifier::shouldProcessNotification(int index) const -> bool {
     // Si la notificación anterior está "saliendo", no hagas nada
-    return !(index > 0 && notifications_[index - 1].state == NotificationStatus::RISING);
+    return index <= 0 || notifications_[index - 1].state != NotificationStatus::RISING;
 }
 
 void Notifier::processNotification(int index) {

source/path_sprite.cpp

@@ -1,7 +1,6 @@
 // IWYU pragma: no_include <bits/std_abs.h>
 #include "path_sprite.h"
 
-#include <cmath>       // Para abs
 #include <functional>  // Para function
 #include <utility>     // Para move
 

source/scoreboard.cpp

@@ -1,10 +1,11 @@
 #include "scoreboard.h"
 
-#include <SDL3/SDL.h>  // Para SDL_DestroyTexture, SDL_SetRenderDrawColor
+#include <SDL3/SDL.h>  // Para SDL_DestroyTexture, SDL_SetRenderDrawColor, SDL_SetRenderTarget, SDL_CreateTexture, SDL_GetRenderTarget, SDL_GetTicks, SDL_RenderClear, SDL_RenderLine, SDL_RenderTexture, SDL_SetTextureBlendMode, SDL_FRect, SDL_BLENDMODE_BLEND, SDL_PixelFormat, SDL_Texture, SDL_TextureAccess
 
+#include <algorithm>  // Para max
 #include <cmath>      // Para roundf
 #include <iomanip>    // Para operator<<, setfill, setw
-#include <sstream>  // Para basic_ostringstream, basic_ostream, basic_os...
+#include <sstream>    // Para basic_ostream, basic_ostringstream, basic_ostream::operator<<, ostringstream
 
 #include "enter_name.h"  // Para NAME_SIZE
 #include "lang.h"        // Para getText

source/sections/credits.cpp

@@ -1,14 +1,13 @@
 // IWYU pragma: no_include <bits/std_abs.h>
 #include "credits.h"
 
-#include <SDL3/SDL.h>  // Para SDL_RenderFillRect, SDL_RenderTexture
+#include <SDL3/SDL.h>  // Para SDL_RenderFillRect, SDL_RenderTexture, SDL_SetRenderTarget, SDL_SetRenderDrawColor, SDL_CreateTexture, SDL_DestroyTexture, SDL_GetTicks, SDL_GetRenderTarget, SDL_PixelFormat, SDL_PollEvent, SDL_RenderClear, SDL_RenderRect, SDL_SetTextureBlendMode, SDL_TextureAccess, SDL_BLENDMODE_BLEND, SDL_Event
 
 #include <algorithm>    // Para max, min, clamp
 #include <array>        // Para array
-#include <cmath>      // Para abs
 #include <stdexcept>    // Para runtime_error
 #include <string>       // Para basic_string, string
-#include <string_view>
+#include <string_view>  // Para string_view
 #include <vector>       // Para vector
 
 #include "audio.h"            // Para Audio
@@ -28,7 +27,7 @@
 #include "texture.h"          // Para Texture
 #include "tiled_bg.h"         // Para TiledBG, TiledBGMode
 #include "ui/service_menu.h"  // Para ServiceMenu
-#include "utils.h"            // Para Color, Zone, SHADOW_TEXT_COLOR, NO_TEXT...
+#include "utils.h"            // Para Zone, SHADOW_TEXT_COLOR, NO_TEXT_COLOR, Color
 
 // Textos
 constexpr std::string_view TEXT_COPYRIGHT = "@2020,2025 JailDesigner";

source/sections/game.h

@@ -6,27 +6,24 @@
 #include <string>  // Para string
 #include <vector>  // Para vector
 
+#include "bullet.h"                // Para Bullet, BulletType (ptr only)
+#include "item.h"                  // Para Item, ItemType (ptr only)
 #include "manage_hiscore_table.h"  // Para HiScoreEntry
 #include "options.h"               // Para SettingsOptions, settings, DifficultyCode (ptr only)
+#include "path_sprite.h"           // Para PathSprite, Path
 #include "player.h"                // Para Player
+#include "smart_sprite.h"          // Para SmartSprite
 #include "utils.h"                 // Para Demo
 
 class Background;
 class Balloon;
 class BalloonManager;
-class Bullet;
 class Fade;
 class Input;
-class Item;
-class PathSprite;
 class Scoreboard;
 class Screen;
-class SmartSprite;
 class Tabe;
 class Texture;
-enum class BulletType : Uint8;
-enum class ItemType;
-struct Path;
 
 // Modo demo
 constexpr bool GAME_MODE_DEMO_OFF = false;

source/sections/hiscore_table.h

@@ -6,14 +6,13 @@
 #include <string>  // Para string
 #include <vector>  // Para vector
 
+#include "path_sprite.h"  // Para Path, PathSprite (ptr only)
 #include "utils.h"        // Para Color
 
 class Background;
 class Fade;
-class PathSprite;
 class Sprite;
 enum class FadeMode : Uint8;
-struct Path;
 
 /*
         Esta clase gestiona un estado del programa. Se encarga de mostrar la tabla con las puntuaciones

source/sections/instructions.h

@@ -5,8 +5,9 @@
 #include <memory>  // Para unique_ptr, shared_ptr
 #include <vector>  // Para vector
 
+#include "sprite.h"  // Para Sprite
+
 class Fade;
-class Sprite;
 class Text;
 class Texture;
 class TiledBG;

source/sections/intro.cpp

@@ -1,11 +1,12 @@
 #include "intro.h"
 
-#include <SDL3/SDL.h>  // Para SDL_GetTicks, SDL_SetRenderDrawColor, SDL...
+#include <SDL3/SDL.h>  // Para SDL_GetTicks, SDL_SetRenderDrawColor, SDL_FRect, SDL_RenderFillRect, SDL_GetRenderTarget, SDL_RenderClear, SDL_RenderRect, SDL_SetRenderTarget, SDL_BLENDMODE_BLEND, SDL_PixelFormat, SDL_PollEvent, SDL_RenderTexture, SDL_TextureAccess, SDLK_A, SDLK_C, SDLK_D, SDLK_F, SDLK_S, SDLK_V, SDLK_X, SDLK_Z, SDL_Event, SDL_EventType, Uint32
 
+#include <algorithm>   // Para max
 #include <array>       // Para array
 #include <functional>  // Para function
-#include <iostream>    // Para basic_ostream, basic_ostream::operator<<
+#include <iostream>    // Para basic_ostream, basic_ostream::operator<<, operator<<, cout, endl, hex
-#include <string>      // Para basic_string, char_traits, string
+#include <string>      // Para char_traits, basic_string, string
 #include <utility>     // Para move
 
 #include "audio.h"          // Para Audio
@@ -13,7 +14,7 @@
 #include "global_inputs.h"  // Para check
 #include "input.h"          // Para Input
 #include "lang.h"           // Para getText
-#include "param.h"          // Para Param, param, ParamGame, ParamIntro, Para...
+#include "param.h"          // Para Param, param, ParamGame, ParamIntro, ParamTitle
 #include "path_sprite.h"    // Para PathSprite, PathType
 #include "resource.h"       // Para Resource
 #include "screen.h"         // Para Screen
@@ -21,7 +22,7 @@
 #include "text.h"           // Para Text
 #include "texture.h"        // Para Texture
 #include "tiled_bg.h"       // Para TiledBG, TiledBGMode
-#include "utils.h"          // Para Color, Zone, easeInOutExpo, easeInElastic
+#include "utils.h"          // Para Color, Zone, easeInOutExpo, easeInElastic, easeOutBounce, easeOutElastic, easeOutQuad, easeOutQuint
 #include "writer.h"         // Para Writer
 
 #ifdef DEBUG

source/sections/logo.cpp

@@ -1,8 +1,8 @@
 #include "logo.h"
 
-#include <SDL3/SDL.h>  // Para SDL_GetTicks, SDL_PollEvent, SDL_Event
+#include <SDL3/SDL.h>  // Para SDL_GetTicks, SDL_PollEvent, SDL_Event, SDL_FRect
 
-#include <string>   // Para basic_string
+#include <algorithm>  // Para max
 #include <utility>    // Para move
 
 #include "audio.h"          // Para Audio

source/sections/logo.h

@@ -2,12 +2,13 @@
 
 #include <SDL3/SDL.h>  // Para SDL_FPoint, Uint64
 
-#include <memory>  // Para shared_ptr, unique_ptr
+#include <memory>  // Para unique_ptr, shared_ptr
 #include <vector>  // Para vector
 
-class Sprite;
+#include "sprite.h"  // Para Sprite
+#include "utils.h"   // Para Color
+
 class Texture;
-struct Color;
 
 /*
         Esta clase gestiona un estado del programa. Se encarga de dibujar por pantalla el

source/tabe.cpp

@@ -4,10 +4,8 @@
 #include <SDL3/SDL.h>  // Para SDL_FlipMode, SDL_GetTicks
 
 #include <algorithm>  // Para max
-#include <array>
+#include <array>      // Para array
-#include <cmath>    // Para abs
 #include <cstdlib>    // Para rand, abs
-#include <string>   // Para basic_string
 
 #include "audio.h"     // Para Audio
 #include "param.h"     // Para Param, ParamGame, param

source/tiled_bg.cpp

@@ -1,12 +1,11 @@
 #include "tiled_bg.h"
 
-#include <SDL3/SDL.h>  // Para SDL_SetRenderTarget, SDL_CreateTexture, SDL_De...
+#include <SDL3/SDL.h>  // Para SDL_SetRenderTarget, SDL_CreateTexture, SDL_DestroyTexture, SDL_FRect, SDL_GetRenderTarget, SDL_RenderTexture, SDL_PixelFormat, SDL_TextureAccess
 
 #include <cmath>    // Para sin
 #include <cstdlib>  // Para rand
-#include <memory>   // Para unique_ptr, make_unique
+#include <memory>   // Para allocator, unique_ptr, make_unique
-#include <numbers>
+#include <numbers>  // Para pi
-#include <string>  // Para basic_string
 
 #include "resource.h"  // Para Resource
 #include "screen.h"    // Para Screen

source/ui/menu_renderer.cpp

@@ -1,7 +1,6 @@
 #include "menu_renderer.h"
 
 #include <algorithm>      // Para max
-#include <string>     // Para basic_string
 #include <utility>        // Para pair, move
 
 #include "menu_option.h"  // Para MenuOption

source/ui/menu_renderer.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <SDL3/SDL.h>  // Para SDL_FRect, Uint32
-
 #include <array>
 #include <cstddef>  // Para size_t
 #include <memory>   // Para shared_ptr, unique_ptr

source/ui/service_menu.cpp

@@ -1,10 +1,12 @@
 #include "ui/service_menu.h"
 
+#include <algorithm>        // Para max
+
 #include "audio.h"          // Para Audio
 #include "lang.h"           // Para getText, getCodeFromName, getNameFromCode
-#include "menu_option.h"    // Para MenuOption, BoolOption, ActionOption, Int...
+#include "menu_option.h"    // Para MenuOption, BoolOption, ActionOption, IntOption, FolderOption, ListOption
 #include "menu_renderer.h"  // Para MenuRenderer
-#include "options.h"        // Para PendingChanges, VideoOptions, pending_cha...
+#include "options.h"        // Para PendingChanges, VideoOptions, pending_changes, video, AudioOptions, SettingsOptions, audio, checkPendingChanges, settings, WindowOptions, getDifficultyCodeFromName, getDifficultyNameFromCode, window, MusicOptions, SoundOptions
 #include "param.h"          // Para Param, param, ParamGame, ParamServiceMenu
 #include "resource.h"       // Para Resource
 #include "screen.h"         // Para Screen

source/utils.h

@@ -1,12 +1,13 @@
 #pragma once
 
 #include <SDL3/SDL.h>      // Para Uint8, SDL_FRect, SDL_FPoint, SDL_Renderer
+#include <bits/std_abs.h>  // Para abs
 
 #include <algorithm>  // Para max, min
 #include <array>      // Para array
 #include <cctype>     // Para isxdigit
 #include <cstdint>    // Para int32_t
-#include <cstdlib>    // Para abs, size_t
+#include <cstdlib>    // Para size_t, abs
 #include <stdexcept>  // Para invalid_argument
 #include <string>     // Para string, basic_string, stoi
 #include <vector>     // Para vector