Merge branch 'master' of https://gitea.sustancia.synology.me/JailDoctor/thepool

Makefile

@@ -3,25 +3,25 @@ source = source/*.cpp
 
 windows:
 	@echo off
-	g++ $(source) bin/icon.res -lmingw32 -lSDL2main -lSDL2 -mwindows -o "$(executable).exe"
+	g++ $(source) bin/icon.res -lmingw32 -lSDL3 -mwindows -o "$(executable).exe"
 	strip -s -R .comment -R .gnu.version --strip-unneeded "$(executable).exe"
 
 windows_debug:
 	@echo off
-	g++ $(source) -D DEBUG -g -Wall -fvar-tracking -lmingw32 -lSDL2main -lSDL2 -o "$(executable)_debug.exe"
+	g++ $(source) -D DEBUG -g -Wall -fvar-tracking -lmingw32 -lSDL3 -o "$(executable)_debug.exe"
 
 macos:
-	clang++ $(source) -Wall -Os -std=c++11 -ffunction-sections -fdata-sections -lSDL2 -o "$(executable)"
+	clang++ $(source) -Wall -Os -std=c++11 -ffunction-sections -fdata-sections -lSDL3 -o "$(executable)"
 
 macos_debug:
-	clang++ $(source) -D DEBUG -g -Wall -std=c++11 -lSDL2 -o "$(executable)_debug"
+	clang++ $(source) -D DEBUG -g -Wall -std=c++11 -lSDL3 -o "$(executable)_debug"
 
 macos_bundle:
-	clang++ $(source) -D MACOS_BUNDLE -Wall -Os -std=c++11 -framework SDL2 -F /Library/Frameworks -ffunction-sections -fdata-sections -o mini_bundle -rpath @executable_path/../Frameworks/ -target x86_64-apple-macos10.12
+	clang++ $(source) -D MACOS_BUNDLE -Wall -Os -std=c++11 -framework SDL3 -F /Library/Frameworks -ffunction-sections -fdata-sections -o mini_bundle -rpath @executable_path/../Frameworks/ -target x86_64-apple-macos10.12
 
 linux:
-	g++ $(source) -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -lSDL2 -o "$(executable)"
+	g++ $(source) -Wall -Os -ffunction-sections -fdata-sections -Wl,--gc-sections -lSDL3 -o "$(executable)"
 	strip -s -R .comment -R .gnu.version --strip-unneeded "$(executable)"
 
 linux_debug:
-	g++ $(source) -D DEBUG -g -lSDL2 -o "$(executable)_debug"
+	g++ $(source) -D DEBUG -g -lSDL3 -o "$(executable)_debug"

lagueirtofile

@@ -1,4 +1,4 @@
-libs = -lSDL2
+libs = -lSDL3
 cppflags = -D DEBUG -g
 executable = thepool_debug
 sourcepath = source

source/actor.cpp

@@ -2118,7 +2118,7 @@ namespace actor
 
         void setLives(int value)
         {
-            lives = value;
+            lives = config::getInfiniteLives() ? 8 : value;
         }
 
         void die()

source/actor.h

@@ -1,5 +1,5 @@
 #pragma once
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "misc.h"
 #include "jdraw.h"
 #include <vector>

source/config.cpp

@@ -1,14 +1,16 @@
 #include "config.h"
 #include "jfile.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace config
 {
     bool musicEnabled = true;
     int soundMode = SOUND_ALL;
     uint8_t keys[7] = {SDL_SCANCODE_UP, SDL_SCANCODE_DOWN, SDL_SCANCODE_LEFT, SDL_SCANCODE_RIGHT, SDL_SCANCODE_SPACE, SDL_SCANCODE_RETURN, SDL_SCANCODE_ESCAPE};
-    int8_t pad_btns[7] = {SDL_CONTROLLER_BUTTON_DPAD_UP, SDL_CONTROLLER_BUTTON_DPAD_DOWN, SDL_CONTROLLER_BUTTON_DPAD_LEFT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT, SDL_CONTROLLER_BUTTON_A, SDL_CONTROLLER_BUTTON_B, SDL_CONTROLLER_BUTTON_START};
+    int8_t pad_btns[7] = {SDL_GAMEPAD_BUTTON_DPAD_UP, SDL_GAMEPAD_BUTTON_DPAD_DOWN, SDL_GAMEPAD_BUTTON_DPAD_LEFT, SDL_GAMEPAD_BUTTON_DPAD_RIGHT, SDL_GAMEPAD_BUTTON_SOUTH, SDL_GAMEPAD_BUTTON_EAST, SDL_GAMEPAD_BUTTON_START};
     bool prologo_desbloquejat = false;
+    bool kiosk_mode = false;
+    bool infinite_lives = false;
 
     void setMusic(const bool value)
     {
@@ -82,4 +84,27 @@ namespace config
         return prologo_desbloquejat;
     }
 
+    void setKioskMode(const bool value)
+    {
+        kiosk_mode = value;
+        file::setConfigValue("kiosk", kiosk_mode ? "yes" : "no");
+    }
+
+    const bool getKioskMode()
+    {
+        return kiosk_mode;
+    }
+
+    void setInifiniteLives(const bool value)
+    {
+        infinite_lives= value;
+        file::setConfigValue("infinitelives", infinite_lives? "yes" : "no");
+    }
+
+    const bool getInfiniteLives()
+    {
+        return infinite_lives;
+    }
+
+
 }

source/config.h

@@ -30,4 +30,10 @@ namespace config
 
     void setProgoloDesbloquejat();
     const bool isProgoloDesbloquejat();
+
+    void setKioskMode(const bool value);
+    const bool getKioskMode();
+
+    void setInifiniteLives(const bool value);
+    const bool getInfiniteLives();
 }

source/console.cpp

@@ -1,11 +1,12 @@
 #include "console.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "jdraw.h"
 #include "jinput.h"
 #include "room.h"
 #include "actor.h"
 #include "jgame.h"
 #include "debug.h"
+#include "config.h"
 
 namespace console
 {
@@ -134,10 +135,11 @@ namespace console
     #define CMD_EXIT        4
     #define CMD_SHOW        5
     #define CMD_HIDE        6
-    #define CMD_HELP        7
+    #define CMD_SET         7
-    #define NUM_CMDS        8
+    #define CMD_HELP        8
+    #define NUM_CMDS        9
 
-    const char *command_text[NUM_CMDS] = { "GIVE", "DROP", "GOTO", "MOVE", "EXIT", "SHOW", "HIDE", "HELP" };
+    const char *command_text[NUM_CMDS] = { "GIVE", "DROP", "GOTO", "MOVE", "EXIT", "SHOW", "HIDE", "SET", "HELP" };
 
     #define PARAM_UNKNOWN  -1
     #define PARAM_RUN       0
@@ -283,9 +285,28 @@ namespace console
                         debug::disable(value);
                 }
                 break;
+            case CMD_SET:
+                if (!tokens[1]) {
+                    strcpy(msg, "ERROR: Nothing to set.");
+                } else {
+                    strcpy(msg, "Ok.");
+                    const int value = getIndexFromString(tokens[1], {"KIOSK", "INFINITELIVES"});
+                    if (value==-1)
+                        strcpy(msg, "ERROR: Cannot set that.");
+                    else
+                        switch (value) {
+                            case 0:
+                                config::setKioskMode(!config::getKioskMode());
+                                break;
+                            case 1:
+                                config::setInifiniteLives(!config::getInfiniteLives());
+                                break;
+                        }
+
+                }
             case CMD_HELP:
                 if (!tokens[1]) {
-                    strcpy(msg, "GIVE DROP GOTO MOVE EXIT SHOW HIDE HELP");
+                    strcpy(msg, "GIVE DROP GOTO MOVE EXIT SHOW HIDE SET HELP");
                 } else {
                     int command = getCommand();
                     switch (command)

source/gif.h

@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <fcntl.h>
+#include <stdint.h>
 
 #define EXTENSION_INTRODUCER   0x21
 #define IMAGE_DESCRIPTOR       0x2C

source/jail_audio.cpp

@@ -1,43 +1,57 @@
 #ifndef JA_USESDLMIXER
 #include "jail_audio.h"
-#include "stb_vorbis.c"
+#include "stb_vorbis.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include <stdio.h>
+#include "log.h"
 
 #define JA_MAX_SIMULTANEOUS_CHANNELS 5
 
-struct JA_Sound_t {
+struct JA_Sound_t
-    Uint32  length {0};
+{
-    Uint8*  buffer {NULL};
+    SDL_AudioSpec       spec        { SDL_AUDIO_S16, 2, 48000 };
+    Uint32              length      { 0 };
+    Uint8               *buffer     { NULL };
 };
 
-struct JA_Channel_t {
+struct JA_Channel_t
-    JA_Sound_t          *sound;
+{
-    int                 pos {0};
+    JA_Sound_t          *sound      { nullptr };
-    int                 times {0};
+    int                 pos         { 0 };
-    JA_Channel_state    state { JA_CHANNEL_FREE };
+    int                 times       { 0 };
+    SDL_AudioStream     *stream     { nullptr };
+    JA_Channel_state    state       { JA_CHANNEL_FREE };
 };
 
-struct JA_Music_t {
+struct JA_Music_t
-    int             samples {0};
+{
-    int             pos {0};
+    SDL_AudioSpec       spec        { SDL_AUDIO_S16, 2, 48000 };
-    int             times {0};
+    Uint32              length      { 0 };
-    short*          output {NULL};
+    Uint8               *buffer     { nullptr };
-    JA_Music_state  state {JA_MUSIC_INVALID};
+
+    int                 pos         { 0 };
+    int                 times       { 0 };
+    SDL_AudioStream     *stream     { nullptr };
+    JA_Music_state      state       { JA_MUSIC_INVALID };
 };
 
-JA_Music_t      *current_music{NULL};
+JA_Music_t          *current_music  { nullptr };
-JA_Channel_t    channels[JA_MAX_SIMULTANEOUS_CHANNELS];
+JA_Channel_t        channels[JA_MAX_SIMULTANEOUS_CHANNELS];
 
-int             JA_freq {48000};
+SDL_AudioSpec       JA_audioSpec    { SDL_AUDIO_S16, 2, 48000 };
-SDL_AudioFormat JA_format {AUDIO_S16};
+float               JA_musicVolume  { 1.0f };
-Uint8           JA_channels {2};
+float               JA_soundVolume  { 0.5f };
-int             JA_musicVolume = 128;
+bool                JA_musicEnabled { true };
-int             JA_soundVolume = 64;
+bool                JA_soundEnabled { true };
-bool            JA_musicEnabled = true;
+SDL_AudioDeviceID   sdlAudioDevice  { 0 };
-bool            JA_soundEnabled = true;
+SDL_TimerID         JA_timerID      { 0 };
-SDL_AudioDeviceID sdlAudioDevice = 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) {
@@ -73,42 +87,100 @@ void audioCallback(void * userdata, uint8_t * stream, int len) {
         }
     }
 }
+*/
 
-void JA_Init(const int freq, const SDL_AudioFormat format, const int channels) {
+Uint32 JA_UpdateCallback(void *userdata, SDL_TimerID timerID, Uint32 interval)
-    JA_freq = freq;
+{
-    JA_format = format;
+    if (JA_musicEnabled && current_music && current_music->state == JA_MUSIC_PLAYING)
-    JA_channels = channels;
+    {
-    SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
+        if (fading) {
-    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+            int time = SDL_GetTicks();
-    sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
+            if (time > (fade_start_time+fade_duration)) {
-    SDL_PauseAudioDevice(sdlAudioDevice, 0);
+                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_Quit() {
+void JA_Init(const int freq, const SDL_AudioFormat format, const int channels)
-    SDL_PauseAudioDevice(sdlAudioDevice, 1);
+{
-    if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
+    #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)
 {
-    int chan, samplerate;
     JA_Music_t *music = new JA_Music_t();
 
-    music->samples = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &music->output);
+    int chan, samplerate;
-    // [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
+    short *output;
-//    music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
+    music->length = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &output) * chan * 2;
 
-    SDL_AudioCVT cvt;
+    music->spec.channels = chan;
-    SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
+    music->spec.freq = samplerate;
-    if (cvt.needed) {
+    music->spec.format = SDL_AUDIO_S16;
-        cvt.len = music->samples * chan * 2;
+    music->buffer = (Uint8*)SDL_malloc(music->length);
-        cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
+    SDL_memcpy(music->buffer, output, music->length);
-        SDL_memcpy(cvt.buf, music->output, cvt.len);
+    free(output);
-        SDL_ConvertAudio(&cvt);
-        free(music->output);
-        music->output = (short*)cvt.buf;
-    }
     music->pos = 0;
     music->state = JA_MUSIC_STOPPED;
 
@@ -137,110 +209,133 @@ void JA_PlayMusic(JA_Music_t *music, const int loop)
 {
     if (!JA_musicEnabled) return;
 
-    if (current_music != NULL) {
+    JA_StopMusic();
-        current_music->pos = 0;
+
-        current_music->state = JA_MUSIC_STOPPED;
-    }
     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;
 
-    if (current_music == NULL || 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;
 
-    if (current_music == NULL || 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;
 
-    if (current_music == NULL || 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;
 }
 
-JA_Music_state JA_GetMusicState() {
+void JA_FadeOutMusic(const int milliseconds)
-    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
+{
+    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;
 
-    if (current_music == NULL) return JA_MUSIC_INVALID;
     return current_music->state;
 }
 
-void JA_DeleteMusic(JA_Music_t *music) {
+void JA_DeleteMusic(JA_Music_t *music)
-    if (current_music == music) current_music = NULL;
+{
-    free(music->output);
+    if (current_music == music) current_music = nullptr;
+    SDL_free(music->buffer);
+    if (music->stream) SDL_DestroyAudioStream(music->stream);
     delete music;
 }
 
-int JA_SetMusicVolume(int volume)
+float JA_SetMusicVolume(float volume)
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : 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 != NULL && current_music->state==JA_MUSIC_PLAYING) JA_StopMusic();
+    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 *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 *JA_LoadSound(uint8_t* buffer, uint32_t size)
+{
     JA_Sound_t *sound = new JA_Sound_t();
-    SDL_AudioSpec wavSpec;
+    SDL_LoadWAV_IO(SDL_IOFromMem(buffer, size),1, &sound->spec, &sound->buffer, &sound->length);
-    SDL_LoadWAV_RW(SDL_RWFromMem(buffer, size),1, &wavSpec, &sound->buffer, &sound->length);
-    
-    SDL_AudioCVT cvt;
-    SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
-    cvt.len = sound->length;
-    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
-    SDL_memcpy(cvt.buf, sound->buffer, sound->length);
-    SDL_ConvertAudio(&cvt);
-    SDL_FreeWAV(sound->buffer);
-    sound->buffer = cvt.buf;
-    sound->length = cvt.len_cvt;
 
     return sound;
 }
 
-JA_Sound_t *JA_LoadSound(const char* filename) {
+JA_Sound_t *JA_LoadSound(const char* filename)
+{
     JA_Sound_t *sound = new JA_Sound_t();
-    SDL_AudioSpec wavSpec;
+    SDL_LoadWAV(filename, &sound->spec, &sound->buffer, &sound->length);
-    SDL_LoadWAV(filename, &wavSpec, &sound->buffer, &sound->length);
-
-    SDL_AudioCVT cvt;
-    SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, JA_format, JA_channels, JA_freq);
-    cvt.len = sound->length;
-    cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
-    SDL_memcpy(cvt.buf, sound->buffer, sound->length);
-    SDL_ConvertAudio(&cvt);
-    SDL_FreeWAV(sound->buffer);
-    sound->buffer = cvt.buf;
-    sound->length = cvt.len_cvt;
 
     return sound;
 }
@@ -252,11 +347,36 @@ int JA_PlaySound(JA_Sound_t *sound, const int loop)
     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;
 }
 
@@ -273,12 +393,24 @@ void JA_PauseChannel(const int channel)
 {
     if (!JA_soundEnabled) return;
 
-    if (channel == -1) {
+    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;
+        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);
         }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state == JA_CHANNEL_PLAYING) channels[channel].state = JA_CHANNEL_PAUSED;
     }
 }
 
@@ -286,12 +418,24 @@ void JA_ResumeChannel(const int channel)
 {
     if (!JA_soundEnabled) return;
 
-    if (channel == -1) {
+    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;
+        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);
         }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state == JA_CHANNEL_PAUSED) channels[channel].state = JA_CHANNEL_PLAYING;
     }
 }
 
@@ -299,13 +443,20 @@ void JA_StopChannel(const int channel)
 {
     if (!JA_soundEnabled) return;
 
-    if (channel == -1) {
+    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[channel].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) {
+    }
+    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;
@@ -317,12 +468,18 @@ 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;
 }
 
-int JA_SetSoundVolume(int volume)
+float JA_SetSoundVolume(float volume)
 {
-    JA_soundVolume = volume > 128 ? 128 : volume < 0 ? 0 : 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;
 }
 
@@ -335,10 +492,15 @@ void JA_EnableSound(const bool value)
     JA_soundEnabled = value;
 }
 
-int JA_SetVolume(int volume)
+const bool JA_IsSoundEnabled()
 {
-    JA_musicVolume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
+    return JA_soundEnabled;
-    JA_soundVolume = JA_musicVolume/2;
+}
+
+float JA_SetVolume(float volume)
+{
+    JA_SetSoundVolume(JA_SetMusicVolume(volume) / 2.0f);
+
     return JA_musicVolume;
 }
 

source/jail_audio.h

@@ -1,5 +1,5 @@
 #pragma once
-#include <SDL2/SDL.h>
+#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 };
@@ -16,21 +16,27 @@ 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);
-int JA_SetMusicVolume(int volume);
+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);
-int JA_SetSoundVolume(int volume);
+float JA_SetSoundVolume(float volume);
 void JA_EnableSound(const bool value);
+const bool JA_IsSoundEnabled();
 
-int JA_SetVolume(int volume);
+float JA_SetVolume(float volume);

source/jaudio.cpp

@@ -1,6 +1,6 @@
 #include "jaudio.h"
 #include "jail_audio.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include <stdio.h>
 #include "jfile.h"
 #include <vector>
@@ -24,7 +24,7 @@ namespace audio
     // Inicialitza el sistema de só
     void init()
     {
-        JA_Init(48000, AUDIO_S16, 2);
+        JA_Init(48000, SDL_AUDIO_S16LE, 2);
         //Mix_Init(MIX_INIT_OGG);// | MIX_INIT_WAVPACK);
         //Mix_OpenAudio(48000, AUDIO_S16, 2, 512);
     }

source/jdraw.cpp

@@ -1,6 +1,6 @@
 #include "jdraw.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
-#include "gif.c"
+#include "gif.h"
 #include "jfile.h"
 #include <vector>
 
@@ -15,7 +15,7 @@ namespace draw
     SDL_Renderer *sdl_renderer = nullptr; // El renderer de SDL
     SDL_Texture *sdl_texture = nullptr;   // La textura de SDL a la que pintarem la nostra superficie "screen" i que despres volcarem a pantalla
 
-    SDL_Rect dest_rect = {0, 0, 320, 240};
+    SDL_FRect dest_rect = {0, 0, 320, 240};
     static int fullscreen_scale = 1;
 
     static int screen_zoom = 1;
@@ -89,23 +89,21 @@ namespace draw
         // [TODO] Incloure gestió de pantalla completa
 
         // Inicialització de les estructures de SDL
-        sdl_window = SDL_CreateWindow(screen_title.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, screen_width * screen_zoom, screen_height * screen_zoom, screen_fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : SDL_WINDOW_SHOWN);
+        sdl_window = SDL_CreateWindow(screen_title.c_str(), screen_width * screen_zoom, screen_height * screen_zoom, screen_fullscreen ? SDL_WINDOW_FULLSCREEN : 0);
-        sdl_renderer = SDL_CreateRenderer(sdl_window, -1, 0);
+        sdl_renderer = SDL_CreateRenderer(sdl_window, nullptr);
         sdl_texture = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, screen_width, screen_height);
+        SDL_SetTextureScaleMode(sdl_texture, SDL_SCALEMODE_NEAREST);
 
-        SDL_RendererInfo info;
         const int num_render_drivers = SDL_GetNumRenderDrivers();
         printf("Available renderers:\n");
         for (int i=0; i<num_render_drivers; ++i)
         {
-            SDL_GetRenderDriverInfo(i, &info);
+            printf(" - %i: %s\n", i, SDL_GetRenderDriver(i));
-            printf(" - %i: %s\n", i, info.name);
         }
 
-        SDL_GetRendererInfo(sdl_renderer, &info);
+        printf("\nRenderer: %s\n", SDL_GetRendererName(sdl_renderer));
-        printf("\nRenderer: %s\n", info.name);
 
-        SDL_ShowCursor(false);
+        SDL_HideCursor();
         
         if (screen_fullscreen)        
         {
@@ -138,10 +136,12 @@ namespace draw
         char *p = buffer;
         char *n = buffer;
         while (*n!=0) {
-            while (*n!='\n') n++;
+            while (*n!='\n' && *n!='\r') n++;
             *n=0;
             loadSurface(p);
-            p=++n;
+            n++;
+            while (*n=='\n' || *n=='\r') n++;
+            p=n;
         }
         free(buffer);
 
@@ -183,11 +183,12 @@ namespace draw
         SDL_DestroyWindow(sdl_window);
 
         const int zoom = screen_fullscreen ? 1 : screen_zoom;
-        sdl_window = SDL_CreateWindow(screen_title.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, screen_width * zoom, screen_height * zoom, screen_fullscreen?SDL_WINDOW_FULLSCREEN_DESKTOP:SDL_WINDOW_SHOWN);
+        sdl_window = SDL_CreateWindow(screen_title.c_str(), screen_width * zoom, screen_height * zoom, screen_fullscreen?SDL_WINDOW_FULLSCREEN:0);
-        sdl_renderer = SDL_CreateRenderer(sdl_window, -1, 0);
+        sdl_renderer = SDL_CreateRenderer(sdl_window, nullptr);
         sdl_texture = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, screen_width, screen_height);
+        SDL_SetTextureScaleMode(sdl_texture, SDL_SCALEMODE_NEAREST);
 
-        SDL_ShowCursor(false);
+        SDL_HideCursor();
 
         if (screen_fullscreen)        
         {
@@ -213,12 +214,10 @@ namespace draw
     void setZoom(const int value)
     {
         if (value < 1) return;
+        const SDL_DisplayMode *dm = SDL_GetCurrentDisplayMode(SDL_GetDisplayForWindow(sdl_window));
 
-        SDL_DisplayMode dm;
+        if (screen_width*value > dm->w) return;
-        SDL_GetCurrentDisplayMode(0, &dm);
+        if (screen_height*value > dm->h) return;
-
-        if (screen_width*value > dm.w) return;
-        if (screen_height*value > dm.h) return;
 
         screen_zoom = value;
         reinit();
@@ -677,9 +676,33 @@ namespace draw
         print2(buffer, x, y, color, zoom);
     }
 
+bool SaveIndexedAsBMP(const char *filename,
+                      const uint8_t *pixels,
+                      const uint32_t *palette,
+                      int w, int h)
+{
+    SDL_Surface *surface = SDL_CreateSurface(w, h, SDL_PIXELFORMAT_ARGB8888);
+    if (!surface) return false;
+
+    uint32_t *dst = (uint32_t *)surface->pixels;
+    int pitch32 = surface->pitch / 4;
+
+    for (int y = 0; y < h; y++) {
+        for (int x = 0; x < w; x++) {
+            uint8_t idx = pixels[y * w + x];
+            dst[y * pitch32 + x] = palette[idx];  // assumes ARGB8888
+        }
+    }
+
+    bool ok = SDL_SaveBMP(surface, filename);
+    SDL_DestroySurface(surface);
+    return ok;
+}
+
     // Refresca la pantalla
     void render()
     {
+        //SaveIndexedAsBMP("screen.bmp", screen->pixels, palette, 320, 240);
 
         Uint32 *sdl_pixels;                     // Punter al array de pixels que enstornarà SDL_LockTexture
         int sdl_pitch;                          // Ací estarà guardat el pitch de la textura, com es de 32 bits, no m'afecta
@@ -694,7 +717,7 @@ namespace draw
         //  i el enviem a la textura SDL
         for (uint32_t i = 0; i < size; ++i)
         {
-            sdl_pixels[i] = palette[screen->pixels[i]];
+            sdl_pixels[i] = 0xff000000 | palette[screen->pixels[i]];
         }
 
         // Desbloquejem la textura
@@ -707,7 +730,7 @@ namespace draw
         }
 
         // Pintem la textura a pantalla
-        SDL_RenderCopy(sdl_renderer, sdl_texture, NULL, &dest_rect);
+        SDL_RenderTexture(sdl_renderer, sdl_texture, NULL, &dest_rect);
 
         if (screen_mode & SCREEN_MODE_SCANLINES)
         {
@@ -718,14 +741,14 @@ namespace draw
                 for (int y=0; y<screen_height; ++y)
                 {
                     SDL_SetRenderDrawColor(sdl_renderer, 0, 0, 0, 192);
-                    SDL_RenderDrawLine(sdl_renderer, dest_rect.x, dest_rect.y + y*zoom, dest_rect.x + dest_rect.w, dest_rect.y + y*zoom);
+                    SDL_RenderLine(sdl_renderer, dest_rect.x, dest_rect.y + y*zoom, dest_rect.x + dest_rect.w, dest_rect.y + y*zoom);
                     SDL_SetRenderDrawColor(sdl_renderer, 0, 0, 0, 96);
-                    if (zoom>3) SDL_RenderDrawLine(sdl_renderer, dest_rect.x, 1+dest_rect.y + y*zoom, dest_rect.x + dest_rect.w, 1+dest_rect.y + y*zoom);
+                    if (zoom>3) SDL_RenderLine(sdl_renderer, dest_rect.x, 1+dest_rect.y + y*zoom, dest_rect.x + dest_rect.w, 1+dest_rect.y + y*zoom);
                 }
                 SDL_SetRenderDrawColor(sdl_renderer, 0, 0, 0, 16);
                 for (int x=0; x<screen_width; ++x)
                 {
-                    SDL_RenderDrawLine(sdl_renderer, dest_rect.x + x*zoom, dest_rect.y, dest_rect.x + x*zoom, dest_rect.y + dest_rect.h);
+                    SDL_RenderLine(sdl_renderer, dest_rect.x + x*zoom, dest_rect.y, dest_rect.x + x*zoom, dest_rect.y + dest_rect.h);
                 }
             }
         }

source/jgame.cpp

@@ -2,7 +2,7 @@
 #include "jdraw.h"
 #include "jinput.h"
 #include "jaudio.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace game
 {
@@ -34,7 +34,7 @@ int main(int argc, char *argv[])
     game::param_count = argc;
     game::params = argv;
 
-    SDL_Init(SDL_INIT_EVERYTHING);
+    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_GAMEPAD);
     
     input::init();
     audio::init();
@@ -47,26 +47,26 @@ int main(int argc, char *argv[])
     {
         while(SDL_PollEvent(&e))
         {
-            if (e.type==SDL_QUIT) { game::should_exit = true; break; }
+            if (e.type==SDL_EVENT_QUIT) { game::should_exit = true; break; }
-            if (e.type==SDL_KEYDOWN)
+            if (e.type==SDL_EVENT_KEY_DOWN)
             {
-                input::updateKey(e.key.keysym.scancode);
+                input::updateKey(e.key.scancode);
             }
-            if (e.type==SDL_KEYUP)
+            if (e.type==SDL_EVENT_KEY_UP)
             {
-                input::updateKeypressed(e.key.keysym.scancode);
+                input::updateKeypressed(e.key.scancode);
             }
-            if (e.type==SDL_MOUSEBUTTONUP)
+            if (e.type==SDL_EVENT_MOUSE_BUTTON_UP)
             {
                 input::updateClk(e.button.button);
             }
-            if (e.type==SDL_MOUSEWHEEL)
+            if (e.type==SDL_EVENT_MOUSE_WHEEL)
             {
                 input::updateWheel(e.wheel.y);
             }
-            if (e.type==SDL_CONTROLLERBUTTONDOWN) {
+            if (e.type==SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
-                input::updatePadBtn(e.cbutton.button);
+                input::updatePadBtn(e.gbutton.button);
-                input::updatePadBtnPressed(e.cbutton.button);
+                input::updatePadBtnPressed(e.gbutton.button);
             }
         }
 
@@ -78,8 +78,8 @@ int main(int argc, char *argv[])
             input::updateKeypressed(SDL_SCANCODE_UNKNOWN);
             input::updateClk(0);
             input::updateWheel(0);
-            input::updatePadBtn(SDL_CONTROLLER_BUTTON_INVALID);
+            input::updatePadBtn(SDL_GAMEPAD_BUTTON_INVALID);
-            input::updatePadBtnPressed(SDL_CONTROLLER_BUTTON_INVALID);
+            input::updatePadBtnPressed(SDL_GAMEPAD_BUTTON_INVALID);
         }
     }
 

source/jinput.cpp

@@ -1,31 +1,40 @@
 #include "jinput.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "jdraw.h"
 #include "jfile.h"
 
 namespace input
 {
-    static const uint8_t *keys = nullptr;
+    static const bool *keys = nullptr;
     static uint8_t keypressed = 0;
     static uint8_t keydown = 0;
     static uint8_t btnClicked = 0;
     static int wheel = 0;
-    static SDL_GameController *gamepad = NULL;
+    static SDL_Gamepad *gamepad = NULL;
-    static int8_t pad_btn_pressed = SDL_CONTROLLER_BUTTON_INVALID;
+    static int8_t pad_btn_pressed = SDL_GAMEPAD_BUTTON_INVALID;
-    static int8_t pad_btn_down = SDL_CONTROLLER_BUTTON_INVALID;
+    static int8_t pad_btn_down = SDL_GAMEPAD_BUTTON_INVALID;
 
     void initGamePad()
     {
         int size;
         char *buffer = file::getFileBuffer("gamecontrollerdb.txt", size);
-        if (SDL_GameControllerAddMappingsFromRW(SDL_RWFromMem(buffer, size), 1) < 0) printf("No s'ha pogut carregar el gamecontrollersdb.txt\n");
+        if (SDL_AddGamepadMappingsFromIO(SDL_IOFromMem(buffer, size), 1) < 0) printf("No s'ha pogut carregar el gamecontrollersdb.txt\n");
         free(buffer);
 
+        int num_gamepads;
+        SDL_JoystickID *gamepads = SDL_GetGamepads(&num_gamepads);
+        if (num_gamepads>0)
+        {
+            gamepad = SDL_OpenGamepad(gamepads[0]);
+            SDL_SetGamepadEventsEnabled(true);
+            SDL_free(gamepads);
+        }
+/*
         const int num_joysticks = SDL_NumJoysticks();
         if (num_joysticks>=1) {
             for (int i=0; i<num_joysticks; ++i) {
                 if (SDL_IsGameController(i)) {
-                    gamepad = SDL_GameControllerOpen(i);
+                    gamepad = SDL_OpenGamepad() GameControllerOpen(i);
                     if (SDL_GameControllerGetAttached(gamepad) == SDL_TRUE) {
                         SDL_GameControllerEventState(SDL_ENABLE);
                         return;
@@ -33,6 +42,7 @@ namespace input
                 }
             }
         }
+*/
     }
 
     void init()
@@ -76,7 +86,7 @@ namespace input
     bool padBtnDown(const int8_t btn)
     {
         if (!gamepad) return false;
-        return SDL_GameControllerGetButton(gamepad, SDL_GameControllerButton(btn)) == 1;
+        return SDL_GetGamepadButton(gamepad, SDL_GamepadButton(btn)) == 1;
     }
 
     // Determina si el botó del pad especificat ha sigut polsat, pero no tornarà a ser true fins
@@ -88,7 +98,7 @@ namespace input
     // Determina si hi ha algun botó del pad polsat ara mateix
     bool anyPadBtn()
     {
-        return pad_btn_down != SDL_CONTROLLER_BUTTON_INVALID;
+        return pad_btn_down != SDL_GAMEPAD_BUTTON_INVALID;
     }
 
     // Torna el codi del botó del pad que està sent polsat ara mateix
@@ -144,7 +154,7 @@ namespace input
     // Torna la posició X actual del ratolí
     const int mouseX()
     {
-        int x;
+        float x;
         SDL_GetMouseState(&x, NULL);
         return x/draw::getZoom();
     }
@@ -152,7 +162,7 @@ namespace input
     // Torna la posició Y actual del ratolí
     const int mouseY()
     {
-        int y;
+        float y;
         SDL_GetMouseState(NULL, &y);
         return y/draw::getZoom();
     }
@@ -160,7 +170,7 @@ namespace input
     // Determina si el botó del ratolí especificat està sent polsada ara mateix
     const bool mouseBtn(const int btn)
     {
-        return (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(btn));
+        return (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON_MASK(btn));
     }
 
     // Determina si el botó especificat ha sigut polsat, pero no tornarà a ser true fins

source/jui.cpp

@@ -2,7 +2,7 @@
 #include "jdraw.h"
 #include "jinput.h"
 #include <string.h>
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace ui
 {

source/jutil.cpp

@@ -1,7 +1,7 @@
 #include "jutil.h"
 #include <string.h>
 #include <ctype.h>
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 namespace util
 {
     int stringToInt(const char *value, std::vector<const char*> strings, std::vector<int> values)

source/log.h

@@ -0,0 +1,27 @@
+#pragma once
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifdef DEBUG
+enum LogLevel { LOG_OK, LOG_FAIL, LOG_WARN, LOG_INFO, LOG_LUART, LOG_LUALD, LOG_VERBOSE, LOG_UNSALTED };
+
+static inline void log_msg(enum LogLevel level, const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+
+    switch (level) {
+        case LOG_OK:   printf("[\033[1;32m OK \033[0m] "); break;
+        case LOG_FAIL: printf("[\033[1;31mFAIL\033[0m] "); break;
+        case LOG_WARN: printf("[\033[1;33mWARN\033[0m] "); break;
+        case LOG_INFO: printf("[\033[1;34mINFO\033[0m] "); break;
+        case LOG_LUART:  printf("[\033[1;35mLUA RUNTIME ERROR\033[0m] "); break;
+        case LOG_LUALD:  printf("[\033[1;35mLUA LOADING ERROR\033[0m] "); break;
+        case LOG_VERBOSE: printf("  - "); break;
+        case LOG_UNSALTED: break;
+    }
+    vprintf(fmt, args);
+    va_end(args);
+}
+#else
+#define log_msg(...) ((void)0)
+#endif

source/m_catslife.cpp

@@ -6,7 +6,7 @@
 #include "actor.h"
 #include "room.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace modules
 {

source/m_editor_bitmap.cpp

@@ -1,7 +1,7 @@
 #include "m_editor_bitmap.h"
 #include "jdraw.h"
 #include "jinput.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "room.h"
 #include "actor.h"
 #include "m_game.h"

source/m_editor_bitmap_file.cpp

@@ -2,7 +2,7 @@
 #include "jdraw.h"
 #include "jinput.h"
 #include "jfile.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "room.h"
 #include "actor.h"
 #include "m_game.h"

source/m_editor_colors.cpp

@@ -1,7 +1,7 @@
 #include "m_editor_colors.h"
 #include "jdraw.h"
 #include "jinput.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "room.h"
 
 namespace modules

source/m_editor_map.cpp

@@ -2,7 +2,7 @@
 #include "jdraw.h"
 #include "jinput.h"
 #include "misc.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "room.h"
 #include "actor.h"
 

source/m_editor_templates.cpp

@@ -2,7 +2,7 @@
 #include "jdraw.h"
 #include "jinput.h"
 #include "misc.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "actor.h"
 #include <vector>
 #include "room.h"

source/m_end_prologo_sequence.cpp

@@ -5,7 +5,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "actor.h"
 
 namespace modules

source/m_end_sequence.cpp

@@ -5,7 +5,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "actor.h"
 
 namespace modules

source/m_gameover.cpp

@@ -6,7 +6,7 @@
 #include "actor.h"
 #include "room.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace modules
 {

source/m_ingame.cpp

@@ -7,7 +7,7 @@
 #include "actor.h"
 #include "room.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace modules
 {

source/m_intro.cpp

@@ -4,7 +4,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "actor.h"
 
 namespace modules

source/m_logo.cpp

@@ -4,7 +4,8 @@
 #include "controller.h"
 #include "jaudio.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
+#include <math.h>
 
 namespace modules
 {

source/m_menu.cpp

@@ -4,7 +4,7 @@
 #include "controller.h"
 #include "jdraw.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "jaudio.h"
 #include "actor.h"
 namespace modules
@@ -32,19 +32,21 @@ namespace modules
 
         int loop()
         {
-            if (controller::pressed(KEY_MENU)) {
+            int max_option = config::getKioskMode() ? 4 : 5;
+
+            if (controller::pressed(KEY_MENU) && !config::getKioskMode()) {
                 return OPTION_EIXIR;
             }
             if (controller::pressed(KEY_DOWN) || input::keyPressed(SDL_SCANCODE_DOWN))
             {
                 audio::playSound("snd_push.wav", SOUND_BASIC);
-                selected_option++; if (selected_option==6) selected_option=min_option;
+                selected_option++; if (selected_option==max_option+1) selected_option=min_option;
             }
 
             if (controller::pressed(KEY_UP) || input::keyPressed(SDL_SCANCODE_UP))
             {
                 audio::playSound("snd_push.wav", SOUND_BASIC);
-                selected_option--; if (selected_option<min_option) selected_option=5;
+                selected_option--; if (selected_option<min_option) selected_option=max_option;
             }
 
             if (controller::pressed(KEY_JUMP) || controller::pressed(KEY_PICK) || input::keyPressed(SDL_SCANCODE_RETURN) )
@@ -72,7 +74,7 @@ namespace modules
                     draw::print2("de   REDEFINIR TECLES", 11, 17, GREEN, FONT_ZOOM_NONE);
                     draw::print2("de   REDEFINIR GAMEPAD", 11, 19, GREEN, FONT_ZOOM_NONE);
                     draw::print2("de   CONFIGURAR AUDIO", 11, 21, GREEN, FONT_ZOOM_NONE);
-                    draw::print2("de   EIXIR", 11, 23, GREEN, FONT_ZOOM_NONE);
+                    if (!config::getKioskMode()) draw::print2("de   EIXIR", 11, 23, GREEN, FONT_ZOOM_NONE);
                     break;
                 case OPTION_JUGAR:
                     if (config::isProgoloDesbloquejat()) draw::print2("de   JUGAR AL PROLOGO", 11, 12, GREEN, FONT_ZOOM_NONE);
@@ -80,7 +82,7 @@ namespace modules
                     draw::print2("de   REDEFINIR TECLES", 11, 17, GREEN, FONT_ZOOM_NONE);
                     draw::print2("de   REDEFINIR GAMEPAD", 11, 19, GREEN, FONT_ZOOM_NONE);
                     draw::print2("de   CONFIGURAR AUDIO", 11, 21, GREEN, FONT_ZOOM_NONE);
-                    draw::print2("de   EIXIR", 11, 23, GREEN, FONT_ZOOM_NONE);
+                    if (!config::getKioskMode()) draw::print2("de   EIXIR", 11, 23, GREEN, FONT_ZOOM_NONE);
                     break;
                 case OPTION_TECLES:
                     if (config::isProgoloDesbloquejat()) draw::print2("de   JUGAR AL PROLOGO", 11, 12, GREEN, FONT_ZOOM_NONE);
@@ -88,7 +90,7 @@ namespace modules
                     draw::print2("fg   REDEFINIR TECLES", 11, 16, YELLOW, FONT_ZOOM_VERTICAL);
                     draw::print2("de   REDEFINIR GAMEPAD", 11, 19, GREEN, FONT_ZOOM_NONE);
                     draw::print2("de   CONFIGURAR AUDIO", 11, 21, GREEN, FONT_ZOOM_NONE);
-                    draw::print2("de   EIXIR", 11, 23, GREEN, FONT_ZOOM_NONE);
+                    if (!config::getKioskMode()) draw::print2("de   EIXIR", 11, 23, GREEN, FONT_ZOOM_NONE);
                     break;
                 case OPTION_GAMEPAD:
                     if (config::isProgoloDesbloquejat()) draw::print2("de   JUGAR AL PROLOGO", 11, 12, GREEN, FONT_ZOOM_NONE);
@@ -96,7 +98,7 @@ namespace modules
                     draw::print2("de   REDEFINIR TECLES", 11, 16, GREEN, FONT_ZOOM_NONE);
                     draw::print2("fg   REDEFINIR GAMEPAD", 11, 18, YELLOW, FONT_ZOOM_VERTICAL);
                     draw::print2("de   CONFIGURAR AUDIO", 11, 21, GREEN, FONT_ZOOM_NONE);
-                    draw::print2("de   EIXIR", 11, 23, GREEN, FONT_ZOOM_NONE);
+                    if (!config::getKioskMode()) draw::print2("de   EIXIR", 11, 23, GREEN, FONT_ZOOM_NONE);
                     break;
                 case OPTION_AUDIO:
                     if (config::isProgoloDesbloquejat()) draw::print2("de   JUGAR AL PROLOGO", 11, 12, GREEN, FONT_ZOOM_NONE);
@@ -104,7 +106,7 @@ namespace modules
                     draw::print2("de   REDEFINIR TECLES", 11, 16, GREEN, FONT_ZOOM_NONE);
                     draw::print2("de   REDEFINIR GAMEPAD", 11, 18, GREEN, FONT_ZOOM_NONE);
                     draw::print2("fg   CONFIGURAR AUDIO", 11, 20, YELLOW, FONT_ZOOM_VERTICAL);
-                    draw::print2("de   EIXIR", 11, 23, GREEN, FONT_ZOOM_NONE);
+                    if (!config::getKioskMode()) draw::print2("de   EIXIR", 11, 23, GREEN, FONT_ZOOM_NONE);
                     break;
                 case OPTION_EIXIR:
                     if (config::isProgoloDesbloquejat()) draw::print2("de   JUGAR AL PROLOGO", 11, 12, GREEN, FONT_ZOOM_NONE);

source/m_menu_audio.cpp

@@ -4,7 +4,7 @@
 #include "controller.h"
 #include "jdraw.h"
 #include "jaudio.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "config.h"
 
 namespace modules

source/m_menu_gamepad.cpp

@@ -4,7 +4,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace modules
 {
@@ -57,7 +57,7 @@ namespace modules
                 }
             } else {
                 const int8_t btn = input::getPadBtnPressed();
-                if (btn != SDL_CONTROLLER_BUTTON_INVALID) {
+                if (btn != SDL_GAMEPAD_BUTTON_INVALID) {
                     config::definePadBtn(selected_option, btn);
                     selected_option++;
                     if (selected_option==6) state = STATE_SELECTING;

source/m_menu_tecles.cpp

@@ -4,7 +4,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 namespace modules
 {

source/m_prologo_intro.cpp

@@ -4,7 +4,7 @@
 #include "jaudio.h"
 #include "controller.h"
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 #include "actor.h"
 
 namespace modules

source/main.cpp

@@ -7,7 +7,7 @@
 #include "console.h"
 #include <string.h>
 #include "config.h"
-#include <SDL2/SDL.h>
+#include <SDL3/SDL.h>
 
 #include "actor.h"
 #include "room.h"
@@ -98,6 +98,10 @@ void loadConfig()
         const int value = SDL_atoi( file::getConfigValue(nombotons[i]).c_str() );
         if (value != 0) config::definePadBtn(i, value);
     }
+
+    if (strcmp(file::getConfigValue("kiosk").c_str(), "yes")==0) config::setKioskMode(true);
+    if (strcmp(file::getConfigValue("infinitelives").c_str(), "yes")==0) config::setInifiniteLives(true);
+
 }
 
 void game::init()
@@ -106,7 +110,7 @@ void game::init()
 
     if (editor::isDevMode()) {
         draw::init("The Pool", 520, 240, zoom);
-        SDL_ShowCursor(true);
+        SDL_ShowCursor();
     } else {
         loadConfig();
         draw::init("The Pool", 320, 240, zoom, fullscreen);