treballant en el overlay, el text i les notificacions

source/core/jail/jail_audio.cpp

@@ -0,0 +1,450 @@
+#ifndef JA_USESDLMIXER
+#include "core/jail/jail_audio.hpp"
+
+#include <SDL3/SDL.h>
+#include <stdio.h>
+
+#include "external/stb_vorbis.h"
+
+#define JA_MAX_SIMULTANEOUS_CHANNELS 5
+
+struct JA_Sound_t {
+    SDL_AudioSpec spec{SDL_AUDIO_S16, 2, 48000};
+    Uint32 length{0};
+    Uint8 *buffer{NULL};
+};
+
+struct JA_Channel_t {
+    JA_Sound_t *sound{nullptr};
+    int pos{0};
+    int times{0};
+    SDL_AudioStream *stream{nullptr};
+    JA_Channel_state state{JA_CHANNEL_FREE};
+};
+
+struct JA_Music_t {
+    SDL_AudioSpec spec{SDL_AUDIO_S16, 2, 48000};
+    Uint32 length{0};
+    Uint8 *buffer{nullptr};
+    char *filename{nullptr};
+
+    int pos{0};
+    int times{0};
+    SDL_AudioStream *stream{nullptr};
+    JA_Music_state state{JA_MUSIC_INVALID};
+};
+
+JA_Music_t *current_music{nullptr};
+JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];
+
+SDL_AudioSpec JA_audioSpec{SDL_AUDIO_S16, 2, 48000};
+float JA_musicVolume{1.0f};
+float JA_soundVolume{0.5f};
+bool JA_musicEnabled{true};
+bool JA_soundEnabled{true};
+SDL_AudioDeviceID sdlAudioDevice{0};
+SDL_TimerID JA_timerID{0};
+
+bool fading = false;
+int fade_start_time;
+int fade_duration;
+int fade_initial_volume;
+
+/*
+void audioCallback(void * userdata, uint8_t * stream, int len) {
+    SDL_memset(stream, 0, len);
+    if (current_music != NULL && current_music->state == JA_MUSIC_PLAYING) {
+        const int size = SDL_min(len, current_music->samples*2-current_music->pos);
+        SDL_MixAudioFormat(stream, (Uint8*)(current_music->output+current_music->pos), AUDIO_S16, size, JA_musicVolume);
+        current_music->pos += size/2;
+        if (size < len) {
+            if (current_music->times != 0) {
+                SDL_MixAudioFormat(stream+size, (Uint8*)current_music->output, AUDIO_S16, len-size, JA_musicVolume);
+                current_music->pos = (len-size)/2;
+                if (current_music->times > 0) current_music->times--;
+            } else {
+                current_music->pos = 0;
+                current_music->state = JA_MUSIC_STOPPED;
+            }
+        }
+    }
+    // Mixar els channels mi amol
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+        if (channels[i].state == JA_CHANNEL_PLAYING) {
+            const int size = SDL_min(len, channels[i].sound->length - channels[i].pos);
+            SDL_MixAudioFormat(stream, channels[i].sound->buffer + channels[i].pos, AUDIO_S16, size, JA_soundVolume);
+            channels[i].pos += size;
+            if (size < len) {
+                if (channels[i].times != 0) {
+                    SDL_MixAudioFormat(stream + size, channels[i].sound->buffer, AUDIO_S16, len-size, JA_soundVolume);
+                    channels[i].pos = len-size;
+                    if (channels[i].times > 0) channels[i].times--;
+                } else {
+                    JA_StopChannel(i);
+                }
+            }
+        }
+    }
+}
+*/
+
+Uint32 JA_UpdateCallback(void *userdata, SDL_TimerID timerID, Uint32 interval) {
+    if (JA_musicEnabled && current_music && current_music->state == JA_MUSIC_PLAYING) {
+        if (fading) {
+            int time = SDL_GetTicks();
+            if (time > (fade_start_time + fade_duration)) {
+                fading = false;
+                JA_StopMusic();
+                return 30;
+            } else {
+                const int time_passed = time - fade_start_time;
+                const float percent = (float)time_passed / (float)fade_duration;
+                SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume * (1.0 - percent));
+            }
+        }
+
+        if (current_music->times != 0) {
+            if (SDL_GetAudioStreamAvailable(current_music->stream) < int(current_music->length / 2)) {
+                SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length);
+            }
+            if (current_music->times > 0) current_music->times--;
+        } else {
+            if (SDL_GetAudioStreamAvailable(current_music->stream) == 0) JA_StopMusic();
+        }
+    }
+
+    if (JA_soundEnabled) {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; ++i)
+            if (channels[i].state == JA_CHANNEL_PLAYING) {
+                if (channels[i].times != 0) {
+                    if (SDL_GetAudioStreamAvailable(channels[i].stream) < int(channels[i].sound->length / 2)) {
+                        SDL_PutAudioStreamData(channels[i].stream, channels[i].sound->buffer, channels[i].sound->length);
+                        if (channels[i].times > 0) channels[i].times--;
+                    }
+                } else {
+                    if (SDL_GetAudioStreamAvailable(channels[i].stream) == 0) JA_StopChannel(i);
+                }
+            }
+    }
+
+    return 30;
+}
+
+void JA_Init(const int freq, const SDL_AudioFormat format, const int num_channels) {
+#ifdef DEBUG
+    SDL_SetLogPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG);
+#endif
+
+    SDL_Log("Iniciant JailAudio...");
+    JA_audioSpec = {format, num_channels, freq};
+    if (!sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);
+    sdlAudioDevice = SDL_OpenAudioDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &JA_audioSpec);
+    SDL_Log((sdlAudioDevice == 0) ? "Failed to initialize SDL audio!\n" : "OK!\n");
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; ++i) channels[i].state = JA_CHANNEL_FREE;
+    // SDL_PauseAudioDevice(sdlAudioDevice);
+    JA_timerID = SDL_AddTimer(30, JA_UpdateCallback, nullptr);
+}
+
+void JA_Quit() {
+    if (JA_timerID) SDL_RemoveTimer(JA_timerID);
+
+    if (!sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);
+    sdlAudioDevice = 0;
+}
+
+JA_Music_t *JA_LoadMusic(Uint8 *buffer, Uint32 length, const char *filename) {
+    JA_Music_t *music = new JA_Music_t();
+
+    int chan, samplerate;
+    short *output;
+    music->length = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &output) * chan * 2;
+
+    music->spec.channels = chan;
+    music->spec.freq = samplerate;
+    music->spec.format = SDL_AUDIO_S16;
+    music->buffer = (Uint8 *)SDL_malloc(music->length);
+    SDL_memcpy(music->buffer, output, music->length);
+    free(output);
+    music->pos = 0;
+    music->state = JA_MUSIC_STOPPED;
+    if (filename) {
+        music->filename = (char *)malloc(strlen(filename) + 1);
+        strcpy(music->filename, filename);
+    }
+
+    return music;
+}
+
+JA_Music_t *JA_LoadMusic(const char *filename) {
+    // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
+    FILE *f = fopen(filename, "rb");
+    fseek(f, 0, SEEK_END);
+    long fsize = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    Uint8 *buffer = (Uint8 *)malloc(fsize + 1);
+    if (fread(buffer, fsize, 1, f) != 1) return NULL;
+    fclose(f);
+
+    JA_Music_t *music = JA_LoadMusic(buffer, fsize, filename);
+
+    free(buffer);
+
+    return music;
+}
+
+void JA_PlayMusic(JA_Music_t *music, const int loop) {
+    if (!JA_musicEnabled) return;
+
+    JA_StopMusic();
+
+    current_music = music;
+    current_music->pos = 0;
+    current_music->state = JA_MUSIC_PLAYING;
+    current_music->times = loop;
+
+    current_music->stream = SDL_CreateAudioStream(&current_music->spec, &JA_audioSpec);
+    if (!SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length)) printf("[ERROR] SDL_PutAudioStreamData failed!\n");
+    SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
+    if (!SDL_BindAudioStream(sdlAudioDevice, current_music->stream)) printf("[ERROR] SDL_BindAudioStream failed!\n");
+    // SDL_ResumeAudioStreamDevice(current_music->stream);
+}
+
+char *JA_GetMusicFilename(JA_Music_t *music) {
+    if (!music) music = current_music;
+    return music->filename;
+}
+
+void JA_PauseMusic() {
+    if (!JA_musicEnabled) return;
+    if (!current_music || current_music->state == JA_MUSIC_INVALID) return;
+
+    current_music->state = JA_MUSIC_PAUSED;
+    // SDL_PauseAudioStreamDevice(current_music->stream);
+    SDL_UnbindAudioStream(current_music->stream);
+}
+
+void JA_ResumeMusic() {
+    if (!JA_musicEnabled) return;
+    if (!current_music || current_music->state == JA_MUSIC_INVALID) return;
+
+    current_music->state = JA_MUSIC_PLAYING;
+    // SDL_ResumeAudioStreamDevice(current_music->stream);
+    SDL_BindAudioStream(sdlAudioDevice, current_music->stream);
+}
+
+void JA_StopMusic() {
+    if (!JA_musicEnabled) return;
+    if (!current_music || current_music->state == JA_MUSIC_INVALID) return;
+
+    current_music->pos = 0;
+    current_music->state = JA_MUSIC_STOPPED;
+    // SDL_PauseAudioStreamDevice(current_music->stream);
+    SDL_DestroyAudioStream(current_music->stream);
+    current_music->stream = nullptr;
+    free(current_music->filename);
+    current_music->filename = nullptr;
+}
+
+void JA_FadeOutMusic(const int milliseconds) {
+    if (!JA_musicEnabled) return;
+    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
+
+    fading = true;
+    fade_start_time = SDL_GetTicks();
+    fade_duration = milliseconds;
+    fade_initial_volume = JA_musicVolume;
+}
+
+JA_Music_state JA_GetMusicState() {
+    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+    if (!current_music) return JA_MUSIC_INVALID;
+
+    return current_music->state;
+}
+
+void JA_DeleteMusic(JA_Music_t *music) {
+    if (current_music == music) current_music = nullptr;
+    SDL_free(music->buffer);
+    if (music->stream) SDL_DestroyAudioStream(music->stream);
+    delete music;
+}
+
+float JA_SetMusicVolume(float volume) {
+    JA_musicVolume = SDL_clamp(volume, 0.0f, 1.0f);
+    if (current_music) SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
+    return JA_musicVolume;
+}
+
+void JA_SetMusicPosition(float value) {
+    if (!current_music) return;
+    current_music->pos = value * current_music->spec.freq;
+}
+
+float JA_GetMusicPosition() {
+    if (!current_music) return 0;
+    return float(current_music->pos) / float(current_music->spec.freq);
+}
+
+void JA_EnableMusic(const bool value) {
+    if (!value && current_music && (current_music->state == JA_MUSIC_PLAYING)) JA_StopMusic();
+
+    JA_musicEnabled = value;
+}
+
+JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length) {
+    JA_Sound_t *sound = new JA_Sound_t();
+    sound->buffer = buffer;
+    sound->length = length;
+    return sound;
+}
+
+JA_Sound_t *JA_LoadSound(uint8_t *buffer, uint32_t size) {
+    JA_Sound_t *sound = new JA_Sound_t();
+    SDL_LoadWAV_IO(SDL_IOFromMem(buffer, size), 1, &sound->spec, &sound->buffer, &sound->length);
+
+    return sound;
+}
+
+JA_Sound_t *JA_LoadSound(const char *filename) {
+    JA_Sound_t *sound = new JA_Sound_t();
+    SDL_LoadWAV(filename, &sound->spec, &sound->buffer, &sound->length);
+
+    return sound;
+}
+
+int JA_PlaySound(JA_Sound_t *sound, const int loop) {
+    if (!JA_soundEnabled) return -1;
+
+    int channel = 0;
+    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
+    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0;
+    JA_StopChannel(channel);
+
+    channels[channel].sound = sound;
+    channels[channel].times = loop;
+    channels[channel].pos = 0;
+    channels[channel].state = JA_CHANNEL_PLAYING;
+    channels[channel].stream = SDL_CreateAudioStream(&channels[channel].sound->spec, &JA_audioSpec);
+    SDL_PutAudioStreamData(channels[channel].stream, channels[channel].sound->buffer, channels[channel].sound->length);
+    SDL_SetAudioStreamGain(channels[channel].stream, JA_soundVolume);
+    SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
+
+    return channel;
+}
+
+int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop) {
+    if (!JA_soundEnabled) return -1;
+
+    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return -1;
+    JA_StopChannel(channel);
+
+    channels[channel].sound = sound;
+    channels[channel].times = loop;
+    channels[channel].pos = 0;
+    channels[channel].state = JA_CHANNEL_PLAYING;
+    channels[channel].stream = SDL_CreateAudioStream(&channels[channel].sound->spec, &JA_audioSpec);
+    SDL_PutAudioStreamData(channels[channel].stream, channels[channel].sound->buffer, channels[channel].sound->length);
+    SDL_SetAudioStreamGain(channels[channel].stream, JA_soundVolume);
+    SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
+
+    return channel;
+}
+
+void JA_DeleteSound(JA_Sound_t *sound) {
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+        if (channels[i].sound == sound) JA_StopChannel(i);
+    }
+    SDL_free(sound->buffer);
+    delete sound;
+}
+
+void JA_PauseChannel(const int channel) {
+    if (!JA_soundEnabled) return;
+
+    if (channel == -1) {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+            if (channels[i].state == JA_CHANNEL_PLAYING) {
+                channels[i].state = JA_CHANNEL_PAUSED;
+                // SDL_PauseAudioStreamDevice(channels[i].stream);
+                SDL_UnbindAudioStream(channels[i].stream);
+            }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        if (channels[channel].state == JA_CHANNEL_PLAYING) {
+            channels[channel].state = JA_CHANNEL_PAUSED;
+            // SDL_PauseAudioStreamDevice(channels[channel].stream);
+            SDL_UnbindAudioStream(channels[channel].stream);
+        }
+    }
+}
+
+void JA_ResumeChannel(const int channel) {
+    if (!JA_soundEnabled) return;
+
+    if (channel == -1) {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+            if (channels[i].state == JA_CHANNEL_PAUSED) {
+                channels[i].state = JA_CHANNEL_PLAYING;
+                // SDL_ResumeAudioStreamDevice(channels[i].stream);
+                SDL_BindAudioStream(sdlAudioDevice, channels[i].stream);
+            }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        if (channels[channel].state == JA_CHANNEL_PAUSED) {
+            channels[channel].state = JA_CHANNEL_PLAYING;
+            // SDL_ResumeAudioStreamDevice(channels[channel].stream);
+            SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
+        }
+    }
+}
+
+void JA_StopChannel(const int channel) {
+    if (!JA_soundEnabled) return;
+
+    if (channel == -1) {
+        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+            if (channels[i].state != JA_CHANNEL_FREE) SDL_DestroyAudioStream(channels[i].stream);
+            channels[i].stream = nullptr;
+            channels[i].state = JA_CHANNEL_FREE;
+            channels[i].pos = 0;
+            channels[i].sound = NULL;
+        }
+    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
+        if (channels[channel].state != JA_CHANNEL_FREE) SDL_DestroyAudioStream(channels[channel].stream);
+        channels[channel].stream = nullptr;
+        channels[channel].state = JA_CHANNEL_FREE;
+        channels[channel].pos = 0;
+        channels[channel].sound = NULL;
+    }
+}
+
+JA_Channel_state JA_GetChannelState(const int channel) {
+    if (!JA_soundEnabled) return JA_SOUND_DISABLED;
+
+    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
+
+    return channels[channel].state;
+}
+
+float JA_SetSoundVolume(float volume) {
+    JA_soundVolume = SDL_clamp(volume, 0.0f, 1.0f);
+
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
+        if ((channels[i].state == JA_CHANNEL_PLAYING) || (channels[i].state == JA_CHANNEL_PAUSED))
+            SDL_SetAudioStreamGain(channels[i].stream, JA_soundVolume);
+
+    return JA_soundVolume;
+}
+
+void JA_EnableSound(const bool value) {
+    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
+        if (channels[i].state == JA_CHANNEL_PLAYING) JA_StopChannel(i);
+    }
+    JA_soundEnabled = value;
+}
+
+float JA_SetVolume(float volume) {
+    JA_SetSoundVolume(JA_SetMusicVolume(volume) / 2.0f);
+
+    return JA_musicVolume;
+}
+
+#endif

source/core/jail/jail_audio.hpp

@@ -0,0 +1,49 @@
+#pragma once
+#include <SDL3/SDL.h>
+
+enum JA_Channel_state { JA_CHANNEL_INVALID,
+    JA_CHANNEL_FREE,
+    JA_CHANNEL_PLAYING,
+    JA_CHANNEL_PAUSED,
+    JA_SOUND_DISABLED };
+enum JA_Music_state { JA_MUSIC_INVALID,
+    JA_MUSIC_PLAYING,
+    JA_MUSIC_PAUSED,
+    JA_MUSIC_STOPPED,
+    JA_MUSIC_DISABLED };
+
+struct JA_Sound_t;
+struct JA_Music_t;
+
+void JA_Init(const int freq, const SDL_AudioFormat format, const int num_channels);
+void JA_Quit();
+
+JA_Music_t *JA_LoadMusic(const char *filename);
+JA_Music_t *JA_LoadMusic(Uint8 *buffer, Uint32 length, const char *filename = nullptr);
+void JA_PlayMusic(JA_Music_t *music, const int loop = -1);
+char *JA_GetMusicFilename(JA_Music_t *music = nullptr);
+void JA_PauseMusic();
+void JA_ResumeMusic();
+void JA_StopMusic();
+void JA_FadeOutMusic(const int milliseconds);
+JA_Music_state JA_GetMusicState();
+void JA_DeleteMusic(JA_Music_t *music);
+float JA_SetMusicVolume(float volume);
+void JA_SetMusicPosition(float value);
+float JA_GetMusicPosition();
+void JA_EnableMusic(const bool value);
+
+JA_Sound_t *JA_NewSound(Uint8 *buffer, Uint32 length);
+JA_Sound_t *JA_LoadSound(Uint8 *buffer, Uint32 length);
+JA_Sound_t *JA_LoadSound(const char *filename);
+int JA_PlaySound(JA_Sound_t *sound, const int loop = 0);
+int JA_PlaySoundOnChannel(JA_Sound_t *sound, const int channel, const int loop = 0);
+void JA_PauseChannel(const int channel);
+void JA_ResumeChannel(const int channel);
+void JA_StopChannel(const int channel);
+JA_Channel_state JA_GetChannelState(const int channel);
+void JA_DeleteSound(JA_Sound_t *sound);
+float JA_SetSoundVolume(float volume);
+void JA_EnableSound(const bool value);
+
+float JA_SetVolume(float volume);

source/core/jail/jdraw8.cpp

@@ -0,0 +1,217 @@
+#include "core/jail/jdraw8.hpp"
+
+#include <fstream>
+
+#include "core/jail/jfile.hpp"
+#include "core/rendering/screen.hpp"
+#include "external/gif.h"
+
+JD8_Surface screen = NULL;
+JD8_Palette main_palette = NULL;
+Uint32 *pixel_data = NULL;
+
+void JD8_Init() {
+    screen = (JD8_Surface)calloc(1, 64000);
+    main_palette = (JD8_Palette)calloc(1, 768);
+    pixel_data = (Uint32 *)calloc(1, 320 * 200 * 4);
+}
+
+void JD8_Quit() {
+    if (screen != NULL) free(screen);
+    if (main_palette != NULL) free(main_palette);
+    if (pixel_data != NULL) free(pixel_data);
+}
+
+void JD8_ClearScreen(Uint8 color) {
+    memset(screen, color, 64000);
+}
+
+JD8_Surface JD8_NewSurface() {
+    JD8_Surface surface = (JD8_Surface)malloc(64000);
+    memset(surface, 0, 64000);
+    return surface;
+}
+
+JD8_Surface JD8_LoadSurface(const char *file) {
+    int filesize = 0;
+    char *buffer = file_getfilebuffer(file, filesize);
+
+    unsigned short w, h;
+    Uint8 *pixels = LoadGif((unsigned char *)buffer, &w, &h);
+
+    free(buffer);
+
+    if (pixels == NULL) {
+        printf("Unable to load bitmap: %s\n", SDL_GetError());
+        exit(1);
+    }
+
+    JD8_Surface image = JD8_NewSurface();
+    memcpy(image, pixels, 64000);
+
+    free(pixels);
+    return image;
+}
+
+JD8_Palette JD8_LoadPalette(const char *file) {
+    int filesize = 0;
+    char *buffer = NULL;
+    buffer = file_getfilebuffer(file, filesize);
+
+    JD8_Palette palette = (JD8_Palette)LoadPalette((unsigned char *)buffer);
+
+    return palette;
+}
+
+void JD8_SetScreenPalette(JD8_Palette palette) {
+    if (main_palette == palette) return;
+    if (main_palette != NULL) free(main_palette);
+    main_palette = palette;
+}
+
+void JD8_FillSquare(int ini, int height, Uint8 color) {
+    const int offset = ini * 320;
+    const int size = height * 320;
+    memset(&screen[offset], color, size);
+}
+
+void JD8_Blit(JD8_Surface surface) {
+    memcpy(screen, surface, 64000);
+}
+
+void JD8_Blit(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh) {
+    int src_pointer = sx + (sy * 320);
+    int dst_pointer = x + (y * 320);
+    for (int i = 0; i < sh; i++) {
+        memcpy(&screen[dst_pointer], &surface[src_pointer], sw);
+        src_pointer += 320;
+        dst_pointer += 320;
+    }
+}
+
+void JD8_BlitToSurface(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, JD8_Surface dest) {
+    int src_pointer = sx + (sy * 320);
+    int dst_pointer = x + (y * 320);
+    for (int i = 0; i < sh; i++) {
+        memcpy(&dest[dst_pointer], &surface[src_pointer], sw);
+        src_pointer += 320;
+        dst_pointer += 320;
+    }
+}
+
+void JD8_BlitCK(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, Uint8 colorkey) {
+    int src_pointer = sx + (sy * 320);
+    int dst_pointer = x + (y * 320);
+    for (int j = 0; j < sh; j++) {
+        for (int i = 0; i < sw; i++) {
+            if (surface[src_pointer + i] != colorkey) screen[dst_pointer + i] = surface[src_pointer + i];
+        }
+        src_pointer += 320;
+        dst_pointer += 320;
+    }
+}
+
+void JD8_BlitCKCut(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, Uint8 colorkey) {
+    int src_pointer = sx + (sy * 320);
+    int dst_pointer = x + (y * 320);
+    for (int j = 0; j < sh; j++) {
+        for (int i = 0; i < sw; i++) {
+            if (surface[src_pointer + i] != colorkey && (x + i >= 0) && (y + j >= 0) && (x + i < 320) && (y + j < 200)) screen[dst_pointer + i] = surface[src_pointer + i];
+        }
+        src_pointer += 320;
+        dst_pointer += 320;
+    }
+}
+
+void JD8_BlitCKScroll(int y, JD8_Surface surface, int sx, int sy, int sh, Uint8 colorkey) {
+    int dst_pointer = y * 320;
+    for (int j = sy; j < sy + sh; j++) {
+        for (int i = 0; i < 320; i++) {
+            int x = (i + sx) % 320;
+            if (surface[x + j * 320] != colorkey) screen[dst_pointer] = surface[x + j * 320];
+            dst_pointer++;
+        }
+    }
+}
+
+void JD8_BlitCKToSurface(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, JD8_Surface dest, Uint8 colorkey) {
+    int src_pointer = sx + (sy * 320);
+    int dst_pointer = x + (y * 320);
+    for (int j = 0; j < sh; j++) {
+        for (int i = 0; i < sw; i++) {
+            if (surface[src_pointer + i] != colorkey) dest[dst_pointer + i] = surface[src_pointer + i];
+        }
+        src_pointer += 320;
+        dst_pointer += 320;
+    }
+}
+
+void JD8_Flip() {
+    for (int x = 0; x < 320; x++) {
+        for (int y = 0; y < 200; y++) {
+            Uint32 color = 0xFF000000 + main_palette[screen[x + (y * 320)]].r + (main_palette[screen[x + (y * 320)]].g << 8) + (main_palette[screen[x + (y * 320)]].b << 16);
+            pixel_data[x + (y * 320)] = color;
+        }
+    }
+    Screen::get()->present(pixel_data);
+}
+
+void JD8_FreeSurface(JD8_Surface surface) {
+    free(surface);
+}
+
+Uint8 JD8_GetPixel(JD8_Surface surface, int x, int y) {
+    return surface[x + (y * 320)];
+}
+
+void JD8_PutPixel(JD8_Surface surface, int x, int y, Uint8 pixel) {
+    surface[x + (y * 320)] = pixel;
+}
+
+void JD8_SetPaletteColor(Uint8 index, Uint8 r, Uint8 g, Uint8 b) {
+    main_palette[index].r = r << 2;
+    main_palette[index].g = g << 2;
+    main_palette[index].b = b << 2;
+}
+
+void JD8_FadeOut() {
+    for (int j = 0; j < 32; j++) {
+        for (int i = 0; i < 256; i++) {
+            if (main_palette[i].r >= 8)
+                main_palette[i].r -= 8;
+            else
+                main_palette[i].r = 0;
+            if (main_palette[i].g >= 8)
+                main_palette[i].g -= 8;
+            else
+                main_palette[i].g = 0;
+            if (main_palette[i].b >= 8)
+                main_palette[i].b -= 8;
+            else
+                main_palette[i].b = 0;
+        }
+        JD8_Flip();
+    }
+}
+
+#define MAX(a, b) (a) > (b) ? (a) : (b)
+
+void JD8_FadeToPal(JD8_Palette pal) {
+    for (int j = 0; j < 32; j++) {
+        for (int i = 0; i < 256; i++) {
+            if (main_palette[i].r <= int(pal[i].r) - 8)
+                main_palette[i].r += 8;
+            else
+                main_palette[i].r = pal[i].r;
+            if (main_palette[i].g <= int(pal[i].g) - 8)
+                main_palette[i].g += 8;
+            else
+                main_palette[i].g = pal[i].g;
+            if (main_palette[i].b <= int(pal[i].b) - 8)
+                main_palette[i].b += 8;
+            else
+                main_palette[i].b = pal[i].b;
+        }
+        JD8_Flip();
+    }
+}

source/core/jail/jdraw8.hpp

@@ -0,0 +1,61 @@
+#pragma once
+#include <SDL3/SDL.h>
+
+struct Color {
+    Uint8 r;
+    Uint8 g;
+    Uint8 b;
+};
+
+typedef Uint8 *JD8_Surface;
+typedef Color *JD8_Palette;
+
+void JD8_Init();
+
+void JD8_Quit();
+
+void JD8_ClearScreen(Uint8 color);
+
+JD8_Surface JD8_NewSurface();
+
+JD8_Surface JD8_LoadSurface(const char *file);
+
+JD8_Palette JD8_LoadPalette(const char *file);
+
+void JD8_SetScreenPalette(JD8_Palette palette);
+
+void JD8_FillSquare(int ini, int height, Uint8 color);
+
+void JD8_Blit(JD8_Surface surface);
+
+void JD8_Blit(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh);
+
+void JD8_BlitToSurface(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, JD8_Surface dest);
+
+void JD8_BlitCK(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, Uint8 colorkey);
+
+void JD8_BlitCKCut(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, Uint8 colorkey);
+
+void JD8_BlitCKScroll(int y, JD8_Surface surface, int sx, int sy, int sh, Uint8 colorkey);
+
+void JD8_BlitCKToSurface(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, JD8_Surface dest, Uint8 colorkey);
+
+void JD8_Flip();
+
+void JD8_FreeSurface(JD8_Surface surface);
+
+Uint8 JD8_GetPixel(JD8_Surface surface, int x, int y);
+
+void JD8_PutPixel(JD8_Surface surface, int x, int y, Uint8 pixel);
+
+void JD8_SetPaletteColor(Uint8 index, Uint8 r, Uint8 g, Uint8 b);
+
+void JD8_FadeOut();
+
+void JD8_FadeToPal(JD8_Palette pal);
+
+// JD_Font JD_LoadFont( char *file, int width, int height);
+
+// void JD_DrawText( int x, int y, JD_Font *source, char *text);
+
+// char *JD_GetFPS();

source/core/jail/jfile.cpp

@@ -0,0 +1,218 @@
+#include "core/jail/jfile.hpp"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#ifndef _WIN32
+#include <pwd.h>
+#endif
+
+#define DEFAULT_FILENAME "data.jf2"
+#define DEFAULT_FOLDER "data/"
+#define CONFIG_FILENAME "config.txt"
+
+struct file_t {
+    std::string path;
+    uint32_t size;
+    uint32_t offset;
+};
+
+std::vector<file_t> toc;
+
+/* El std::map me fa coses rares, vaig a usar un good old std::vector amb una estructura key,value propia i au, que sempre funciona */
+struct keyvalue_t {
+    std::string key, value;
+};
+
+char *resource_filename = NULL;
+char *resource_folder = NULL;
+int file_source = SOURCE_FILE;
+char scratch[255];
+static std::string config_folder;
+std::vector<keyvalue_t> config;
+
+void file_setresourcefilename(const char *str) {
+    if (resource_filename != NULL) free(resource_filename);
+    resource_filename = (char *)malloc(strlen(str) + 1);
+    strcpy(resource_filename, str);
+}
+
+void file_setresourcefolder(const char *str) {
+    if (resource_folder != NULL) free(resource_folder);
+    resource_folder = (char *)malloc(strlen(str) + 1);
+    strcpy(resource_folder, str);
+}
+
+void file_setsource(const int src) {
+    file_source = src % 2;  // mod 2 so it always is a valid value, 0 (file) or 1 (folder)
+    if (src == SOURCE_FOLDER && resource_folder == NULL) file_setresourcefolder(DEFAULT_FOLDER);
+}
+
+bool file_getdictionary() {
+    if (resource_filename == NULL) file_setresourcefilename(DEFAULT_FILENAME);
+
+    std::ifstream fi(resource_filename, std::ios::binary);
+    if (!fi.is_open()) return false;
+    char header[4];
+    fi.read(header, 4);
+    uint32_t num_files, toc_offset;
+    fi.read((char *)&num_files, 4);
+    fi.read((char *)&toc_offset, 4);
+    fi.seekg(toc_offset);
+
+    for (uint32_t i = 0; i < num_files; ++i) {
+        uint32_t file_offset, file_size;
+        fi.read((char *)&file_offset, 4);
+        fi.read((char *)&file_size, 4);
+        uint8_t path_size;
+        fi.read((char *)&path_size, 1);
+        char file_name[path_size + 1];
+        fi.read(file_name, path_size);
+        file_name[path_size] = 0;
+        std::string filename = file_name;
+        toc.push_back({filename, file_size, file_offset});
+    }
+    fi.close();
+    return true;
+}
+
+char *file_getfilenamewithfolder(const char *filename) {
+    strcpy(scratch, resource_folder);
+    strcat(scratch, filename);
+    return scratch;
+}
+
+FILE *file_getfilepointer(const char *resourcename, int &filesize, const bool binary) {
+    if (file_source == SOURCE_FILE and toc.size() == 0) {
+        if (not file_getdictionary()) file_setsource(SOURCE_FOLDER);
+    }
+
+    FILE *f;
+
+    if (file_source == SOURCE_FILE) {
+        bool found = false;
+        uint32_t count = 0;
+        while (!found && count < toc.size()) {
+            found = (std::string(resourcename) == toc[count].path);
+            if (!found) count++;
+        }
+
+        if (!found) {
+            perror("El recurs no s'ha trobat en l'arxiu de recursos");
+            exit(1);
+        }
+
+        filesize = toc[count].size;
+
+        f = fopen(resource_filename, binary ? "rb" : "r");
+        if (not f) {
+            perror("No s'ha pogut obrir l'arxiu de recursos");
+            exit(1);
+        }
+        fseek(f, toc[count].offset, SEEK_SET);
+    } else {
+        f = fopen(file_getfilenamewithfolder(resourcename), binary ? "rb" : "r");
+        fseek(f, 0, SEEK_END);
+        filesize = ftell(f);
+        fseek(f, 0, SEEK_SET);
+    }
+    return f;
+}
+
+char *file_getfilebuffer(const char *resourcename, int &filesize, const bool zero_terminate) {
+    FILE *f = file_getfilepointer(resourcename, filesize, true);
+    char *buffer = (char *)malloc(zero_terminate ? filesize : filesize + 1);
+    fread(buffer, filesize, 1, f);
+    if (zero_terminate) buffer[filesize] = 0;
+    fclose(f);
+    return buffer;
+}
+
+// Crea la carpeta del sistema donde guardar datos.
+// Acepta rutas con subdirectorios (ej: "jailgames/aee") y crea toda la jerarquía.
+void file_setconfigfolder(const char *foldername) {
+#ifdef _WIN32
+    config_folder = std::string(getenv("APPDATA")) + "/" + foldername;
+#elif __APPLE__
+    struct passwd *pw = getpwuid(getuid());
+    const char *homedir = pw->pw_dir;
+    config_folder = std::string(homedir) + "/Library/Application Support/" + foldername;
+#elif __linux__
+    struct passwd *pw = getpwuid(getuid());
+    const char *homedir = pw->pw_dir;
+    config_folder = std::string(homedir) + "/.config/" + foldername;
+#endif
+
+    std::filesystem::create_directories(config_folder);
+}
+
+const char *file_getconfigfolder() {
+    static std::string folder;
+    folder = config_folder + "/";
+    return folder.c_str();
+}
+
+void file_loadconfigvalues() {
+    config.clear();
+    std::string config_file = config_folder + "/config.txt";
+    FILE *f = fopen(config_file.c_str(), "r");
+    if (!f) return;
+
+    char line[1024];
+    while (fgets(line, sizeof(line), f)) {
+        char *value = strchr(line, '=');
+        if (value) {
+            *value = '\0';
+            value++;
+            value[strlen(value) - 1] = '\0';
+            config.push_back({line, value});
+        }
+    }
+    fclose(f);
+}
+
+void file_saveconfigvalues() {
+    std::string config_file = config_folder + "/config.txt";
+    FILE *f = fopen(config_file.c_str(), "w");
+    if (f) {
+        for (auto pair : config) {
+            fprintf(f, "%s=%s\n", pair.key.c_str(), pair.value.c_str());
+        }
+        fclose(f);
+    }
+}
+
+const char *file_getconfigvalue(const char *key) {
+    if (config.empty()) file_loadconfigvalues();
+    for (auto pair : config) {
+        if (pair.key == std::string(key)) {
+            strcpy(scratch, pair.value.c_str());
+            return scratch;
+        }
+    }
+    return NULL;
+}
+
+void file_setconfigvalue(const char *key, const char *value) {
+    if (config.empty()) file_loadconfigvalues();
+    for (auto &pair : config) {
+        if (pair.key == std::string(key)) {
+            pair.value = value;
+            file_saveconfigvalues();
+            return;
+        }
+    }
+    config.push_back({key, value});
+    file_saveconfigvalues();
+    return;
+}

source/core/jail/jfile.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include <stdio.h>
+
+#define SOURCE_FILE 0
+#define SOURCE_FOLDER 1
+
+void file_setconfigfolder(const char *foldername);
+const char *file_getconfigfolder();
+
+void file_setresourcefilename(const char *str);
+void file_setresourcefolder(const char *str);
+void file_setsource(const int src);
+
+FILE *file_getfilepointer(const char *resourcename, int &filesize, const bool binary = false);
+char *file_getfilebuffer(const char *resourcename, int &filesize, const bool zero_terminate = false);
+
+const char *file_getconfigvalue(const char *key);
+void file_setconfigvalue(const char *key, const char *value);

source/core/jail/jgame.cpp

@@ -0,0 +1,42 @@
+#include "core/jail/jgame.hpp"
+
+bool eixir = false;
+Uint32 updateTicks = 0;
+Uint32 updateTime = 0;
+Uint32 cycle_counter = 0;
+
+void JG_Init() {
+    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
+    // SDL_WM_SetCaption( title, NULL );
+    updateTime = SDL_GetTicks();
+}
+
+void JG_Finalize() {
+    SDL_Quit();
+}
+
+void JG_QuitSignal() {
+    eixir = true;
+}
+
+bool JG_Quitting() {
+    return eixir;
+}
+
+void JG_SetUpdateTicks(Uint32 milliseconds) {
+    updateTicks = milliseconds;
+}
+
+bool JG_ShouldUpdate() {
+    if (SDL_GetTicks() - updateTime > updateTicks) {
+        updateTime = SDL_GetTicks();
+        cycle_counter++;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+Uint32 JG_GetCycleCounter() {
+    return cycle_counter;
+}

source/core/jail/jgame.hpp

@@ -0,0 +1,16 @@
+#pragma once
+#include <SDL3/SDL.h>
+
+void JG_Init();
+
+void JG_Finalize();
+
+void JG_QuitSignal();
+
+bool JG_Quitting();
+
+void JG_SetUpdateTicks(Uint32 milliseconds);
+
+bool JG_ShouldUpdate();
+
+Uint32 JG_GetCycleCounter();

source/core/jail/jinput.cpp

@@ -0,0 +1,57 @@
+#include "core/jail/jinput.hpp"
+
+#include <string>
+
+#include "core/input/global_inputs.hpp"
+#include "core/jail/jgame.hpp"
+
+const bool* keystates;  // = SDL_GetKeyboardState( NULL );
+SDL_Event event;
+Uint8 cheat[5];
+bool key_pressed = false;
+int waitTime = 0;
+
+void JI_DisableKeyboard(Uint32 time) {
+    waitTime = time;
+}
+
+void JI_moveCheats(Uint8 new_key) {
+    cheat[0] = cheat[1];
+    cheat[1] = cheat[2];
+    cheat[2] = cheat[3];
+    cheat[3] = cheat[4];
+    cheat[4] = new_key;
+}
+
+void JI_Update() {
+    key_pressed = false;
+    keystates = SDL_GetKeyboardState(NULL);
+
+    if (waitTime > 0) waitTime--;
+
+    while (SDL_PollEvent(&event)) {
+        if (event.type == SDL_EVENT_QUIT) JG_QuitSignal();
+        if (event.type == SDL_EVENT_KEY_UP) {
+            key_pressed = true;
+            JI_moveCheats(event.key.scancode);
+        }
+    }
+
+    GlobalInputs::handle();
+}
+
+bool JI_KeyPressed(int key) {
+    return waitTime > 0 ? false : (keystates[key] != 0);
+}
+
+bool JI_CheatActivated(const char* cheat_code) {
+    bool found = true;
+    for (size_t i = 0; i < strlen(cheat_code); i++) {
+        if (cheat[i] != cheat_code[i]) found = false;
+    }
+    return found;
+}
+
+bool JI_AnyKey() {
+    return waitTime > 0 ? false : key_pressed;
+}

source/core/jail/jinput.hpp

@@ -0,0 +1,12 @@
+#pragma once
+#include <SDL3/SDL.h>
+
+void JI_DisableKeyboard(Uint32 time);
+
+void JI_Update();
+
+bool JI_KeyPressed(int key);
+
+bool JI_CheatActivated(const char* cheat_code);
+
+bool JI_AnyKey();