- [WIP] Puta que susto, una regla mal feta en el .gitignore i ja no comitaba res

- Canvi de comp

.gitignore

@@ -1,5 +1,5 @@
-mini.exe
+/mini.exe
-mini
+/mini
 mini_debug.exe
 mini_debug
 .vscode/*

source/mini/audio/audio.cpp

@@ -0,0 +1,115 @@
+#include "audio.h"
+#include "jail_audio.h"
+#include "mini/file/file.h"
+
+namespace mini
+{
+    namespace audio
+    {
+        JA_Music_t *current_music = NULL;
+        #define MAX_SOUNDS 50
+        JA_Sound_t *sounds[MAX_SOUNDS];
+
+        void init() {
+            JA_Init(48000, SDL_AUDIO_S16, 1);
+            for (int i=0;i<MAX_SOUNDS;++i) sounds[i] = NULL;
+        }
+
+        void quit() {
+            if (current_music != NULL) JA_DeleteMusic(current_music);
+            for (int i=0;i<MAX_SOUNDS;++i) if (sounds[i]!=NULL) JA_DeleteSound(sounds[i]);
+            JA_Quit();
+        }
+
+        namespace music
+        {
+            void play(const char *filename, const int loop) {
+                int size;
+                char *buffer = file::getfilebuffer(filename, size);
+                if (current_music != NULL) JA_DeleteMusic(current_music);
+                current_music = JA_LoadMusic((Uint8*)buffer, size);
+                JA_PlayMusic(current_music, loop);
+            }
+
+            void pause() {
+                JA_PauseMusic();
+            }
+
+            void resume() {
+                JA_ResumeMusic();
+            }
+
+            void stop(const int t) {
+                JA_StopMusic();
+            }
+
+            namespace pos {
+                void set(float value)
+                {
+                    JA_SetMusicPosition(value);
+                }
+
+                float get()
+                {
+                    return JA_GetMusicPosition();
+                }
+            }
+
+            namespace enable {
+                void set(const bool value)
+                {
+                    JA_EnableMusic(value);
+                    file::setconfigvalue("music", value?"true":"false");
+                }
+
+                const bool get()
+                {
+                    return JA_IsMusicEnabled();
+                }
+            }
+        }
+
+        namespace sound
+        {
+            int load(const char *filename) {
+                int size;
+                char *buffer = file::getfilebuffer(filename, size);
+                int i=0;
+                while (i<MAX_SOUNDS && sounds[i]!=NULL) i++;
+                if (i==MAX_SOUNDS) { i=0; JA_DeleteSound(sounds[i]); }
+                sounds[i]=JA_LoadSound((Uint8*)buffer, size);
+                return i;
+            }
+
+            void free(int soundfile) {
+                JA_DeleteSound(sounds[soundfile]);
+                sounds[soundfile] = NULL;
+            }
+
+            int play(int soundfile, const int volume) {
+                const int channel = JA_PlaySound(sounds[soundfile], 0);
+                JA_SetSoundVolume(128);
+                //Mix_Volume(channel, volume!=-1?volume:MIX_MAX_VOLUME);
+                return channel;
+            }
+
+            void stop(int soundchannel) {
+                JA_StopChannel(soundchannel);
+                //Mix_HaltChannel(soundchannel);
+            }
+
+            namespace enable {
+                void set(const bool value)
+                {
+                    JA_EnableSound(value);
+                    file::setconfigvalue("sound", value?"true":"false");
+                }
+
+                const bool get()
+                {
+                    return JA_IsSoundEnabled();
+                }
+            }
+        }
+    }
+}

source/mini/audio/audio.h

@@ -0,0 +1,38 @@
+#pragma once
+
+namespace mini
+{
+    namespace audio
+    {
+        void init();
+        void quit();
+        
+        namespace music
+        {
+            void play(const char *filename, const int loop=-1);
+            void pause();
+            void resume();
+            void stop(const int t=1000);
+            namespace pos {
+                void set(float value);
+                float get();
+            }
+            namespace enable {
+                void set(const bool value);
+                const bool get();
+            }
+        }
+
+        namespace sound
+        {
+            int load(const char *filename);
+            void free(int soundfile);
+            int play(int soundfile, const int volume=-1);
+            void stop(int soundchannel);
+            namespace enable {
+                void set(const bool value);
+                const bool get();
+            }
+        }
+    }
+}

source/mini/audio/jail_audio.cpp

@@ -0,0 +1,509 @@
+#ifndef JA_USESDLMIXER
+#include "jail_audio.h"
+#include "external/stb_vorbis.h"
+#include "aux/log.h"
+
+#include <SDL3/SDL.h>
+
+#include <stdio.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 };
+
+    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, 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 channels)
+{
+    #ifdef DEBUG
+    SDL_SetLogPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG);
+    #endif
+    
+    JA_audioSpec = {format, channels, freq };
+    if (!sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);
+    sdlAudioDevice = SDL_OpenAudioDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &JA_audioSpec);
+    if (!sdlAudioDevice) {
+        log_msg(LOG_FAIL, "Failed to initialize SDL audio: %s\n", SDL_GetError());
+    } else {
+        log_msg(LOG_OK, "Audio subsytem initialized\n");
+    }
+    //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)
+{
+    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;
+
+    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);
+
+    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)) log_msg(LOG_FAIL, "SDL_PutAudioStreamData failed!\n");
+    SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
+    if (!SDL_BindAudioStream(sdlAudioDevice, current_music->stream)) log_msg(LOG_FAIL, "SDL_BindAudioStream failed!\n");
+    //SDL_ResumeAudioStreamDevice(current_music->stream);
+}
+
+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;
+}
+
+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;
+}
+
+const bool JA_IsMusicEnabled()
+{
+    return JA_musicEnabled;
+}
+
+
+
+
+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;
+}
+
+const bool JA_IsSoundEnabled()
+{
+    return JA_soundEnabled;
+}
+
+float JA_SetVolume(float volume)
+{
+    JA_SetSoundVolume(JA_SetMusicVolume(volume) / 2.0f);
+
+    return JA_musicVolume;
+}
+
+#endif

source/mini/audio/jail_audio.h

@@ -0,0 +1,42 @@
+#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 channels);
+void JA_Quit();
+
+JA_Music_t *JA_LoadMusic(const char* filename);
+JA_Music_t *JA_LoadMusic(Uint8* buffer, Uint32 length);
+void JA_PlayMusic(JA_Music_t *music, const int loop = -1);
+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);
+const bool JA_IsMusicEnabled();
+
+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);
+const bool JA_IsSoundEnabled();
+
+float JA_SetVolume(float volume);

source/mini/config/config.cpp

@@ -0,0 +1,21 @@
+#include "config.h"
+#include "mini/file/file.h"
+
+namespace mini
+{
+    namespace config
+    {
+        namespace key {
+            void set(const char* key, const char* value) {
+                file::setconfigvalue(key, value);
+            }
+            const char* get(const char* key) {
+                return file::getconfigvalue(key);
+            }
+        }
+
+        const char *folder() {
+            return file::getconfigfolder();
+        }
+    }
+}

source/mini/config/config.h

@@ -0,0 +1,15 @@
+#pragma once
+#include <stdint.h>
+
+namespace mini
+{
+    namespace config
+    {
+        namespace key {
+            void set(const char* key, const char* value);
+            const char *get(const char* key);
+        }
+
+        const char *folder();
+    }
+}

source/mini/draw/draw.cpp

@@ -0,0 +1,445 @@
+#include "draw.h"
+#include "mini/surf/surf.h"
+#include "mini/view/view.h"
+#include "mini/font/font.h"
+
+#include <SDL3/SDL.h>
+
+#define DEST(x, y) surf::state.dest_surface->p[x+y*surf::state.dest_surface->w]
+#define SOURCE(x, y) surf::state.source_surface->p[x+y*surf::state.source_surface->w]
+
+namespace mini
+{
+    namespace draw
+    {
+        state_t state;
+
+        namespace pixel {
+            static inline void pset_fast(int x, int y, uint8_t color) {
+                if (state.trans != color) DEST(x, y) = state.draw_palette[color];
+            }
+
+            static inline void pset_bool(int x, int y, uint8_t color) {
+                if (state.trans != color) {
+                    switch (state.mode) {
+                        case DRAWMODE_AND:
+                            DEST(x, y) = DEST(x, y) & color;
+                            break;
+                        case DRAWMODE_OR:
+                            DEST(x, y) = DEST(x, y) | color;
+                            break;
+                        case DRAWMODE_XOR:
+                            DEST(x, y) = DEST(x, y) ^ color;
+                            break;
+                        case DRAWMODE_NOT:
+                            DEST(x, y) = ~DEST(x, y);
+                            break;
+                    }
+                }
+            }
+
+            static inline void pset_pattern(int x, int y, uint8_t color) {
+                int pbx = x % 4, pby = y % 4;
+                int pb = pbx+pby*4;
+                if (state.fill_pattern & (1 << pb)) if (state.trans != color) DEST(x, y) = color;
+            }
+
+           // Per a les funcions que pinten tot del mateix color
+            static inline void direct_pset(int x, int y, uint8_t color) {
+                x += view::state.origin[0]; y += view::state.origin[1];
+                if (x < surf::state.dest_surface->clip[0] || x > surf::state.dest_surface->clip[2] || y < surf::state.dest_surface->clip[1] || y > surf::state.dest_surface->clip[3]) return;
+                switch (state.mode) {
+                    case DRAWMODE_NORMAL: pset_fast(x,y,color); break;
+                    case DRAWMODE_PATTERN: pset_pattern(x,y,color); break;
+                    default: pset_bool(x,y,color); break;
+                }
+            }
+
+            // Per a les funcions que van canviant de color (surf.pixel i draw.surf, bàsicament)
+            static inline void subst_pset(int x, int y, uint8_t color) {
+                direct_pset(x, y, state.draw_palette[color]);
+            }
+
+            void set(int x, int y, uint8_t color) {
+                subst_pset(x,y,color);
+            }
+
+            uint8_t get(int x, int y) {
+                if (!surf::state.source_surface) return 0;
+                if (x < 0 || x > (surf::state.source_surface->w-1) || y < 0 || y > (surf::state.source_surface->h-1)) return 0;
+                return SOURCE(x, y);
+            }
+        }
+
+        // Bresenham Line Algorithm
+        void line(int x0, int y0, int x1, int y1, uint8_t color) {
+            int		x, y;
+            int		dx, dy;
+            int		incx, incy;
+            int		balance;
+            color = state.draw_palette[color];
+
+            if (x1 >= x0) { dx = x1 - x0; incx = 1; } else { dx = x0 - x1; incx = -1; }
+            if (y1 >= y0) { dy = y1 - y0; incy = 1; } else { dy = y0 - y1; incy = -1; }
+
+            x = x0; y = y0;
+
+            if (dx >= dy) {
+                dy <<= 1;
+                balance = dy - dx;
+                dx <<= 1;
+
+                while (x != x1) {
+                    pixel::direct_pset(x, y, color);
+                    if (balance >= 0) { y += incy; balance -= dx; }
+                    balance += dy;
+                    x += incx;
+                }
+                pixel::direct_pset(x, y, color);
+            } else {
+                dx <<= 1;
+                balance = dx - dy;
+                dy <<= 1;
+
+                while (y != y1) {
+                    pixel::direct_pset(x, y, color);
+                    if (balance >= 0) { x += incx; balance -= dy; }
+                    balance += dx;
+                    y += incy;
+                }
+                pixel::direct_pset(x, y, color);
+            }
+        }
+
+        void hline(int x0, int y, int x1, uint8_t color) {
+            color = state.draw_palette[color];
+            if (x0>x1) { const int tmp=x0;x0=x1;x1=tmp; }
+            for (int x=x0; x<=x1; ++x) pixel::direct_pset(x, y, color);
+        }
+
+        void vline(int x, int y0, int y1, uint8_t color) {
+            color = state.draw_palette[color];
+            if (y0>y1) { const int tmp=y0;y0=y1;y1=tmp; }
+            for (int y=y0; y<=y1; ++y) pixel::direct_pset(x, y, color);
+        }
+
+        void rect(int x, int y, int w, int h, uint8_t color) {
+            int x1 = w+x-1;
+            int y1 = h+y-1;
+            hline(x, y, x1, color);
+            hline(x, y1, x1, color);
+            vline(x, y, y1, color);
+            vline(x1, y, y1, color);
+        }
+
+        void rectf(int x, int y, int w, int h, uint8_t color) {
+            int x1 = w+x-1;
+            int y1 = h+y-1;
+            for (int i=y; i<=y1; ++i) hline(x, i, x1, color);
+        }
+
+        static inline void circ_scanline(int xc, int yc, int x, int y, uint8_t color) {
+            pixel::direct_pset(xc+x, yc+y, color);
+            pixel::direct_pset(xc-x, yc+y, color);
+            pixel::direct_pset(xc+x, yc-y, color);
+            pixel::direct_pset(xc-x, yc-y, color);
+            pixel::direct_pset(xc+y, yc+x, color);
+            pixel::direct_pset(xc-y, yc+x, color);
+            pixel::direct_pset(xc+y, yc-x, color);
+            pixel::direct_pset(xc-y, yc-x, color);
+        }
+
+        void circ(int x, int y, uint8_t r, uint8_t color) {
+            color = state.draw_palette[color];
+            int xi=0, yi=r;
+            int d=3-2*r;
+            circ_scanline(x, y, xi, yi, color);
+            while (yi>=xi++) {
+                d += d>0 ? 4*(xi-yi--)+10 : 4*xi+6;
+                circ_scanline(x, y, xi, yi, color);
+            }
+        }
+
+        static inline void circf_scanline(int xc, int yc, int x, int y, uint8_t color) {
+            hline(xc-x, yc+y, xc+x, color);
+            hline(xc-x, yc-y, xc+x, color);
+            hline(xc-y, yc+x, xc+y, color);
+            hline(xc-y, yc-x, xc+y, color);
+        }
+
+        void circf(int x, int y, uint8_t r, uint8_t color) {
+            int xi=0, yi=r;
+            int d=3-2*r;
+            circf_scanline(x, y, xi, yi, color);
+            while (yi>=xi++) {
+                d += d>0 ? 4*(xi-yi--)+10 : 4*xi+6;
+                circf_scanline(x, y, xi, yi, color);
+            }
+        }
+
+        void roundrect(int x, int y, int w, int h, uint8_t r, uint8_t color) {
+            int xi=0, yi=r;
+            int d=3-2*r;
+
+            int xf = w+x-1;
+            int yf = h+y-1;
+            int x1 = x+r, y1 = y+r;
+            int x2 = xf-r, y2 = yf-r;
+            hline(x1, y, x2, color);
+            hline(x1, yf, x2, color);
+            vline(x, y1, y2, color);
+            vline(xf, y1, y2, color);
+
+            color = state.draw_palette[color];
+            while (yi>=xi++) {
+                d += d>0 ? 4*(xi-yi--)+10 : 4*xi+6;
+                pixel::direct_pset(x2+xi, y2+yi, color);
+                pixel::direct_pset(x1-xi, y2+yi, color);
+                pixel::direct_pset(x2+xi, y1-yi, color);
+                pixel::direct_pset(x1-xi, y1-yi, color);
+                pixel::direct_pset(x2+yi, y2+xi, color);
+                pixel::direct_pset(x1-yi, y2+xi, color);
+                pixel::direct_pset(x2+yi, y1-xi, color);
+                pixel::direct_pset(x1-yi, y1-xi, color);
+            }
+        }
+
+        void roundrectf(int x, int y, int w, int h, uint8_t r, uint8_t color) {
+            int xi=0, yi=r;
+            int d=3-2*r;
+
+            int xf = w+x-1;
+            int yf = h+y-1;
+            int x1 = x+r, y1 = y+r;
+            int x2 = xf-r, y2 = yf-r;
+            for (int i=y1; i<=y2; ++i) hline(x, i, xf, color);
+
+            while (yi>=xi++) {
+                d += d>0 ? 4*(xi-yi--)+10 : 4*xi+6;
+                hline(x1-xi, y2+yi, x2+xi, color);
+                hline(x1-xi, y1-yi, x2+xi, color);
+                hline(x1-yi, y2+xi, x2+yi, color);
+                hline(x1-yi, y1-xi, x2+yi, color);
+            }
+        }
+
+        void oval_scanline(int xc, int yc, int x, int y, float xf, float yf, uint8_t color) {
+            pixel::direct_pset((xc+x)*xf, (yc+y)*yf, color);
+            pixel::direct_pset((xc-x)*xf, (yc+y)*yf, color);
+            pixel::direct_pset((xc+x)*xf, (yc-y)*yf, color);
+            pixel::direct_pset((xc-x)*xf, (yc-y)*yf, color);
+            pixel::direct_pset((xc+y)*xf, (yc+x)*yf, color);
+            pixel::direct_pset((xc-y)*xf, (yc+x)*yf, color);
+            pixel::direct_pset((xc+y)*xf, (yc-x)*yf, color);
+            pixel::direct_pset((xc-y)*xf, (yc-x)*yf, color);
+        }
+
+        void oval(int x0, int y0, int x1, int y1, uint8_t color) {
+            color = state.draw_palette[color];
+            int rx = (x1-x0)/2;
+            int ry = (y1-y0)/2;
+            int r = rx;
+            int x = x0 + rx;
+            int y = y0 + ry;
+            float xf = 1.0f, yf = 1.0f;
+            if (rx>=ry) {r=rx;yf=float(ry)/float(rx);} else {r=ry;xf=float(rx)/float(ry);}
+            int xi=0, yi=r;
+            int d=3-2*r;
+            oval_scanline(x, y, xi, yi, xf, yf, color);
+            while (yi>=xi++) {
+                d += d>0 ? 4*(xi-yi--)+10 : 4*xi+6;
+                oval_scanline(x, y, xi, yi, xf, yf, color);
+            }
+        }
+
+        static inline void ovalf_scanline(int xc, int yc, int x, int y, float xf, float yf, uint8_t color) {
+            hline((xc-x)*xf, (yc+y)*yf, (xc+x)*xf, color);
+            hline((xc-x)*xf, (yc-y)*yf, (xc+x)*xf, color);
+            hline((xc-y)*xf, (yc+x)*yf, (xc+y)*xf, color);
+            hline((xc-y)*xf, (yc-x)*yf, (xc+y)*xf, color);
+        }
+
+        void ovalf(int x0, int y0, int x1, int y1, uint8_t color) {
+            int rx = (x1-x0)/2;
+            int ry = (y1-y0)/2;
+            int r = rx;
+            int x = x0 + rx;
+            int y = y0 + ry;
+            float xf = 1.0f, yf = 1.0f;
+            if (rx>=ry) {r=rx;yf=float(ry)/float(rx);} else {r=ry;xf=float(rx)/float(ry);}
+            int xi=0, yi=r;
+            int d=3-2*r;
+            ovalf_scanline(x, y, xi, yi, xf, yf, color);
+            while (yi>=xi++) {
+                d += d>0 ? 4*(xi-yi--)+10 : 4*xi+6;
+                ovalf_scanline(x, y, xi, yi, xf, yf, color);
+            }
+        }
+
+        namespace pattern {
+            void set(uint16_t pat, bool transparent) {
+                state.fill_pattern = pat;
+            }
+        }
+
+        void surf(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, bool flip_x, bool flip_y, bool invert) {
+            if (dw == 0) dw = sw;
+            if (dh == 0) dh = sh;
+
+            // 16.16 fixed point
+            int sdx = (sw << 16) / dw;
+            int sdy = (sh << 16) / dh;
+
+            if (flip_x) sdx = -sdx;
+            if (flip_y) sdy = -sdy;
+
+            int ssx = flip_x ? ((sx + sw - 1) << 16) : (sx << 16);
+            int ssy = flip_y ? ((sy + sh - 1) << 16) : (sy << 16);
+
+            int csy = ssy;
+
+            if (!invert) {
+                for (int y = dy; y < dy + dh; ++y) {
+                    int csx = ssx;
+                    for (int x = dx; x < dx + dw; ++x) {
+                        uint8_t color = pixel::get(csx >> 16, csy >> 16);
+                        pixel::subst_pset(x, y, color);
+                        csx += sdx;
+                    }
+                    csy += sdy;
+                }
+            } else {
+                for (int y = dy; y < dy + dh; ++y) {
+                    int csx = ssx;
+                    for (int x = dx; x < dx + dw; ++x) {
+                        uint8_t color = pixel::get(csy >> 16, csx >> 16);
+                        pixel::subst_pset(x, y, color);
+                        csx += sdx;
+                    }
+                    csy += sdy;
+                }
+            }
+        }
+
+        void surfrot(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, bool flip_x, bool flip_y, float angle_deg) {
+            if (dw == 0) dw = sw;
+            if (dh == 0) dh = sh;
+
+            // Centro del destino (rectángulo sin rotar)
+            float dcx = dx + dw * 0.5f;
+            float dcy = dy + dh * 0.5f;
+
+            // Centro del subrectángulo origen
+            float scx = sx + sw * 0.5f;
+            float scy = sy + sh * 0.5f;
+
+            // Escalado destino -> origen
+            float inv_scale_x = float(sw) / float(dw);
+            float inv_scale_y = float(sh) / float(dh);
+
+            // Flips integrados en la escala
+            if (flip_x) inv_scale_x = -inv_scale_x;
+            if (flip_y) inv_scale_y = -inv_scale_y;
+
+            // Ángulo en radianes
+            float a  = angle_deg * 3.14159265f / 180.0f;
+            float ca = SDL_cosf(a);
+            float sa = SDL_sinf(a);
+
+            // --- 1. Bounding box rotado del rectángulo destino ---
+
+            float hx = dw * 0.5f;
+            float hy = dh * 0.5f;
+
+            float vx[4] = { -hx,  hx, -hx,  hx };
+            float vy[4] = { -hy, -hy,  hy,  hy };
+
+            float min_x =  1e9f, max_x = -1e9f;
+            float min_y =  1e9f, max_y = -1e9f;
+
+            for (int i = 0; i < 4; ++i) {
+                float rr_x = vx[i] * ca - vy[i] * sa;
+                float rr_y = vx[i] * sa + vy[i] * ca;
+
+                float dxp = dcx + rr_x;
+                float dyp = dcy + rr_y;
+
+                if (dxp < min_x) min_x = dxp;
+                if (dxp > max_x) max_x = dxp;
+                if (dyp < min_y) min_y = dyp;
+                if (dyp > max_y) max_y = dyp;
+            }
+
+            int bb_x0 = (int)SDL_floorf(min_x);
+            int bb_x1 = (int)SDL_ceilf (max_x);
+            int bb_y0 = (int)SDL_floorf(min_y);
+            int bb_y1 = (int)SDL_ceilf (max_y);
+
+            // --- 2. Rotación inversa + escalado + clipping estricto ---
+
+            for (int y = bb_y0; y <= bb_y1; ++y) {
+                for (int x = bb_x0; x <= bb_x1; ++x) {
+
+                    // Coordenadas relativas al centro destino
+                    float rx = x - dcx;
+                    float ry = y - dcy;
+
+                    // Rotación inversa
+                    float ux =  rx * ca + ry * sa;
+                    float uy = -rx * sa + ry * ca;
+
+                    // Escalado destino -> origen (con flips)
+                    float sxp = scx + ux * inv_scale_x;
+                    float syp = scy + uy * inv_scale_y;
+
+                    // Clipping estricto al subrectángulo origen
+                    if (sxp < sx || sxp >= sx + sw ||
+                        syp < sy || syp >= sy + sh)
+                        continue; // no pintamos nada
+
+                    uint8_t color = pixel::get((int)sxp, (int)syp);
+                    pixel::subst_pset(x, y, color);
+                }
+            }
+        }
+
+        const uint8_t printchar(uint8_t c, int x, int y) {
+            font::char_t &chr = font::current_font->chars[c];
+            draw::surf(chr.x, chr.y, chr.w, chr.h, x, y-chr.base);
+            return chr.w;
+        }
+
+        void text(const char* str, int x, int y, uint8_t color) {
+            
+            const unsigned char* p = (const unsigned char*)str;
+            uint8_t cp;
+            uint8_t xpos = x;
+
+            uint8_t old_source = surf::source::get();
+            surf::source::set(font::current_font->surface);
+            uint8_t old_color = state.draw_palette[1];
+            state.draw_palette[1] = color;
+            uint8_t old_trans = state.trans;
+            state.trans = 0;
+            while (p[0]!=0) {
+                if (p[0] < 0x80) {
+                    cp = p[0];
+                    p+=1;
+                } else if ((p[0] & 0xE0) == 0xC0) {
+                    cp = (p[0] << 6) | (p[1] & 0x3F);
+                    p+=2;
+                }
+                xpos += printchar(cp, xpos, y) + font::current_font->spacing;
+            }
+            state.trans = old_trans;
+            state.draw_palette[1] = old_color;
+            surf::source::set(old_source);
+        }
+
+        namespace mode {
+            void set(uint8_t mode) {
+                state.mode = mode;
+            }
+        }
+    }
+}

source/mini/draw/draw.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <stdint.h>
+
+#define DRAWMODE_NORMAL 0
+#define DRAWMODE_PATTERN 1
+#define DRAWMODE_AND 2
+#define DRAWMODE_OR 3
+#define DRAWMODE_XOR 4
+#define DRAWMODE_NOT 5
+
+namespace mini
+{
+    namespace draw
+    {
+        struct state_t {
+            uint8_t     trans = 0;
+            uint16_t    fill_pattern = 0b1111111111111111;
+            uint8_t     draw_palette[256];
+            uint8_t     mode = DRAWMODE_NORMAL;
+        };
+        extern state_t state;
+
+        namespace pixel {
+            void set(int x, int y, uint8_t color);
+            uint8_t get(int x, int y);
+        }
+
+        void line(int x0, int y0, int x1, int y1, uint8_t color);
+        void hline(int x0, int y, int x1, uint8_t color);
+        void vline(int x, int y0, int y1, uint8_t color);
+
+        void rect(int x, int y, int w, int h, uint8_t color);
+        void rectf(int x, int y, int w, int h, uint8_t color);
+
+        void circ(int x, int y, uint8_t r, uint8_t color);
+        void circf(int x, int y, uint8_t r, uint8_t color);
+
+        void roundrect(int x, int y, int w, int h, uint8_t r, uint8_t color);
+        void roundrectf(int x, int y, int w, int h, uint8_t r, uint8_t color);
+        void oval(int x0, int y0, int x1, int y1, uint8_t color);
+        void ovalf(int x0, int y0, int x1, int y1, uint8_t color);
+
+        namespace pattern {
+            void set(uint16_t pat, bool transparent = false);
+        }
+
+        void surf(int sx, int sy, int sw, int sh, int dx, int dy, int dw=0, int dh=0, bool flip_x = false, bool flip_y = false, bool invert = false);
+        void surfrot(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, bool flip_x, bool flip_y, float angle_deg);
+
+        void text(const char *str, int x, int y, uint8_t color);
+
+        namespace mode
+        {
+            void set(uint8_t mode);
+        }
+    }
+}

source/mini/file/file.cpp

@@ -0,0 +1,390 @@
+#include "file.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <iostream>
+#include <fstream>
+#include <filesystem>
+#include <string>
+#include <algorithm>
+#include <dirent.h>
+
+#ifndef _WIN32
+#include <pwd.h>
+#endif
+
+#define DEFAULT_FILENAME    "data.jf2"
+#define DEFAULT_FOLDER      "data/"
+#define CONFIG_FILENAME      "config.txt"
+
+namespace mini
+{
+	namespace file
+	{
+		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 setresourcefilename(const char *str) {
+			if (resource_filename != NULL) free(resource_filename);
+			resource_filename = (char*)malloc(strlen(str)+1);
+			strcpy(resource_filename, str);
+		}
+
+		void setresourcefolder(const char *str) {
+			if (resource_folder != NULL) free(resource_folder);
+			resource_folder = (char*)malloc(strlen(str)+1);
+			strcpy(resource_folder, str);
+		}
+
+		void 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) setresourcefolder(DEFAULT_FOLDER);
+		}
+
+		bool getdictionary() {
+			if (resource_filename == NULL) 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 = (char*)malloc(path_size+1);
+				fi.read( file_name, path_size );
+				file_name[path_size] = 0;
+				std::string filename = file_name;
+				free(file_name);
+				toc.push_back({filename, file_size, file_offset});
+			}
+			fi.close();
+			return true;
+		}
+
+		char *getfilenamewithfolder(const char* filename) {
+			strcpy(scratch, resource_folder);
+			strcat(scratch, filename);
+			return scratch;
+		}
+
+		FILE *getfilepointer(const char *resourcename, int& filesize, const bool binary) {
+
+			if (file_source==SOURCE_FILE and toc.size()==0) {
+				if (not getdictionary()) 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(getfilenamewithfolder(resourcename), binary?"rb":"r");
+				fseek(f, 0, SEEK_END);
+				filesize = ftell(f);
+				fseek(f, 0, SEEK_SET);
+			}
+			return f;
+		}
+
+		char *getfilebuffer(const char *resourcename, int& filesize, const bool zero_terminate) {
+			FILE *f = 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;
+		}
+
+		FILE *getfilepointerex(const char *filename, int& filesize, const bool binary) {
+
+			FILE *f;
+			f = fopen(filename, binary?"rb":"r");
+			fseek(f, 0, SEEK_END);
+			filesize = ftell(f);
+			fseek(f, 0, SEEK_SET);
+			return f;
+		}
+
+		char *getfilebufferex(const char *filename, int& filesize, const bool zero_terminate) {
+			FILE *f = getfilepointerex(filename, 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
+		void 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) + "/." + foldername;
+			config_folder = std::string(homedir) + "/.config/jailgames/" + foldername;
+
+			{
+				// Intenta crear ".config", per si no existeix
+				std::string config_base_folder = std::string(homedir) + "/.config";
+				int ret = mkdir(config_base_folder.c_str(), S_IRWXU);
+				if (ret == -1 && errno != EEXIST)
+				{
+					printf("ERROR CREATING CONFIG BASE FOLDER.");
+					exit(EXIT_FAILURE);
+				}
+			}
+			{
+				// Intenta crear ".config/jailgames", per si no existeix
+				std::string config_base_folder = std::string(homedir) + "/.config/jailgames";
+				int ret = mkdir(config_base_folder.c_str(), S_IRWXU);
+				if (ret == -1 && errno != EEXIST)
+				{
+					printf("ERROR CREATING CONFIG BASE FOLDER.");
+					exit(EXIT_FAILURE);
+				}
+			}
+
+		#endif
+
+			struct stat st = {0};
+			if (stat(config_folder.c_str(), &st) == -1)
+			{
+		#ifdef _WIN32
+				int ret = mkdir(config_folder.c_str());
+		#else
+				int ret = mkdir(config_folder.c_str(), S_IRWXU);
+		#endif
+
+				if (ret == -1)
+				{
+					printf("ERROR CREATING CONFIG FOLDER.");
+					exit(EXIT_FAILURE);
+				}
+			}
+		}
+
+		const char *getconfigfolder() {
+			static std::string folder = config_folder + "/";
+			return folder.c_str();
+		}
+
+		void 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 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* getconfigvalue(const char *key) {
+			if (config.empty()) loadconfigvalues();
+			for (auto pair : config) {
+				if (pair.key == std::string(key)) {
+					strcpy(scratch, pair.value.c_str());
+					return scratch;
+				}
+			}
+			return NULL;
+		}
+
+		void setconfigvalue(const char* key, const char* value) {
+			if (config.empty()) loadconfigvalues();
+			for (auto &pair : config) {
+				if (pair.key == std::string(key)) {
+					pair.value = value;
+					saveconfigvalues();
+					return;
+				}
+			}
+			config.push_back({key, value});
+			saveconfigvalues();
+			return;
+		}
+
+		bool createFolder(const char* name) {
+			char tmp[256];
+			strcpy(tmp, "./");
+			strcat(tmp, name);
+		#ifdef _WIN32
+			return mkdir(tmp)==0;
+		#else
+			return mkdir(tmp, 0755)==0;
+		#endif
+		}
+
+		static bool has_extension(const std::string &name, const char *ext)
+		{
+			if (!ext) return true; // sin filtro
+
+			std::string e = ext;
+			std::string suffix = "." + e;
+
+			if (name.size() < suffix.size())
+				return false;
+
+			return (name.compare(name.size() - suffix.size(), suffix.size(), suffix) == 0);
+		}
+
+		std::vector<std::string> listresourcesdir(const char *folder, const char *extension)
+		{
+			std::vector<std::string> result;
+			std::string base(folder);
+
+			// Normalizar: quitar "/" final si existe
+			if (!base.empty() && base.back() == '/')
+				base.pop_back();
+
+			// -------------------------------
+			// 1. MODO: ARCHIVOS SUELTOS
+			// -------------------------------
+			if (file_source == SOURCE_FOLDER)
+			{
+				std::string fullpath = std::string(resource_folder) + base;
+
+				DIR *dir = opendir(fullpath.c_str());
+				if (!dir)
+					return result;
+
+				struct dirent *entry;
+				while ((entry = readdir(dir)) != nullptr)
+				{
+					std::string name = entry->d_name;
+
+					// Ignorar "." y ".."
+					if (name == "." || name == "..")
+						continue;
+
+					// Ignorar subdirectorios
+					std::string full = fullpath + "/" + name;
+					DIR *test = opendir(full.c_str());
+					if (test)
+					{
+						closedir(test);
+						continue; // es un directorio
+					}
+
+					// Filtrar por extensión
+					if (!has_extension(name, extension))
+						continue;
+
+					result.push_back(name);
+				}
+
+				closedir(dir);
+				return result;
+			}
+
+			// -------------------------------
+			// 2. MODO: ARCHIVO CONTENEDOR
+			// -------------------------------
+			if (file_source == SOURCE_FILE)
+			{
+				std::string prefix = base + "/";
+
+				for (auto &f : toc)
+				{
+					const std::string &path = f.path;
+
+					// Debe empezar por "folder/"
+					if (path.compare(0, prefix.size(), prefix) != 0)
+						continue;
+
+					// Extraer la parte después de "folder/"
+					std::string rest = path.substr(prefix.size());
+
+					// Ignorar subdirectorios
+					if (rest.find('/') != std::string::npos)
+						continue;
+
+					// Filtrar por extensión
+					if (!has_extension(rest, extension))
+						continue;
+
+					result.push_back(rest);
+				}
+
+				return result;
+			}
+
+			return result;
+		}
+	}
+}

source/mini/file/file.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <vector>
+#include <string>
+
+#define SOURCE_FILE         0
+#define SOURCE_FOLDER       1
+
+namespace mini
+{
+    namespace file
+    {
+        void setconfigfolder(const char *foldername);
+        const char *getconfigfolder();
+
+        void setresourcefilename(const char *str);
+        void setresourcefolder(const char *str);
+        void setsource(const int src);
+
+        FILE *getfilepointer(const char *resourcename, int& filesize, const bool binary=false);
+        char *getfilebuffer(const char *resourcename, int& filesize, const bool zero_terminate=false);
+
+        FILE *getfilepointerex(const char *filename, int& filesize, const bool binary=false);
+        char *getfilebufferex(const char *filename, int& filesize, const bool zero_terminate=false);
+
+        const char* getconfigvalue(const char *key);
+        void setconfigvalue(const char* key, const char* value);
+
+        bool createFolder(const char* name);
+        std::vector<std::string> listresourcesdir(const char *folder, const char *extension=NULL);
+    }
+}

source/mini/font/font.cpp

@@ -0,0 +1,121 @@
+#include "font.h"
+#include "mini/surf/surf.h"
+#include "mini/file/file.h"
+#include "aux/log.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define MAX_FONTS 5
+
+namespace mini
+{
+    namespace font
+    {
+        font_t fonts[MAX_FONTS];
+        font_t *current_font;
+
+        uint8_t load_from_buffer(const char* buffer, uint8_t index, const char* name) {
+            if (!buffer) return false;
+
+            const char* ptr = buffer;
+            char line[256];
+
+            // --- Read first line ---
+            {
+                // Extract line
+                int len = 0;
+                while (ptr[len] && ptr[len] != '\n' && len < 255) len++;
+
+                memcpy(line, ptr, len);
+                line[len] = '\0';
+                ptr += (ptr[len] == '\n') ? len + 1 : len; // Advance pointer
+                if (len > 0 && line[len - 1] == '\r') line[len - 1] = '\0';
+
+                if (strncmp(line, "bitmap=", 7) != 0) return false; // Parse first line
+
+                fonts[index].surface = surf::load(line + 7);
+
+                fonts[index].name = (char*)malloc(strlen(name)+1);
+                strcpy(fonts[index].name, name);
+            }
+
+            // --- Read character lines ---
+            while (*ptr) {
+                // Extract next line
+                int len = 0;
+                while (ptr[len] && ptr[len] != '\n' && len < 255) len++;
+
+                memcpy(line, ptr, len);
+                line[len] = '\0';
+                ptr += (ptr[len] == '\n') ? len + 1 : len; // Advance pointer
+                if (len > 0 && line[len - 1] == '\r') line[len - 1] = '\0';
+
+                // Remove comments
+                char* hash = strchr(line, '#');
+                if (hash) *hash = '\0';
+
+                // Parse
+                int code, x, y, w, h, base;
+                if (sscanf(line, "%d: %d %d %d %d %d", &code, &x, &y, &w, &h, &base) == 6) {
+                    if (code >= 0 && code < 256) {
+                        fonts[index].chars[code] = { (uint8_t)x, (uint8_t)y, (uint8_t)w, (uint8_t)h, (uint8_t)base };
+                    }
+                }
+            }
+            return index;
+        }
+
+        uint8_t load(const char *filename) {
+            // Si la font ja s'ha carregat, tornem eixa font
+            for (unsigned int i=0; i<MAX_FONTS; ++i)
+                if (fonts[i].name && strcmp(fonts[i].name, filename)==0) {
+                    log_msg(LOG_INFO, "Carrega de '%s' abortada: Reusant: %i.\n", filename, i);
+                    return i;
+                }
+
+            // Agafar la pròxima font lliure
+            unsigned int i = 0;
+            while (i<MAX_FONTS && fonts[i].name != NULL) ++i;
+            if (i==MAX_FONTS) return 255;
+
+            // Carregar l'arxiu de disc
+            int size;
+            char *buffer;
+            buffer = file::getfilebuffer(filename, size);
+
+            // Si no s'ha pogut, petar
+            if (!buffer) {
+                log_msg(LOG_FAIL, "Error al intentar obrir l'arxiu '%s'\n", filename);
+                exit(-1);
+                return 255;
+            }
+
+            load_from_buffer(buffer, i, filename);
+            free(buffer);
+            
+            log_msg(LOG_INFO, "Arxiu '%s' carregat en font: %i.\n", filename, i);
+            return i;
+        }
+
+        namespace current {
+            void set(uint8_t font) {
+                current_font = &fonts[font];
+            }
+            uint8_t get() {
+                for (unsigned int i=0; i<MAX_FONTS; ++i) if (current_font == &fonts[i]) return i;
+                return 0;
+            }
+        }
+
+        namespace spacing {
+            void set(uint8_t spacing) {
+                current_font->spacing = spacing;
+            }
+            uint8_t get() {
+                return current_font->spacing;
+            }
+        }
+    }
+}

source/mini/font/font.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <stdint.h>
+
+namespace mini
+{
+    namespace font
+    {
+        struct char_t {
+            uint8_t x,y,w,h,base;
+        };
+
+        struct font_t {
+            char    *name {nullptr};
+            uint8_t surface {0};
+            uint8_t spacing {1};
+            char_t  chars[256];
+        };
+        extern font_t *current_font;
+
+        uint8_t load(const char *filename);
+
+        namespace current {
+            void set(uint8_t font);
+            uint8_t get();
+        }
+
+        namespace spacing {
+            void set(uint8_t spacing);
+            uint8_t get();
+        }
+    }
+}

source/mini/key/key.cpp

@@ -0,0 +1,49 @@
+#include "key.h"
+#include "mini/pad/pad.h"
+
+#include <SDL3/SDL.h>
+
+namespace mini
+{
+    namespace key
+    {
+        state_t state;
+
+        bool down(uint8_t i) {
+            return state.keys[i];
+        }
+
+        bool press(uint8_t i) {
+            if (state.just_pressed == i) {
+                state.just_pressed=0;
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        int press() {
+            return state.just_pressed;
+        }
+
+        bool any() {
+            const bool something_pressed = (state.just_pressed != 0) || (pad::state.just_pressed != -1);
+            state.just_pressed=0;
+            pad::state.just_pressed=-1;
+            return something_pressed;
+        }
+
+        void text(const bool enable) {
+            // [TODO]
+            //if (enable)
+            //    SDL_StartTextInput(mini_win);
+            //else
+            //    SDL_StopTextInput(mini_win);
+        }
+
+        const char* utf8char() {
+            return state.has_text_input ? state.text_input_buffer : nullptr;
+        }
+
+    }
+}

source/mini/key/key.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <stdint.h>
+
+namespace mini
+{
+    namespace key
+    {
+        struct state_t {
+            const bool *keys;
+            uint8_t just_pressed = 0;
+            char text_input_buffer[10];
+            bool has_text_input = false;
+        };
+        extern state_t state;
+
+        bool down(uint8_t i);
+        bool press(uint8_t i);
+        int press();
+        bool any();
+        void text(const bool enable);
+        const char *utf8char();
+     }
+}

source/mini/lua/lua.cpp

@@ -0,0 +1,171 @@
+#include "lua.h"
+#include "lua.wrappers.h"
+#include "lua.debug.h"
+#include "external/lua/lua.hpp"
+#include "mini/file/file.h"
+#include "aux/log.h"
+
+#include <algorithm>
+#include <unistd.h>
+
+namespace mini
+{
+    namespace lua
+    {
+        lua_State *L;
+        bool is_playing = false;
+        bool init_exists = false;
+        bool update_exists = false;
+
+        bool running() {
+            debug::process_commands(L);
+            return is_playing;
+        }
+
+        int MiniLoader(lua_State *L) {
+            const char *name = luaL_checkstring(L, 1);
+
+            // 1. Convertir puntos en barras
+            std::string path(name);
+            std::string regpath(name);
+            std::replace(path.begin(), path.end(), '.', '/');
+
+            // 2. Detectar comodín "/*"
+            bool load_all = false;
+            if (path.size() >= 2 && path.substr(path.size()-2) == "/*") {
+                load_all = true;
+                path = path.substr(0, path.size()-2); // quitar "/*"
+                regpath = regpath.substr(0, regpath.size()-2); // quitar "/*"
+            }
+
+            if (load_all) {
+                std::vector<std::string> files = file::listresourcesdir(path.c_str(), "lua");
+
+                // Ejecutar todos los módulos
+                for (auto &f : files) {
+                    std::string fullpath = path + "/" + f;
+                    std::string registerpath = std::string(regpath + "." + f.substr(0,f.size()-4));
+
+                    int size;
+                    char* buffer = file::getfilebuffer(fullpath.c_str(), size);
+                    if (!buffer) continue;
+
+                    if (luaL_loadbuffer(L, buffer, size, registerpath.c_str()) == LUA_OK) {
+                        lua_pcall(L, 0, 0, 0); // ejecutar módulo, sin devolver nada
+                        lua_getglobal(L, "package");
+                        lua_getfield(L, -1, "loaded");
+                        lua_pushboolean(L, 1);
+                        lua_setfield(L, -2, registerpath.c_str());
+                        lua_pop(L, 2);
+                    } else {
+                        log_msg(LOG_LUALD, "Error cargando %s: %s\n", fullpath.c_str(), lua_tostring(L, -1));
+                        lua_pop(L, 1);
+                    }
+
+                    free(buffer);
+                }
+
+                // Devolver un loader vacío
+                lua_pushcfunction(L, [](lua_State* L) -> int {
+                    lua_pushboolean(L, 1); // require devuelve true
+                    return 1;
+                });
+
+                return 1;
+            }
+
+            // 3. Cargar un único archivo
+            std::string filename = path + ".lua";
+
+            int size;
+            char* buffer = file::getfilebuffer(filename.c_str(), size);
+            if (!buffer) {
+                lua_pushnil(L);
+                return 1;
+            }
+
+            if (luaL_loadbuffer(L, buffer, size, name)) {
+                log_msg(LOG_LUALD, "%s\n", lua_tostring(L, -1));
+                lua_pop(L, 1);
+                free(buffer);
+                lua_pushnil(L);
+                return 1;
+            }
+
+            free(buffer);
+            return 1;
+        }
+
+        void init(const char *main_lua_file) {
+            L = luaL_newstate();
+            luaL_openlibs(L);
+
+            push_functions(L);
+            lua_register(L, "mini_loader", MiniLoader);
+            luaL_dostring(L, "table.insert(package.searchers,2,mini_loader)\n");
+
+            int size;
+            char* buffer = file::getfilebuffer(main_lua_file, size);
+            if (luaL_loadbuffer(L, buffer, size, "main")) {
+                log_msg(LOG_LUALD, "%s\n", lua_tostring(L, -1));
+                lua_pop(L,1);
+                return;
+            }
+            free(buffer);
+            if (lua_pcall(L,0, LUA_MULTRET, 0)) {
+                //luaL_traceback(L, L, NULL, 1);
+                log_msg(LOG_LUART, "%s\n", lua_tostring(L, -1));
+                lua_pop(L,1);
+                return;
+            }
+
+            // Check if _init and _update exist
+            lua_getglobal(L, "mini");
+            lua_getfield(L, -1, "init");
+            if (lua_isfunction(L,-1)) init_exists = true;
+            lua_pop(L,1);
+            lua_pop(L,1);
+
+            lua_getglobal(L, "mini");
+            lua_getfield(L, -1, "update");
+            if (lua_isfunction(L,-1)) update_exists = true;
+            lua_pop(L,1);
+            lua_pop(L,1);
+
+            //std::thread(debugCommandThread).detach();
+            printf("stdin isatty: %d\n", isatty(0));
+            is_playing = true;
+        }
+
+        void quit() {
+            if (!is_playing) return;
+            is_playing = false;
+            lua_close(L);
+        }
+
+        void cleanup() {
+            debug::kill_thread();
+        }
+
+        namespace callbacks
+        {
+            void init() {
+                if (!init_exists) return;
+                debug::process_commands(L);
+                lua_getglobal(L, "mini");
+                lua_getfield(L, -1, "init");
+
+                is_playing = debug::call_and_handle_exceptions(L);
+            }
+
+            void update() {
+                if (!update_exists) return;
+                lua_getglobal(L, "mini");
+                lua_getfield(L, -1, "update");
+
+                is_playing = debug::call_and_handle_exceptions(L);
+            }
+
+        }
+    }
+}

source/mini/lua/lua.debug.h

@@ -0,0 +1,17 @@
+#pragma once
+struct lua_State;
+
+namespace mini
+{
+    namespace lua
+    {
+        namespace debug
+        {
+            bool call_and_handle_exceptions(lua_State* L);
+            void kill_thread();
+            void process_commands(lua_State* L);
+            void toggle(lua_State* L);
+        }
+
+    }
+}

source/mini/lua/lua.h

@@ -0,0 +1,18 @@
+#pragma once
+
+namespace mini
+{
+    namespace lua
+    {
+        bool running();
+        void init(const char* main_lua_file = "main.lua");
+        void quit();
+        void cleanup();
+
+        namespace callbacks
+        {
+            void init();
+            void update();
+        }
+    }
+}

source/mini/lua/lua.wrappers.h

@@ -0,0 +1,11 @@
+#pragma once
+
+struct lua_State;
+
+namespace mini
+{
+    namespace lua
+    {
+        void push_functions(lua_State *L);
+    }
+}

source/mini/main.cpp

@@ -0,0 +1,31 @@
+#include "mini.h"
+#include "win/win.h"
+#include "view/view.h"
+
+uint16_t ants = 0xc936;
+float t = 0;
+
+using namespace mini;
+
+void exception_loop() {
+    //if (t==0) t= time();
+    if (sys::time()-t > 0.25) {
+        t = sys::time();
+        surf::clip::reset();
+        view::origin::set(0,0);
+        surf::target::set(0);
+        pal::trans::set(255);
+        pal::color::set(0,0xffffff00);
+        pal::color::set(1,0xff000000);
+        const int w=win::res::getw();
+        const int h=win::res::geth();
+        mini::draw::mode::set(0);
+        mini::draw::rect(0,0,w,h,1);
+        mini::draw::rect(1,1,w-2,h-2,1);
+        mini::draw::mode::set(1);
+        draw::pattern::set(ants);
+        mini::draw::rect(0,0,w,h,0);
+        mini::draw::rect(1,1,w-2,h-2,0);
+        ants = (ants<<12) | (ants>>4);
+    }
+}

source/mini/mini.cpp

@@ -0,0 +1,586 @@
+#include "mini.h"
+#include "version.h"
+
+#include "surf/surf.h"
+#include "font/font.h"
+#include "draw/draw.h"
+#include "win/win.h"
+#include "view/view.h"
+#include "shader/shader.h"
+#include "audio/audio.h"
+#include "mouse/mouse.h"
+#include "key/key.h"
+#include "pad/pad.h"
+
+#include "file/file.h"
+#include "lua/lua.h"
+#include "aux/log.h"
+#include "aux/default_font_gif.h"
+#include "aux/default_font_fnt.h"
+
+#include <SDL3/SDL.h>
+
+#include <string.h>
+
+
+
+
+#define UPDATE_ALWAYS   0
+#define UPDATE_WAIT     1
+#define UPDATE_TIMEOUT  2
+
+#ifdef MACOS_BUNDLE
+#include <libgen.h>
+#endif
+
+
+
+int         fps=0;
+
+char        config_folder[256];
+
+
+
+uint8_t     tile_width = 8;
+uint8_t     tile_height = 8;
+
+
+char        main_lua_file[200] = "main.lua";
+bool        override_ini = false;
+
+
+int update_mode = UPDATE_ALWAYS;
+int timeout = 0;
+uint32_t    last_update = 0;
+float       delta_time = 0.0f;
+
+bool should_exit = false;
+bool should_quit = false;
+
+Uint32 *pixels;
+int pitch;
+
+uint32_t palette[256] = { 0xFF1a1c2c, 0xFF5d275d, 0xFFb13e53, 0xFFef7d57, 0xFFffcd75, 0xFFa7f070, 0xFF38b764, 0xFF257179,
+                         0xFF29366f, 0xFF3b5dc9, 0xFF41a6f6, 0xFF73eff7, 0xFFf4f4f4, 0xFF94b0c2, 0xFF566c86, 0xFF333c57 };
+
+
+surf::surface_t*  map_surface = NULL;
+
+
+int16_t beats, num_beats = 0;
+
+void createNewProject();
+
+char* get_value_from_line(char* line) {
+    char* equal_character = strchr(line, '=');
+    if (equal_character == NULL) return NULL;
+    *equal_character = '\0';
+    return ++equal_character;
+}
+
+void read_ini() {
+    int size;
+    FILE *f = mini::file::getfilepointer("game.ini", size); // fopen("game.ini", "r");
+    char line[1024];
+    if (f == NULL) { log_msg(LOG_FAIL, "No s'ha pogut obrir 'game.ini'\n"); exit(-1); }
+    log_msg(LOG_OK, "'game.ini' carregat\n");
+    while (fgets(line, sizeof(line), f)) {
+        char *value = get_value_from_line(line);
+        if (value != NULL) {
+            value[strlen(value)-1] = '\0';
+            if (strcmp(line, "title") == 0) { strcpy(mini::win::state.title, value); log_msg(LOG_VERBOSE, "title = %s\n", mini::win::state.title); }
+            else if (strcmp(line, "config") == 0) { strcpy(config_folder, value); log_msg(LOG_VERBOSE, "config = %s\n", config_folder); }
+            else if (strcmp(line, "width") == 0) { mini::win::state.width = atoi(value); log_msg(LOG_VERBOSE, "screen width = %i\n", mini::win::state.width); }
+            else if (strcmp(line, "height") == 0) { mini::win::state.height = atoi(value); log_msg(LOG_VERBOSE, "screen height = %i\n", mini::win::state.height); }
+            else if (strcmp(line, "zoom") == 0) { mini::win::state.zoom = atoi(value); log_msg(LOG_VERBOSE, "screen zoom = %i\n", mini::win::state.zoom); }
+            else if (strcmp(line, "fullscreen") == 0) { mini::win::state.fullscreen = atoi(value); log_msg(LOG_VERBOSE, "screen sullscreen = %i\n", mini::win::state.fullscreen); }
+            //else if (strcmp(line, "files") == 0) {
+                //lua_files = (char*)malloc(strlen(value));
+            //    strcpy(lua_files, value);
+            //}
+        }
+    }
+    fclose(f);
+    //SDL_Log("'game.ini' carregat!\n");
+}
+
+#define TILES(x, y) map_surface->p[x+y*map_surface->w]
+#define CURRENT(x, y) surfaces[i].p[(x)+(y)*surfaces[i].w]
+
+namespace mini
+{
+
+    namespace map
+    {
+        namespace surf {
+            void set(uint8_t surface) {
+                map_surface = &mini::surf::state.surfaces[surface];
+            }
+
+            uint8_t get()
+            {
+                for (unsigned int i=0; i<MAX_SURFACES; ++i) if (map_surface == &mini::surf::state.surfaces[i]) return i;
+                return 0;
+            }
+        }
+
+        static inline void tileblit(uint8_t n, int x, int y) {
+            const int tw = tile_width;
+            const int th = tile_height;
+
+            const int tiles_per_row = mini::surf::state.source_surface->w / tw;
+
+            // Coordenadas del tile dentro del spritesheet
+            int tx = (n % tiles_per_row) * tw;
+            int ty = (n / tiles_per_row) * th;
+
+            int src_y = ty;
+
+            for (int yi = 0; yi < th; ++yi) {
+                int src_x = tx;
+
+                for (int xi = 0; xi < tw; ++xi) {
+                    uint8_t c = mini::draw::pixel::get(src_x, src_y);
+                    mini::draw::pixel::subst_pset(x + xi, y + yi, c);
+                    src_x++;
+                }
+
+                src_y++;
+            }
+        }
+
+        void draw() {
+            if (!map_surface || !mini::surf::state.source_surface) return;
+
+            const int tw = tile_width;
+            const int th = tile_height;
+
+            int celw = map_surface->w;
+            int celh = map_surface->h;
+
+            int celx = 0;
+            int cely = 0;
+
+            int ox = view::state.origin[0];
+            int oy = view::state.origin[1];
+
+            int sx = ox;
+            int sy = oy;
+
+            // Clipping global rápido
+            if (sx + celw * tw < mini::surf::state.dest_surface->clip[0] ||
+                sy + celh * th < mini::surf::state.dest_surface->clip[1] ||
+                sx > mini::surf::state.dest_surface->clip[2] ||
+                sy > mini::surf::state.dest_surface->clip[3])
+                return;
+
+            // Recorte por izquierda
+            if (sx < mini::surf::state.dest_surface->clip[0]) {
+                int diff = (mini::surf::state.dest_surface->clip[0] - sx) / tw;
+                celx += diff;
+                celw -= diff;
+                sx += diff * tw;
+            }
+
+            // Recorte por arriba
+            if (sy < mini::surf::state.dest_surface->clip[1]) {
+                int diff = (mini::surf::state.dest_surface->clip[1] - sy) / th;
+                cely += diff;
+                celh -= diff;
+                sy += diff * th;
+            }
+
+            // Recorte por derecha
+            int max_x = mini::surf::state.dest_surface->clip[2] - sx;
+            if (max_x < celw * tw) celw = max_x / tw + 1;
+
+            // Recorte por abajo
+            int max_y = mini::surf::state.dest_surface->clip[3] - sy;
+            if (max_y < celh * th) celh = max_y / th + 1;
+
+            // Ahora sx, sy son relativos al origen y ya están recortados
+            for (int y = 0; y < celh; ++y) {
+                int ty = sy + y * th;
+                for (int x = 0; x < celw; ++x) {
+                    uint8_t tile = tile::get(celx + x, cely + y);
+                    if (!tile) continue;
+                    int tx = sx + x * tw;
+                    tileblit(tile, tx - ox, ty - oy);
+                }
+            }
+        }
+
+        namespace tile {
+            uint8_t get(int celx, int cely) {
+                if (!map_surface) return 0;
+                if (celx < 0 || celx > (map_surface->w-1) || cely < 0 || cely > (map_surface->h-1)) return 0;
+                return TILES(celx, cely);
+            }
+
+            void set(int celx, int cely, uint8_t snum) {
+                if (!map_surface) return;
+                if (celx < 0 || celx > (map_surface->w-1) || cely < 0 || cely > (map_surface->h-1)) return;
+                TILES(celx, cely) = snum;
+            }
+        }
+
+        namespace cell {
+            uint8_t getw() { return tile_width; }
+            uint8_t geth() { return tile_height; }
+            
+            void set(int w, int h) {
+                tile_width = w;
+                tile_height = h;
+            }
+        }
+
+    }
+
+    namespace pal
+    {
+        uint32_t *load(const char* filename, uint16_t *palsize) {
+            int size;
+            uint8_t *buffer = (uint8_t*)file::getfilebuffer(filename, size);
+            // [TODO]
+            uint32_t *pal = nullptr; //LoadPalette(buffer, palsize);
+            free(buffer);
+            return pal;
+        }
+
+        void set(uint32_t *pal) {
+            for (int i=0; i<256; ++i) palette[i] = pal[i] | 0xff000000;
+        }
+
+        namespace color {
+            void set(uint8_t index, uint32_t color) {
+                palette[index] = color | 0xff000000;
+            }
+
+            uint32_t get(uint8_t index) {
+                return palette[index];
+            }
+        }
+
+        namespace trans {
+            void set(uint8_t index) {
+                ds::trans = index;
+            }
+
+            uint8_t get() {
+                return ds::trans;
+            }
+        }
+
+        namespace subpal {
+            uint8_t set(uint8_t index, uint8_t color) {
+                const uint8_t old = ds::draw_palette[SDL_clamp(index,0,255)];
+                ds::draw_palette[SDL_clamp(index,0,255)] = SDL_clamp(color,0,255);
+                return old;
+            }
+
+            void reset() {
+                for (int i=0;i<256;++i) ds::draw_palette[i]=i;
+            }
+        }
+    }
+
+
+
+    namespace sys
+    {
+        float delta() {
+            return delta_time;
+        }
+
+        float time() {
+            return float(SDL_GetTicks())/1000.0f;
+        }
+
+        bool beat(int16_t i) {
+            if (i<0) {
+                return beats==0;
+            } else {
+                beats=num_beats=i;
+                return false;
+            }
+        }
+
+        int getfps() {
+            return fps;
+        }
+
+        namespace update {
+            void set(const int value, const int t) {
+                update_mode = value;
+                timeout = t;
+            }
+            int get() {
+                return update_mode;
+            }
+        }
+
+        void exit() {
+            should_exit = true;
+            should_quit = true;
+        }
+    }
+
+
+}
+
+
+
+void reinit() {
+    log_msg(LOG_INFO, "STARTING A SYSTEM REINITIALIZATION\n");
+
+    // Reset view state
+    mini::view::init();
+
+    // Reset draw state
+    ds::mode = DRAWMODE_NORMAL;
+    ds::fill_pattern = 0b1111111111111111;
+
+    // Reset surf state
+    for (unsigned int i=0; i<MAX_SURFACES; ++i) mini::surf::destroy(i);
+    mini::surf::target::set(mini::surf::create(mini::win::state.width, mini::win::state.height));
+    mini::surf::state.dest_surface = mini::surf::state.screen_surface;
+
+    // Reset pal state
+    mini::pal::subpal::reset();
+    ds::trans=0;
+}
+
+using namespace mini;
+
+int main(int argc,char*argv[]){
+    
+    #ifdef DEBUG
+        SDL_SetLogPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG);
+        log_msg(LOG_UNSALTED, "MINI v%s\n",MINI_VERSION);
+    #endif
+
+    // Gestió de arguments
+    // ===============================================================
+    if (argc>1)
+    {
+        if (argv[1][0]=='-' && argv[1][1]=='-') {
+            const char *command = &argv[1][2];
+            if (strcmp(command, "new")==0) {
+                createNewProject();
+                exit(0);
+            } else if (strcmp(command, "version")==0) {
+                exit(0);
+            }
+        } else if (strstr(argv[1], ".lua")!=nullptr) {
+            file::setresourcefolder("./");
+            file::setsource(SOURCE_FOLDER);
+            strcpy(main_lua_file, argv[1]);
+            strcpy(mini::win::state.title, argv[1]);
+            override_ini = true;
+        } else if (strstr(argv[1], ".jf2")!=nullptr) {
+            file::setresourcefilename(argv[1]);
+            file::setsource(SOURCE_FILE);
+        } else {
+            char path[256] = "./";
+            strcat(path, argv[1]);
+            file::setresourcefolder(path);
+        }
+    }
+    #ifdef MACOS_BUNDLE
+        char res_file[255] = "";
+        strcpy(res_file, dirname(argv[0]));
+        strcat(res_file, "/../Resources/data.jrf");
+        file::setresourcefilename(res_file);
+    #endif
+
+    while (!should_quit) {
+        should_exit=false;
+
+        // READ INI
+        if (!override_ini)
+        {
+            read_ini();
+            file::setconfigfolder(config_folder);
+            const char *zoom = file::getconfigvalue("zoom");
+            if (zoom) win::state.zoom=atoi(zoom);
+            const char *fullscreen = file::getconfigvalue("fullscreen");
+            if (fullscreen) win::state.fullscreen=strcmp(fullscreen, "true")==0?true:false;
+            const char *cursor = file::getconfigvalue("cursor");
+            if (cursor) win::state.cursor=strcmp(cursor, "true")?true:false;
+            const char *music_enabled = file::getconfigvalue("music");
+            if (music_enabled) audio::music::enable::set(strcmp(music_enabled, "true")==0?true:false);
+            const char *sound_enabled = file::getconfigvalue("sound");
+            if (sound_enabled) audio::sound::enable::set(strcmp(sound_enabled, "true")==0?true:false);
+        }
+
+        SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_GAMEPAD);
+
+        win::init();
+        pad::init();
+        audio::init();
+
+        reinit();
+
+        uint8_t font_surf = surf::load(default_font_gif, "default_font");
+        //surfaces[font_surf].flags |= SURF_GENERATED;
+        font::load_from_buffer((const char*)default_font_fnt, 0, "default_font");
+        current_font = &fonts[0];
+
+        lua::init(main_lua_file);
+        lua::callbacks::init();
+
+        Uint32 dt=SDL_GetTicks();
+
+        key::state.just_pressed = 0;
+        key::state.has_text_input = false;
+        pad::state.just_pressed = SDL_GAMEPAD_BUTTON_INVALID;
+        mouse::state.just_pressed = 0;
+        mouse::state.wheel = 0;
+        mouse::state.double_click = false;
+        
+        int         fps_counter=0;
+        uint32_t    fps_timer=0;
+
+        while(!should_exit) {
+            if (update_mode==UPDATE_WAIT) SDL_WaitEvent(NULL);
+            else if (update_mode==UPDATE_TIMEOUT) SDL_WaitEventTimeout(NULL, timeout);
+            SDL_Event mini_eve;
+            while(SDL_PollEvent(&mini_eve)) {
+                if (mini_eve.type == SDL_EVENT_QUIT) { should_exit=true; should_quit=true; break; }
+                if (mini_eve.type == SDL_EVENT_TEXT_INPUT) {
+                    SDL_strlcpy(key::state.text_input_buffer, mini_eve.text.text, sizeof(key::state.text_input_buffer));
+                    key::state.has_text_input = true;
+                }
+                if (mini_eve.type == SDL_EVENT_KEY_DOWN) {
+#ifdef DEBUG
+                    if (mini_eve.key.scancode == SDL_SCANCODE_F12) {
+                        mini::surf::reloadsurfs();
+                    //} else if (mini_eve.key.scancode == SDL_SCANCODE_F11) {
+                    //    mini::lua::debug::toggle();
+                    } else if (mini_eve.key.scancode == SDL_SCANCODE_F5) {
+                        should_exit=true;
+                    } else {
+                        key::state.just_pressed = mini_eve.key.scancode;
+                    }
+#else
+                    key::state.just_pressed = mini_eve.key.scancode;
+#endif
+                }
+                if (mini_eve.type == SDL_EVENT_MOUSE_BUTTON_UP) {
+                    if (mouse::state.discard)
+                        mouse::state.discard = false;
+                    else
+                        if (mini_eve.button.clicks==2 && mini_eve.button.button==SDL_BUTTON_LEFT) {
+                            mouse::state.double_click = true;
+                        } else {
+                            mouse::state.just_pressed = mini_eve.button.button;
+                        }
+                }
+                if (mini_eve.type == SDL_EVENT_MOUSE_WHEEL) {
+                    mouse::state.wheel = mini_eve.wheel.y;
+                }
+                if (mini_eve.type == SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
+                    pad::state.just_pressed = mini_eve.gbutton.button;
+                }
+                /*if ( (mini_eve.type == SDL_WINDOWEVENT) &&
+                     (mini_eve.window.windowID == windowID) &&
+                     (mini_eve.window.event == SDL_WINDOWEVENT_MOVED) ) {
+                    windowpos_x = mini_eve.window.data1-4;
+                    windowpos_y = mini_eve.window.data2-36;
+                    //SDL_GetWindowPosition(mini_win, &windowpos_x, &windowpos_y);
+                }*/
+            }
+            key::state.keys = SDL_GetKeyboardState(NULL);
+            float real_mouse_x, real_mouse_y;
+            mouse::state.buttons = SDL_GetMouseState(&real_mouse_x, &real_mouse_y);
+            float mx, my;
+            SDL_RenderCoordinatesFromWindow(win::state.renderer, real_mouse_x, real_mouse_y, &mx, &my);
+            mouse::state.x = int(mx/win::state.zoom)-view::state.origin[0];
+            mouse::state.y = int(my/win::state.zoom)-view::state.origin[1];
+            
+            if (SDL_GetTicks()-dt>13) {
+                dt = SDL_GetTicks();
+                
+                if (lua::running()) {
+                    delta_time = float(SDL_GetTicks() - last_update)/1000.0f;
+                    last_update = SDL_GetTicks();
+
+                    lua::callbacks::update();
+                } else {
+                    exception_loop();
+                }
+                if (beats==0)beats=num_beats;
+                if (beats>0)beats--;
+                key::state.just_pressed = 0;
+                mouse::state.just_pressed = 0;
+                key::state.has_text_input = false;
+                key::state.text_input_buffer[0] = '\0';
+                mouse::state.double_click = false;
+                mouse::state.wheel = 0;
+                pad::state.just_pressed = SDL_GAMEPAD_BUTTON_INVALID;
+            }
+            SDL_SetRenderTarget(win::state.renderer, win::state.tex_shader);
+            SDL_SetRenderDrawColor(win::state.renderer, 0, 0, 0, 255);
+            SDL_RenderClear(win::state.renderer);
+            SDL_LockTexture(win::state.tex_back, NULL, (void**)&pixels, &pitch);
+            for (uint32_t i=0;i<surf::state.screen_surface->size;++i) pixels[i] = palette[surf::state.screen_surface->p[i]];
+            SDL_UnlockTexture(win::state.tex_back);
+            SDL_RenderTexture(win::state.renderer, win::state.tex_back, NULL, NULL); //NEW
+
+            shader::render();
+            //SDL_RenderTexture(mini_ren, mini_bak, NULL, NULL);
+            //SDL_RenderPresent(mini_ren);
+
+            fps_counter++;
+            if (SDL_GetTicks()>=(fps_timer+1000)) {
+                fps = fps_counter;
+                fps_counter=0;
+                fps_timer = SDL_GetTicks();
+            }
+        }
+        lua::quit();
+        audio::quit();
+
+        //Mix_Quit();
+
+        for (unsigned int i=0;i<MAX_SURFACES;++i) surf::destroy(i);
+        surf::state.dest_surface = surf::state.source_surface = map_surface = NULL;
+
+        win::quit();
+        SDL_Quit();
+    }
+    lua::cleanup();
+    return 0;
+}
+
+
+void createNewProject() {
+    if (mini::file::createFolder("data")) {
+        log_msg(LOG_OK, "Directori 'data' creat\n");
+    } else {
+        log_msg(LOG_FAIL, "No s'ha pogut crear la carpeta 'data'\n");
+        exit(-1);
+    }
+
+    FILE *f = fopen("./data/game.ini", "w");
+    if (f) {
+        log_msg(LOG_OK, "Arxiu 'data/game.ini' creat\n");
+    } else {
+        log_msg(LOG_FAIL, "No s'ha pogut crear l'arxiu 'data/game.ini'\n");
+        exit(-1);
+    }
+    fprintf(f, "title=NEW MINI PROJECT\nconfig=newminiproject\nwidth=320\nheight=240\nzoom=2\n");
+    fclose(f);
+
+    f = fopen("./data/main.lua", "w");
+    if (f) {
+        log_msg(LOG_OK, "Arxiu 'data/main.lua' creat\n");
+    } else {
+        log_msg(LOG_FAIL, "No s'ha pogut crear l'arxiu 'data/main.lua'\n");
+        exit(-1);
+    }
+    fprintf(f, "function mini.init()\n\nend\n\nfunction mini.update()\n    surf.cls(0)\nend\n");
+    fclose(f);
+
+    log_msg(LOG_OK, "Projecte nou creat. Ja està fet lo més dificil del jailgame!\n");
+}

source/mini/mini.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <stdint.h>
+
+void exception_loop();
+
+
+namespace mini
+{
+    namespace map
+    {
+        namespace surf {
+            void set(uint8_t surface);
+            uint8_t get();
+        }
+        void draw(); //int celx, int cely, int sx, int sy, uint8_t celw, uint8_t celh, uint8_t layer=0);
+
+        namespace tile {
+            uint8_t get(int celx, int cely);
+            void set(int celx, int cely, uint8_t snum);
+        }
+
+        namespace cell {
+            uint8_t getw();
+            uint8_t geth();
+            void set(int w, int h);
+        }
+    }
+
+    namespace pal
+    {
+        uint32_t *load(const char* filename, uint16_t *palsize=nullptr);
+        void set(uint32_t *pal);
+        namespace color {
+            void set(uint8_t index, uint32_t color);
+            uint32_t get(uint8_t index);
+        }
+        namespace trans {
+            void set(uint8_t index);
+            uint8_t get();
+        }
+        namespace subpal {
+            uint8_t set(uint8_t index, uint8_t color);
+            void reset();
+        }
+    }
+
+    namespace sys
+    {
+        float delta();
+        float time();
+        bool beat(int16_t i);
+
+        int getfps();
+
+        namespace update {
+            void set(const int value, const int t=0);
+            int get();
+        }
+
+        void exit();
+    }
+
+
+}

source/mini/mouse/mouse.cpp

@@ -0,0 +1,44 @@
+#include "mouse.h"
+
+#include <SDL3/SDL.h>
+
+namespace mini
+{
+    namespace mouse
+    {
+        state_t state;
+
+        int posx() {
+            return state.x;
+        }
+
+        int posy() {
+            return state.y;
+        }
+
+        int wheel() {
+            return state.wheel;
+        }
+
+        bool down(uint8_t i) {
+            if (state.discard) return false;
+            return state.buttons & SDL_BUTTON_MASK(i);
+        }
+
+        bool press(uint8_t i) {
+            return state.just_pressed == i;
+        }
+
+        bool dblclick() {
+            return state.double_click;
+        }
+
+        void discard() {
+            state.discard = true;
+        }
+
+        bool inside(int x, int y, int w, int h) {
+            return (state.x>=x) && (state.y>=y) && (state.x<x+w) && (state.y<y+h);
+        }
+    }
+}

source/mini/mouse/mouse.h

@@ -0,0 +1,26 @@
+#pragma once
+#include <stdint.h>
+
+namespace mini
+{
+    namespace mouse
+    {
+        struct state_t {
+            int x, y, wheel;
+            uint32_t buttons;
+            uint8_t just_pressed = 0;
+            bool double_click = false;
+            bool discard = false;
+        };
+        extern state_t state;
+
+        int posx();
+        int posy();
+        int wheel();
+        bool down(uint8_t i);
+        bool press(uint8_t i);
+        bool dblclick();
+        void discard();
+        bool inside(int x, int y, int w, int h);
+    }
+}

source/mini/pad/pad.cpp

@@ -0,0 +1,48 @@
+#include "pad.h"
+
+#include "aux/log.h"
+
+#include <SDL3/SDL.h>
+
+namespace mini
+{
+    namespace pad
+    {
+        state_t state;
+
+        void init() {
+            int num_joysticks;
+            SDL_JoystickID *joysticks = SDL_GetJoysticks(&num_joysticks);
+            if (joysticks) {
+                for (int i=0; i<num_joysticks; ++i) {
+                    if (SDL_IsGamepad(joysticks[i])) {
+                        state.gamepad = SDL_OpenGamepad(joysticks[i]);
+                        if (SDL_GamepadConnected(state.gamepad)) {
+                            SDL_SetGamepadEventsEnabled(true);
+                            log_msg(LOG_OK, "Gamepad found and initialized");
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+        bool down(int8_t i) {
+            if (!state.gamepad) return false;
+            return SDL_GetGamepadButton(state.gamepad, SDL_GamepadButton(i)) == 1;
+        }
+
+        bool press(int8_t i) {
+            if (state.just_pressed == i) {
+                state.just_pressed = -1;
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        int press() {
+            return state.just_pressed;
+        }
+    }
+}

source/mini/pad/pad.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <stdint.h>
+
+struct SDL_Gamepad;
+
+namespace mini
+{
+    namespace pad
+    {
+        struct state_t {
+            SDL_Gamepad *gamepad = nullptr;
+            int8_t just_pressed = -1;
+        };
+        extern state_t state;
+
+        void init();
+        bool down(int8_t i);
+        bool press(int8_t i);
+        int press();
+    }
+}

source/mini/shader/shader.cpp

@@ -0,0 +1,267 @@
+#include "shader.h"
+#include "mini/file/file.h"
+#include "mini/win/win.h"
+
+#include <SDL3/SDL.h>
+
+#include <iostream>
+
+#ifdef __APPLE__
+    #include "CoreFoundation/CoreFoundation.h"
+    #include <OpenGL/OpenGL.h>
+
+    #if ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
+        #include <OpenGL/gl3.h>
+    #else
+        #include <OpenGL/gl.h>
+    #endif //!ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
+#else
+    #include <SDL3/SDL_opengl.h>
+    #include <SDL3/SDL_opengl_glext.h>
+#endif
+
+namespace mini
+{
+    namespace shader
+    {
+        SDL_Window *win = nullptr;
+        SDL_Renderer *renderer = nullptr;
+        GLuint programId = 0;
+        SDL_Texture* backBuffer = nullptr;
+        SDL_Point win_size = {640, 480};
+        SDL_FPoint tex_size = {320, 240};
+        bool can_use_opengl = false;
+        bool using_opengl = false;
+        GLuint texture_number;
+        GLuint nose;
+
+        #ifndef __APPLE__
+
+            // I'm avoiding the use of GLEW or some extensions handler, but that 
+            // doesn't mean you should...
+            PFNGLCREATESHADERPROC glCreateShader;
+            PFNGLSHADERSOURCEPROC glShaderSource;
+            PFNGLCOMPILESHADERPROC glCompileShader;
+            PFNGLGETSHADERIVPROC glGetShaderiv;
+            PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
+            PFNGLDELETESHADERPROC glDeleteShader;
+            PFNGLATTACHSHADERPROC glAttachShader;
+            PFNGLCREATEPROGRAMPROC glCreateProgram;
+            PFNGLDELETEPROGRAMPROC glDeleteProgram;
+            PFNGLLINKPROGRAMPROC glLinkProgram;
+            PFNGLVALIDATEPROGRAMPROC glValidateProgram;
+            PFNGLGETPROGRAMIVPROC glGetProgramiv;
+            PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
+            PFNGLUSEPROGRAMPROC glUseProgram;
+            PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
+            PFNGLACTIVETEXTUREPROC glActiveTexture;
+
+
+            bool initGLExtensions() {
+                glCreateShader = (PFNGLCREATESHADERPROC)SDL_GL_GetProcAddress("glCreateShader");
+                glShaderSource = (PFNGLSHADERSOURCEPROC)SDL_GL_GetProcAddress("glShaderSource");
+                glCompileShader = (PFNGLCOMPILESHADERPROC)SDL_GL_GetProcAddress("glCompileShader");
+                glGetShaderiv = (PFNGLGETSHADERIVPROC)SDL_GL_GetProcAddress("glGetShaderiv");
+                glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)SDL_GL_GetProcAddress("glGetShaderInfoLog");
+                glDeleteShader = (PFNGLDELETESHADERPROC)SDL_GL_GetProcAddress("glDeleteShader");
+                glAttachShader = (PFNGLATTACHSHADERPROC)SDL_GL_GetProcAddress("glAttachShader");
+                glCreateProgram = (PFNGLCREATEPROGRAMPROC)SDL_GL_GetProcAddress("glCreateProgram");
+                glDeleteProgram = (PFNGLDELETEPROGRAMPROC)SDL_GL_GetProcAddress("glDeleteProgram");
+                glLinkProgram = (PFNGLLINKPROGRAMPROC)SDL_GL_GetProcAddress("glLinkProgram");
+                glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)SDL_GL_GetProcAddress("glValidateProgram");
+                glGetProgramiv = (PFNGLGETPROGRAMIVPROC)SDL_GL_GetProcAddress("glGetProgramiv");
+                glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)SDL_GL_GetProcAddress("glGetProgramInfoLog");
+                glUseProgram = (PFNGLUSEPROGRAMPROC)SDL_GL_GetProcAddress("glUseProgram");
+                glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)SDL_GL_GetProcAddress("glGetUniformLocation");
+                glActiveTexture = (PFNGLACTIVETEXTUREPROC)SDL_GL_GetProcAddress("glActiveTexture");
+
+                return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv && 
+                    glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram &&
+                    glDeleteProgram && glLinkProgram && glValidateProgram && glGetProgramiv &&
+                    glGetProgramInfoLog && glUseProgram && glGetUniformLocation;
+            }
+
+        #endif
+
+        state_t state;
+
+        void init(const char* vshader, const char* fshader)
+        {
+            int filesize;
+            char *vshaderfile = file::getfilebuffer(vshader, filesize, true);
+
+            char *fshaderfile = nullptr;
+            if (fshader) { fshaderfile = file::getfilebuffer(fshader, filesize, true); }
+            init(win::state.window, win::state.tex_shader, vshaderfile, fshaderfile);
+        }
+
+
+        GLuint compileShader(const char* source, GLuint shaderType) {
+            // Create ID for shader
+            GLuint result = glCreateShader(shaderType);
+            // Add define depending on shader type
+            const char *sources[2] = { shaderType==GL_VERTEX_SHADER?"#define VERTEX\n":"#define FRAGMENT\n", source };
+            // Define shader text
+            glShaderSource(result, 2, sources, NULL);
+            // Compile shader
+            glCompileShader(result);
+
+            //Check vertex shader for errors
+            GLint shaderCompiled = GL_FALSE;
+            glGetShaderiv( result, GL_COMPILE_STATUS, &shaderCompiled );
+            if (shaderCompiled != GL_TRUE)
+            {
+                std::cout << "Error en la compilación: " << result << "!" << std::endl;
+                GLint logLength;
+                glGetShaderiv(result, GL_INFO_LOG_LENGTH, &logLength);
+                if (logLength > 0)
+                {
+                    GLchar *log = (GLchar*)malloc(logLength);
+                    glGetShaderInfoLog(result, logLength, &logLength, log);
+                    std::cout << "Shader compile log:" << log << std::endl;
+                    //std::cout << source << std::endl;
+                    free(log);
+                }
+                glDeleteShader(result);
+                result = 0;
+            }
+            return result;
+        }
+
+        GLuint compileProgram(const char* vertexShaderSource, const char* fragmentShaderSource)
+        {
+            GLuint programId = 0;
+            GLuint vtxShaderId, fragShaderId;
+
+            if (programId != 0) glDeleteProgram(programId);
+            programId = glCreateProgram();
+            
+
+            vtxShaderId = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
+            fragShaderId = compileShader(fragmentShaderSource?fragmentShaderSource:vertexShaderSource, GL_FRAGMENT_SHADER);
+
+            if(vtxShaderId && fragShaderId)
+            {
+                // Associate shader with program
+                glAttachShader(programId, vtxShaderId);
+                glAttachShader(programId, fragShaderId);
+                glLinkProgram(programId);
+                glValidateProgram(programId);
+
+                // Check the status of the compile/link
+                GLint logLen;
+                glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &logLen);
+                if (logLen > 0)
+                {
+                    char* log = (char*) malloc(logLen * sizeof(char));
+                    // Show any errors as appropriate
+                    glGetProgramInfoLog(programId, logLen, &logLen, log);
+                    std::cout << "Prog Info Log: " << std::endl << log << std::endl;
+                    free(log);
+                }
+            }
+            if (vtxShaderId) glDeleteShader(vtxShaderId);
+            if (fragShaderId) glDeleteShader(fragShaderId);
+            return programId;
+        }
+
+        const bool init(SDL_Window* win, SDL_Texture* backBuffer, const char* vertexShader, const char* fragmentShader)
+        {
+            shader::win = win;
+            shader::renderer = SDL_GetRenderer(win);
+            shader::backBuffer = backBuffer;
+            SDL_GetWindowSize(win, &win_size.x, &win_size.y);
+            SDL_GetTextureSize(backBuffer, &tex_size.x, &tex_size.y);
+            //printf("tex size: %fx%f\n", tex_size.x, tex_size.y);
+            SDL_PropertiesID props = SDL_GetTextureProperties(backBuffer);
+            texture_number = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_NUMBER, -1);
+            //printf("texture number: %i\n", texture_number);
+            int access = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_ACCESS_NUMBER, -1);
+            nose = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_TARGET_NUMBER, -1);
+            //printf("texture target number: %i\n", nose);
+
+            if (access != SDL_TEXTUREACCESS_TARGET)
+            {
+                std::cout << "ERROR FATAL: La textura per al render ha de tindre SDL_TEXTUREACCESS_TARGET definit." << std::endl;
+                exit(1);
+            }
+
+            const char * renderer_name = SDL_GetRendererName(renderer);
+            //printf("rendererInfo.name: %s\n", renderer_name);
+
+            if(!strncmp(renderer_name, "opengl", 6)) {
+    #ifndef __APPLE__
+                static bool gl_extensions_initialized = false;
+                if (!gl_extensions_initialized) {
+                    if (!initGLExtensions()) {
+                        std::cout << "WARNING: No s'han pogut inicialitzar les extensions d'OpenGL!" << std::endl;
+                        can_use_opengl = false;
+                        return false;
+                    }
+                    gl_extensions_initialized = true;
+                }
+    #endif
+                // Compilar el shader y dejarlo listo para usar.
+                if (!vertexShader) {
+                    can_use_opengl = false;
+                    return false;
+                }
+                programId = compileProgram(vertexShader, fragmentShader);
+            } else {
+                std::cout << "WARNING: El driver del renderer no es OpenGL." << std::endl;
+                can_use_opengl = false;
+                return false;
+            }
+            can_use_opengl = true;
+            return true;
+        }
+
+        void enable() { if (can_use_opengl) using_opengl = true; }
+        void disable() { using_opengl = false; }
+
+        void render()
+        {
+            SDL_FlushRenderer(renderer);
+            SDL_SetRenderTarget(renderer, NULL);
+            SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+            SDL_RenderClear(renderer);
+            SDL_FlushRenderer(renderer);
+
+            if (using_opengl)
+            {
+                GLint oldProgramId;
+                if (programId != 0)
+                {
+                    glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId);
+                    glUseProgram(programId);
+                }
+
+                glEnable(GL_TEXTURE_2D);
+                glActiveTexture(GL_TEXTURE0);
+                glBindTexture(GL_TEXTURE_2D, 1);
+                glViewport(0, 0, win_size.x, win_size.y);
+                
+                glBegin(GL_TRIANGLE_STRIP);
+                    glTexCoord2f(0.0f, 0.0f);
+                    glVertex2f(-1.0f, -1.0f);
+                    glTexCoord2f(tex_size.x, 0.0f);
+                    glVertex2f(1.0f, -1.0f);
+                    glTexCoord2f(0.0f, tex_size.y);
+                    glVertex2f(-1.0f, 1.0f);
+                    glTexCoord2f(tex_size.x, tex_size.y);
+                    glVertex2f(1.0f, 1.0f);
+                glEnd();
+
+                SDL_GL_SwapWindow(win);
+
+                if (programId != 0) glUseProgram(oldProgramId);
+
+            } else {
+                SDL_RenderTexture(renderer, backBuffer, NULL, NULL);
+                SDL_RenderPresent(renderer);
+            }
+            if (glGetError()) { printf("GLERROR!\n"); exit(1); }
+        }
+
+    }
+}

source/mini/shader/shader.h

@@ -0,0 +1,27 @@
+#pragma once
+#include <stdint.h>
+
+struct SDL_Window;
+struct SDL_Texture;
+
+namespace mini
+{
+    namespace shader
+    {
+        struct state_t {
+            const bool *keys;
+            uint8_t just_pressed = 0;
+            char text_input_buffer[10];
+            bool has_text_input = false;
+        };
+        extern state_t state;
+
+        const bool init(SDL_Window* win, SDL_Texture* backBuffer, const char* vertexShader, const char* fragmentShader=nullptr);
+        void init(const char* vshader, const char* fshader);
+
+        void enable();
+        void disable();
+
+        void render();
+    }
+}

source/mini/surf/surf.cpp

@@ -0,0 +1,203 @@
+#include "surf.h"
+
+#include "aux/gif.h"
+#include "aux/gifenc.h"
+#include "aux/log.h"
+#include "file/file.h"
+#include "draw/draw.h"
+
+#include <SDL3/SDL.h>
+
+#include <stdlib.h>
+
+namespace mini
+{
+    namespace surf
+    {
+
+        state_t state;
+
+        uint8_t create(int w, int h) {
+            unsigned int i = 0;
+            while (i<MAX_SURFACES && state.surfaces[i].p != NULL) ++i;
+            if (i==MAX_SURFACES) return 255;
+            state.surfaces[i].name = nullptr;
+            state.surfaces[i].w = w;
+            state.surfaces[i].h = h;
+            state.surfaces[i].size = w*h;
+            state.surfaces[i].p = (uint8_t*)calloc(state.surfaces[i].size,1);
+            state.surfaces[i].flags = SURF_GENERATED;
+            clip::reset(i);
+            log_msg(LOG_INFO, "Surface %i creada.\n", i);
+            return i;
+        }
+
+        uint8_t load(uint8_t* buffer, const char* name) {
+            // Agafar la pròxima textura lliure
+            unsigned int i = 0;
+            while (i<MAX_SURFACES && state.surfaces[i].p != NULL) ++i;
+            if (i==MAX_SURFACES) return 255;
+
+            state.surfaces[i].p = LoadGif(buffer, &state.surfaces[i].w, &state.surfaces[i].h);
+            state.surfaces[i].size = state.surfaces[i].w * state.surfaces[i].h;
+            state.surfaces[i].name = (char*)malloc(strlen(name)+1);
+            state.surfaces[i].flags = SURF_GENERATED;
+            clip::reset(i);
+            strcpy(state.surfaces[i].name, name);
+
+            log_msg(LOG_INFO, "Buffer '%s' carregat en surface: %i.\n", name, i);
+
+            return i;
+        }
+
+        uint8_t load(const char* filename, const bool external) {
+            // Si el gif ja s'ha carregat en una textura, tornem eixa textura
+            for (unsigned int i=0; i<MAX_SURFACES; ++i)
+                if (state.surfaces[i].name && strcmp(state.surfaces[i].name, filename)==0) {
+                    log_msg(LOG_INFO, "Carrega de '%s' abortada: Reusant: %i.\n", filename, i);
+                    return i;
+                }
+
+            // Agafar la pròxima textura lliure
+            unsigned int i = 0;
+            while (i<MAX_SURFACES && state.surfaces[i].p != NULL) ++i;
+            if (i==MAX_SURFACES) return 255;
+
+            state.surfaces[i].flags = SURF_NOTHING;
+            // Carregar l'arxiu de disc
+            int size;
+            uint8_t *buffer;
+            if (external) {
+                buffer = (uint8_t*)file::getfilebufferex(filename, size);
+                state.surfaces[i].flags |= SURF_EXTERNAL;
+            } else {
+                buffer = (uint8_t*)file::getfilebuffer(filename, size);
+            }
+
+            // Si no s'ha pogut, petar
+            if (!buffer) {
+                log_msg(LOG_FAIL, "Error al intentar obrir l'arxiu '%s'\n", filename);
+                exit(-1);
+                return 255;
+            }
+
+            // Finalment, carregar el gif en la surface
+            state.surfaces[i].p = LoadGif(buffer, &state.surfaces[i].w, &state.surfaces[i].h);
+            state.surfaces[i].size = state.surfaces[i].w * state.surfaces[i].h;
+            state.surfaces[i].name = (char*)malloc(strlen(filename)+1);
+            clip::reset(i);
+            strcpy(state.surfaces[i].name, filename);
+            free(buffer);
+            
+            log_msg(LOG_INFO, "Arxiu '%s' carregat en surface: %i.\n", filename, i);
+            return i;
+        }
+
+        void reloadsurfs() {
+            for (unsigned int i=0; i<MAX_SURFACES; ++i)
+                if (state.surfaces[i].name) {
+                    if (state.surfaces[i].flags & SURF_GENERATED) {
+                        log_msg(LOG_INFO, "Ignorant surface generada %i.\n", i);
+                    } else {
+                        log_msg(LOG_INFO, "Recarregant de disc surface %i:'%s'.\n", i, state.surfaces[i].name);
+
+                        int size;
+                        uint8_t *buffer;
+                        if (state.surfaces[i].flags & SURF_EXTERNAL) {
+                            buffer = (uint8_t*)file::getfilebufferex(state.surfaces[i].name, size);
+                        } else {
+                            buffer = (uint8_t*)file::getfilebuffer(state.surfaces[i].name, size);
+                        }
+
+                        // Si no s'ha pogut, petar
+                        if (!buffer) {
+                            log_msg(LOG_FAIL, "Error al intentar obrir l'arxiu '%s'\n", state.surfaces[i].name);
+                            exit(-1);
+                        }
+
+                        state.surfaces[i].p = LoadGif(buffer, &state.surfaces[i].w, &state.surfaces[i].h);
+                        state.surfaces[i].size = state.surfaces[i].w * state.surfaces[i].h;
+                        clip::reset(i);
+                        free(buffer);
+                    }
+                }
+
+        }
+
+        void save(uint8_t surface, const char* filename, uint8_t *pal, uint8_t colors)
+        {
+            gif::write_gif(filename, state.surfaces[surface].p, state.surfaces[surface].w, state.surfaces[surface].h, pal, colors);
+        }
+
+        void destroy(uint8_t surface) {
+            if (state.surfaces[surface].name != NULL) free(state.surfaces[surface].name);
+            state.surfaces[surface].name = NULL;
+            if (state.surfaces[surface].p != NULL) {
+                free(state.surfaces[surface].p);
+                log_msg(LOG_INFO, "Surface %i alliberada.\n", surface);
+            }
+            state.surfaces[surface].p = NULL;
+            state.surfaces[surface].flags = SURF_NOTHING;
+        }
+
+        int width(uint8_t surface) {
+            return state.surfaces[surface].w;
+        }
+
+        int height(uint8_t surface) {
+            return state.surfaces[surface].h;
+        }
+
+        void cls(uint8_t color) {
+            const uint8_t col = draw::state.draw_palette[color];
+            SDL_memset(state.dest_surface->p, col, state.dest_surface->size);
+        }
+
+        namespace target {
+            void set(uint8_t surface) {
+                state.dest_surface = &state.surfaces[surface];
+                surf::clip::recalculate();
+            }
+            uint8_t get() {
+                for (unsigned int i=0; i<MAX_SURFACES; ++i) if (state.dest_surface == &state.surfaces[i]) return i;
+                return 0;
+            }
+        }
+
+        namespace source {
+            void set(uint8_t surface) {
+                state.source_surface = &state.surfaces[surface];
+            }
+
+            uint8_t get() {
+                for (unsigned int i=0; i<MAX_SURFACES; ++i) if (state.source_surface == &state.surfaces[i]) return i;
+                return 0;
+            }
+        }
+
+        namespace clip {
+            void set(int x, int y, int w, int h) {
+                state.dest_surface->clip[0]=x;
+                state.dest_surface->clip[1]=y;
+                state.dest_surface->clip[2]=w-x-1;
+                state.dest_surface->clip[3]=h-y-1;
+                recalculate();
+            }
+            void reset(int surface) {
+                surface_t *s = surface==-1 ? state.dest_surface : &state.surfaces[surface];
+                s->clip[0]=0;
+                s->clip[1]=0;
+                s->clip[2]=s->w-1;
+                s->clip[3]=s->h-1;
+                //recalculate();
+            }
+            void recalculate() {
+                if (state.dest_surface->clip[0] < 0) state.dest_surface->clip[0] = 0;
+                if (state.dest_surface->clip[1] < 0) state.dest_surface->clip[1] = 0;
+                if (state.dest_surface->clip[2] >= state.dest_surface->w) state.dest_surface->clip[2] = state.dest_surface->w-1;
+                if (state.dest_surface->clip[3] >= state.dest_surface->h) state.dest_surface->clip[3] = state.dest_surface->h-1;
+            }
+        }
+
+    }
+}

source/mini/surf/surf.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <stdint.h>
+
+namespace mini
+{
+    namespace surf
+    {
+        #define MAX_SURFACES 100
+
+        #define SURF_NOTHING   0
+        #define SURF_EXTERNAL  1
+        #define SURF_GENERATED 2
+
+        struct surface_t {
+            char*       name {nullptr};
+            uint8_t*    p {nullptr};
+            uint16_t    w, h;
+            uint32_t    size;
+            int         clip[4]     {0, 0, 0, 0};
+            uint8_t     flags {SURF_NOTHING};
+        };
+
+        struct state_t {
+            surface_t   surfaces[MAX_SURFACES];
+            surface_t*  screen_surface = &surfaces[0];
+            surface_t*  dest_surface = screen_surface;
+            surface_t*  source_surface = NULL;
+        };
+        extern state_t state;
+
+        uint8_t create(int w, int h);
+        uint8_t load(const char* filename, const bool external = false);
+        void save(uint8_t surface, const char* filename, uint8_t *pal, uint8_t colors=0);
+        void destroy(uint8_t surface);
+        int width(uint8_t surface);
+        int height(uint8_t surface);
+        void cls(uint8_t color=0);
+
+        namespace target {
+            void set(uint8_t surface);
+            uint8_t get();
+        }
+
+        namespace source {
+            void set(uint8_t surface);
+            uint8_t get();
+        }
+
+        namespace clip {
+            void set(int x, int y, int w, int h);
+            void reset(int surface=-1);
+            void recalculate();
+        }
+    }
+}

source/mini/version.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#define MINI_VERSION "1.4.10"

source/mini/view/view.cpp

@@ -0,0 +1,28 @@
+#include "view.h"
+
+namespace mini
+{
+    namespace view
+    {
+        state_t state;
+
+        void init(){
+            state.origin[0] = state.origin[1] = 0;
+        }
+
+        namespace origin {
+            void set(int x, int y) {
+                state.origin[0] = x;
+                state.origin[1] = y;
+            }
+
+            int getx() {
+                return state.origin[0];
+            }
+
+            int gety() {
+                return state.origin[1];
+            }
+        }
+    }
+}

source/mini/view/view.h

@@ -0,0 +1,20 @@
+#pragma once
+
+namespace mini
+{
+    namespace view
+    {
+        struct state_t {
+            int origin[2]   {0, 0};
+        };
+        extern state_t state;
+
+        void init();
+        
+        namespace origin {
+            void set(int x, int y);
+            int getx();
+            int gety();
+        }
+    }
+}

source/mini/win/win.cpp

@@ -0,0 +1,105 @@
+#include "win.h"
+#include "aux/log.h"
+#include "mini/file/file.h"
+#include "mini/shader/shader.h"
+
+#include <SDL3/SDL.h>
+
+namespace mini
+{
+    namespace win
+    {
+        state_t state;
+
+        void init() {
+            // Ajustar el zoom a un valor vàlid
+            if (state.zoom <= 0) state.zoom = 1;
+            const SDL_DisplayMode *dm = SDL_GetDesktopDisplayMode(SDL_GetPrimaryDisplay());
+            while (state.width*state.zoom > dm->w || state.height*state.zoom > dm->h) state.zoom--;
+
+            // Crear SDL_Window i SDL_Renderer
+            state.window = SDL_CreateWindow(state.title, state.width*state.zoom, state.height*state.zoom, SDL_WINDOW_OPENGL|SDL_WINDOW_RESIZABLE|(state.fullscreen?SDL_WINDOW_FULLSCREEN:0));
+            //windowID = SDL_GetWindowID(mini_win);
+            SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
+            state.renderer = SDL_CreateRenderer(state.window, NULL);
+
+            // Mostrar o ocultar el cursor
+            if (state.cursor) SDL_ShowCursor(); else SDL_HideCursor();
+
+            // Crear textura backbuffer
+            state.tex_back = SDL_CreateTexture(state.renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, state.width, state.height);
+            SDL_SetTextureScaleMode(state.tex_back, SDL_SCALEMODE_NEAREST);
+
+            //SDL_PropertiesID props = SDL_GetTextureProperties(state.tex_back);
+            //int real_pixelformat = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_FORMAT_NUMBER, -1);
+            //if (real_pixelformat != SDL_PIXELFORMAT_ARGB8888) {
+            //    log_msg(LOG_FAIL, "Pixelformat incorrecte: %i\n", real_pixelformat);
+            //    exit(1);
+            //}
+
+            // Crear textura shaders i inicialitzar shaders
+            state.tex_shader = SDL_CreateTexture(state.renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, state.width*state.zoom, state.height*state.zoom);
+            SDL_SetTextureScaleMode(state.tex_shader, SDL_SCALEMODE_NEAREST);
+            shader::init(state.window, state.tex_shader, nullptr);
+            
+            log_msg(LOG_OK, "Graphics subsystem initialized\n");
+        }
+
+        void quit() {
+            SDL_DestroyTexture(state.tex_shader);
+            SDL_DestroyTexture(state.tex_back);
+            SDL_DestroyRenderer(state.renderer);
+            SDL_DestroyWindow(state.window);
+        }
+
+        void raise() {
+            SDL_RaiseWindow(state.window);
+        }
+
+        namespace zoom {
+            int get() {
+                return state.zoom;
+            }
+            void set(const int value) {
+                state.zoom = value;
+                quit();
+                init();
+                char strzoom[3];
+                file::setconfigvalue("zoom", SDL_itoa(state.zoom, strzoom, 10));
+            }
+        }
+
+        namespace fullscreen {
+            bool get() {
+                return state.fullscreen;
+            }
+            void set(const bool value) {
+                state.fullscreen=value;
+                quit();
+                init();
+                file::setconfigvalue("fullscreen", state.fullscreen?"true":"false");
+            }
+        }
+
+        namespace cursor {
+            bool get() {
+                return state.cursor;
+            }
+            void set(const bool value) {
+                state.cursor=value;
+                if (state.cursor) SDL_ShowCursor(); else SDL_HideCursor();
+            }
+        }
+
+        namespace res {
+            void set(const int w, const int h) {
+                state.width = w;
+                state.height = h;
+                quit();
+                init();
+            }
+            int getw() { return state.width; }
+            int geth() { return state.height; }
+        }
+    }
+}

source/mini/win/win.h

@@ -0,0 +1,53 @@
+#pragma once
+#include <stdint.h>
+
+struct SDL_Window;
+struct SDL_Renderer;
+struct SDL_Texture;
+
+namespace mini
+{
+    namespace win
+    {
+        struct state_t {
+            char        title[256];
+            uint16_t    width           { 160   };
+            uint16_t    height          { 120   };
+            uint8_t     zoom            { 4     };
+            bool        fullscreen      { false };
+            bool        cursor          { true  };
+
+            SDL_Window  *window         { nullptr };
+            SDL_Renderer*renderer       { nullptr };
+            SDL_Texture *tex_back       { nullptr };
+            SDL_Texture *tex_shader     { nullptr };
+            //Uint32     windowID;
+        };
+        extern state_t state;
+
+        void init();
+        void quit();
+        void raise();
+
+        namespace zoom {
+            void set(const int value);
+            int get();
+        }
+
+        namespace fullscreen {
+            void set(const bool value);
+            bool get();
+        }
+
+        namespace cursor {
+            void set(const bool value);
+            bool get();
+        }
+
+        namespace res {
+            void set(const int w, const int h);
+            int getw();
+            int geth();
+        }
+    }
+}