JailDoctor/thepool
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 6 Wiki Activity

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

Browse Source
This commit is contained in:
Raimon Zamora
2026-03-04 08:13:40 +01:00
parent 00c4a08915 5529777ccb
commit 6d09afdf09
37 changed files with 506 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
Makefile
View File

@@ -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"

BIN
data/grayscale.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 148 B

2
lagueirtofile
View File

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

2
source/actor.cpp
View File

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

2
source/actor.h
View File

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

29
source/config.cpp
View File

@@ -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;
}
}

6
source/config.h
View File

@@ -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();
}

31
source/console.cpp
View File

@@ -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 NUM_CMDS 8
#define CMD_SET 7
#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)

1
source/gif.c → source/gif.h
View File

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

386
source/jail_audio.cpp
View File

@@ -1,43 +1,57 @@
#ifndef JA_USESDLMIXER
#include "jail_audio.h"
#include "stb_vorbis.c"
#include <SDL2/SDL.h>
#include "stb_vorbis.h"
#include <SDL3/SDL.h>
#include <stdio.h>
#include "log.h"
#define JA_MAX_SIMULTANEOUS_CHANNELS 5
struct JA_Sound_t {
Uint32 length {0};
Uint8* buffer {NULL};
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;
int pos {0};
int times {0};
JA_Channel_state state { JA_CHANNEL_FREE };
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 {
int samples {0};
int pos {0};
int times {0};
short* output {NULL};
JA_Music_state state {JA_MUSIC_INVALID};
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{NULL};
JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];
JA_Music_t *current_music { nullptr };
JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];
int JA_freq {48000};
SDL_AudioFormat JA_format {AUDIO_S16};
Uint8 JA_channels {2};
int JA_musicVolume = 128;
int JA_soundVolume = 64;
bool JA_musicEnabled = true;
bool JA_soundEnabled = true;
SDL_AudioDeviceID sdlAudioDevice = 0;
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) {
@@ -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) {
JA_freq = freq;
JA_format = format;
JA_channels = channels;
SDL_AudioSpec audioSpec{JA_freq, JA_format, JA_channels, 0, 1024, 0, 0, audioCallback, NULL};
if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
SDL_PauseAudioDevice(sdlAudioDevice, 0);
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_Quit() {
SDL_PauseAudioDevice(sdlAudioDevice, 1);
if (sdlAudioDevice != 0) SDL_CloseAudioDevice(sdlAudioDevice);
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)
{
int chan, samplerate;
JA_Music_t *music = new JA_Music_t();
music->samples = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &music->output);
// [RZC 28/08/22] Abans el descomprimiem mentre el teniem obert
// music->samples = stb_vorbis_decode_filename(filename, &chan, &samplerate, &music->output);
int chan, samplerate;
short *output;
music->length = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &output) * chan * 2;
SDL_AudioCVT cvt;
SDL_BuildAudioCVT(&cvt, AUDIO_S16, chan, samplerate, JA_format, JA_channels, JA_freq);
if (cvt.needed) {
cvt.len = music->samples * chan * 2;
cvt.buf = (Uint8 *) SDL_malloc(cvt.len * cvt.len_mult);
SDL_memcpy(cvt.buf, music->output, cvt.len);
SDL_ConvertAudio(&cvt);
free(music->output);
music->output = (short*)cvt.buf;
}
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;
@@ -137,110 +209,133 @@ void JA_PlayMusic(JA_Music_t *music, const int loop)
{
if (!JA_musicEnabled) return;
if (current_music != NULL) {
current_music->pos = 0;
current_music->state = JA_MUSIC_STOPPED;
}
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;
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() {
if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
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;
if (current_music == NULL) return JA_MUSIC_INVALID;
return current_music->state;
}
void JA_DeleteMusic(JA_Music_t *music) {
if (current_music == music) current_music = NULL;
free(music->output);
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;
}
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_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;
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 *JA_LoadSound(const char* filename)
{
JA_Sound_t *sound = new JA_Sound_t();
SDL_AudioSpec wavSpec;
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;
SDL_LoadWAV(filename, &sound->spec, &sound->buffer, &sound->length);
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) {
for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
if (channels[i].state == JA_CHANNEL_PLAYING) channels[i].state = JA_CHANNEL_PAUSED;
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);
}
} 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) {
for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
if (channels[i].state == JA_CHANNEL_PAUSED) channels[i].state = JA_CHANNEL_PLAYING;
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);
}
} 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;
JA_soundVolume = JA_musicVolume/2;
return JA_soundEnabled;
}
float JA_SetVolume(float volume)
{
JA_SetSoundVolume(JA_SetMusicVolume(volume) / 2.0f);
return JA_musicVolume;
}

14
source/jail_audio.h
View File

@@ -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);

4
source/jaudio.cpp
View File

@@ -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);
}

77
source/jdraw.cpp
View File

@@ -1,6 +1,6 @@
#include "jdraw.h"
#include <SDL2/SDL.h>
#include "gif.c"
#include <SDL3/SDL.h>
#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_renderer = SDL_CreateRenderer(sdl_window, -1, 0);
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, 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, info.name);
printf(" - %i: %s\n", i, SDL_GetRenderDriver(i));
}
SDL_GetRendererInfo(sdl_renderer, &info);
printf("\nRenderer: %s\n", info.name);
printf("\nRenderer: %s\n", SDL_GetRendererName(sdl_renderer));
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_renderer = SDL_CreateRenderer(sdl_window, -1, 0);
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, 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;
SDL_GetCurrentDisplayMode(0, &dm);
if (screen_width*value > dm.w) return;
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,10 +676,34 @@ 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
const uint32_t size = screen->w * screen->h; // tamany de la superficie
@@ -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);
}
}
}

28
source/jgame.cpp
View File

@@ -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_KEYDOWN)
if (e.type==SDL_EVENT_QUIT) { game::should_exit = true; break; }
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) {
input::updatePadBtn(e.cbutton.button);
input::updatePadBtnPressed(e.cbutton.button);
if (e.type==SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
input::updatePadBtn(e.gbutton.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::updatePadBtnPressed(SDL_CONTROLLER_BUTTON_INVALID);
input::updatePadBtn(SDL_GAMEPAD_BUTTON_INVALID);
input::updatePadBtnPressed(SDL_GAMEPAD_BUTTON_INVALID);
}
}

34
source/jinput.cpp
View File

@@ -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 int8_t pad_btn_pressed = SDL_CONTROLLER_BUTTON_INVALID;
static int8_t pad_btn_down = SDL_CONTROLLER_BUTTON_INVALID;
static SDL_Gamepad *gamepad = NULL;
static int8_t pad_btn_pressed = SDL_GAMEPAD_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

2
source/jui.cpp
View File

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

2
source/jutil.cpp
View File

@@ -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)

27
source/log.h Normal file
View File

@@ -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

2
source/m_catslife.cpp
View File

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

2
source/m_editor_bitmap.cpp
View File

@@ -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"

2
source/m_editor_bitmap_file.cpp
View File

@@ -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"

2
source/m_editor_colors.cpp
View File

@@ -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

2
source/m_editor_map.cpp
View File

@@ -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"

2
source/m_editor_templates.cpp
View File

@@ -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"

2
source/m_end_prologo_sequence.cpp
View File

@@ -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

2
source/m_end_sequence.cpp
View File

@@ -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

2
source/m_gameover.cpp
View File

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

2
source/m_ingame.cpp
View File

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

2
source/m_intro.cpp
View File

@@ -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

3
source/m_logo.cpp
View File

@@ -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
{

20
source/m_menu.cpp
View File

@@ -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);

2
source/m_menu_audio.cpp
View File

@@ -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

4
source/m_menu_gamepad.cpp
View File

@@ -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;

2
source/m_menu_tecles.cpp
View File

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

2
source/m_prologo_intro.cpp
View File

@@ -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

8
source/main.cpp
View File

@@ -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);

0
source/stb_vorbis.c → source/stb_vorbis.h
View File