jaildesigner-jailgames/aee
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

pasada la granera per la carpeta

Browse Source
This commit is contained in:
Sergio
2026-04-04 12:38:48 +02:00
parent 6474d731d0
commit 9e0ab87c76
42 changed files with 128 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
source/bola.cpp Normal file
View File

@@ -0,0 +1,68 @@
#include "bola.h"
#include "jgame.h"
#include <stdlib.h>
Bola::Bola( JD8_Surface gfx, Prota* sam ) : Sprite( gfx ) {
this->sam = sam;
this->entitat = (Entitat*)malloc( sizeof( Entitat ) );
// Frames
this->entitat->num_frames = 2;
this->entitat->frames = (Frame*)malloc( this->entitat->num_frames * sizeof( Frame ) );
this->entitat->frames[0].w = 15;
this->entitat->frames[0].h = 15;
this->entitat->frames[0].x = 30;
this->entitat->frames[0].y = 155;
this->entitat->frames[1].w = 15;
this->entitat->frames[1].h = 15;
this->entitat->frames[1].x = 45;
this->entitat->frames[1].y = 155;
// Animacions
this->entitat->num_animacions = 1;
this->entitat->animacions = (Animacio*)malloc( this->entitat->num_animacions * sizeof( Animacio ) );
this->entitat->animacions[0].num_frames = 2;
this->entitat->animacions[0].frames = (Uint8*)malloc( 2 );
this->entitat->animacions[0].frames[0] = 0;
this->entitat->animacions[0].frames[1] = 1;
this->cur_frame = 0;
this->o = 0;
this->cycles_per_frame = 4;
this->x = 20;
this->y = 100;
this->contador = 0;
}
void Bola::draw() {
if( this->contador == 0 ) Sprite::draw();
}
void Bola::update() {
if( this->contador == 0 ) {
// Augmentem la x
this->x++;
if( this->x == 280 ) this->contador = 200;
// Augmentem el frame
if( JG_GetCycleCounter() % this->cycles_per_frame == 0 ) {
this->cur_frame++;
if( this->cur_frame == this->entitat->animacions[this->o].num_frames ) this->cur_frame = 0;
}
// Comprovem si ha tocat a Sam
if( this->x > ( this->sam->x - 7 ) && this->x < ( this->sam->x + 7 ) && this->y > ( this->sam->y - 7 ) && this->y < ( this->sam->y + 7 ) ) {
this->contador = 200;
info::vida--;
if( info::vida == 0 ) this->sam->o = 5;
}
} else {
this->contador--;
if( this->contador == 0 ) this->x = 20;
}
}

22
source/bola.h Normal file
View File

@@ -0,0 +1,22 @@
#pragma once
#include "sprite.h"
#include "prota.h"
#include "info.h"
class Bola : public Sprite {
public:
Bola( JD8_Surface gfx, Prota* sam );
void draw();
void update();
protected:
Uint8 contador;
Prota* sam;
};

64
source/engendro.cpp Normal file
View File

@@ -0,0 +1,64 @@
#include "engendro.h"
#include "jgame.h"
#include <stdlib.h>
Engendro::Engendro( JD8_Surface gfx, Uint16 x, Uint16 y ) : Sprite( gfx ) {
this->entitat = (Entitat*)malloc( sizeof( Entitat ) );
// Frames
this->entitat->num_frames = 4;
this->entitat->frames = (Frame*)malloc( this->entitat->num_frames * sizeof( Frame ) );
Uint8 frame = 0;
for( int y = 50; y <= 65; y+=15 ) {
for( int x = 225; x <= 240; x+=15 ) {
this->entitat->frames[frame].w = 15;
this->entitat->frames[frame].h = 15;
this->entitat->frames[frame].x = x;
this->entitat->frames[frame].y = y;
frame++;
}
}
// Animacions
this->entitat->num_animacions = 1;
this->entitat->animacions = (Animacio*)malloc( this->entitat->num_animacions * sizeof( Animacio ) );
this->entitat->animacions[0].num_frames = 6;
this->entitat->animacions[0].frames = (Uint8*)malloc( 6 );
this->entitat->animacions[0].frames[0] = 0;
this->entitat->animacions[0].frames[1] = 1;
this->entitat->animacions[0].frames[2] = 2;
this->entitat->animacions[0].frames[3] = 3;
this->entitat->animacions[0].frames[4] = 2;
this->entitat->animacions[0].frames[5] = 1;
this->cur_frame = 0;
this->vida = 18;
this->x = x;
this->y = y;
this->o = 0;
this->cycles_per_frame = 30;
}
void Engendro::draw() {
Sprite::draw();
}
bool Engendro::update() {
bool mort = false;
if( JG_GetCycleCounter() % this->cycles_per_frame == 0 ) {
this->cur_frame++;
if( this->cur_frame == this->entitat->animacions[this->o].num_frames ) this->cur_frame = 0;
this->vida--;
}
if( vida == 0 ) mort = true;
return mort;
}

18
source/engendro.h Normal file
View File

@@ -0,0 +1,18 @@
#pragma once
#include "sprite.h"
class Engendro : public Sprite {
public:
Engendro( JD8_Surface gfx, Uint16 x, Uint16 y );
void draw();
bool update();
protected:
Uint8 vida;
};

507
source/gif.h Normal file
View File

@@ -0,0 +1,507 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#define EXTENSION_INTRODUCER 0x21
#define IMAGE_DESCRIPTOR 0x2C
#define TRAILER 0x3B
#define GRAPHIC_CONTROL 0xF9
#define APPLICATION_EXTENSION 0xFF
#define COMMENT_EXTENSION 0xFE
#define PLAINTEXT_EXTENSION 0x01
#define READ(dst, size) memcpy(dst, buffer, size); buffer += size
typedef struct
{
unsigned short width;
unsigned short height;
unsigned char fields;
unsigned char background_color_index;
unsigned char pixel_aspect_ratio;
}
screen_descriptor_t;
typedef struct
{
unsigned char r;
unsigned char g;
unsigned char b;
}
rgb;
typedef struct
{
unsigned short image_left_position;
unsigned short image_top_position;
unsigned short image_width;
unsigned short image_height;
unsigned char fields;
}
image_descriptor_t;
typedef struct
{
unsigned char byte;
int prev;
int len;
}
dictionary_entry_t;
typedef struct
{
unsigned char extension_code;
unsigned char block_size;
}
extension_t;
typedef struct
{
unsigned char fields;
unsigned short delay_time;
unsigned char transparent_color_index;
}
graphic_control_extension_t;
typedef struct
{
unsigned char application_id[ 8 ];
unsigned char version[ 3 ];
}
application_extension_t;
typedef struct
{
unsigned short left;
unsigned short top;
unsigned short width;
unsigned short height;
unsigned char cell_width;
unsigned char cell_height;
unsigned char foreground_color;
unsigned char background_color;
}
plaintext_extension_t;
//static unsigned short width = 0;
//static unsigned short height = 0;
//static unsigned char* uncompressed_data = NULL;
void uncompress( int code_length,
const unsigned char *input,
int input_length,
unsigned char *out )
{
//int maxbits;
int i, bit;
int code, prev = -1;
dictionary_entry_t *dictionary;
int dictionary_ind;
unsigned int mask = 0x01;
int reset_code_length;
int clear_code; // This varies depending on code_length
int stop_code; // one more than clear code
int match_len;
clear_code = 1 << ( code_length );
stop_code = clear_code + 1;
// To handle clear codes
reset_code_length = code_length;
// Create a dictionary large enough to hold "code_length" entries.
// Once the dictionary overflows, code_length increases
dictionary = ( dictionary_entry_t * )
malloc( sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
// Initialize the first 2^code_len entries of the dictionary with their
// indices. The rest of the entries will be built up dynamically.
// Technically, it shouldn't be necessary to initialize the
// dictionary. The spec says that the encoder "should output a
// clear code as the first code in the image data stream". It doesn't
// say must, though...
for ( dictionary_ind = 0;
dictionary_ind < ( 1 << code_length );
dictionary_ind++ )
{
dictionary[ dictionary_ind ].byte = dictionary_ind;
// XXX this only works because prev is a 32-bit int (> 12 bits)
dictionary[ dictionary_ind ].prev = -1;
dictionary[ dictionary_ind ].len = 1;
}
// 2^code_len + 1 is the special "end" code; don't give it an entry here
dictionary_ind++;
dictionary_ind++;
// TODO verify that the very last byte is clear_code + 1
while ( input_length )
{
code = 0x0;
// Always read one more bit than the code length
for ( i = 0; i < ( code_length + 1 ); i++ )
{
// This is different than in the file read example; that
// was a call to "next_bit"
bit = ( *input & mask ) ? 1 : 0;
mask <<= 1;
if ( mask == 0x100 )
{
mask = 0x01;
input++;
input_length--;
}
code = code | ( bit << i );
}
if ( code == clear_code )
{
code_length = reset_code_length;
dictionary = ( dictionary_entry_t * ) realloc( dictionary,
sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
for ( dictionary_ind = 0;
dictionary_ind < ( 1 << code_length );
dictionary_ind++ )
{
dictionary[ dictionary_ind ].byte = dictionary_ind;
// XXX this only works because prev is a 32-bit int (> 12 bits)
dictionary[ dictionary_ind ].prev = -1;
dictionary[ dictionary_ind ].len = 1;
}
dictionary_ind++;
dictionary_ind++;
prev = -1;
continue;
}
else if ( code == stop_code )
{
if ( input_length > 1 )
{
fprintf( stderr, "Malformed GIF (early stop code)\n" );
exit( 0 );
}
break;
}
// Update the dictionary with this character plus the _entry_
// (character or string) that came before it
if ( ( prev > -1 ) && ( code_length < 12 ) )
{
if ( code > dictionary_ind )
{
fprintf( stderr, "code = %.02x, but dictionary_ind = %.02x\n",
code, dictionary_ind );
exit( 0 );
}
// Special handling for KwKwK
if ( code == dictionary_ind )
{
int ptr = prev;
while ( dictionary[ ptr ].prev != -1 )
{
ptr = dictionary[ ptr ].prev;
}
dictionary[ dictionary_ind ].byte = dictionary[ ptr ].byte;
}
else
{
int ptr = code;
while ( dictionary[ ptr ].prev != -1 )
{
ptr = dictionary[ ptr ].prev;
}
dictionary[ dictionary_ind ].byte = dictionary[ ptr ].byte;
}
dictionary[ dictionary_ind ].prev = prev;
dictionary[ dictionary_ind ].len = dictionary[ prev ].len + 1;
dictionary_ind++;
// GIF89a mandates that this stops at 12 bits
if ( ( dictionary_ind == ( 1 << ( code_length + 1 ) ) ) &&
( code_length < 11 ) )
{
code_length++;
dictionary = ( dictionary_entry_t * ) realloc( dictionary,
sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
}
}
prev = code;
// Now copy the dictionary entry backwards into "out"
match_len = dictionary[ code ].len;
while ( code != -1 )
{
out[ dictionary[ code ].len - 1 ] = dictionary[ code ].byte;
if ( dictionary[ code ].prev == code )
{
fprintf( stderr, "Internal error; self-reference." );
exit( 0 );
}
code = dictionary[ code ].prev;
}
out += match_len;
}
}
static int read_sub_blocks( unsigned char* buffer, unsigned char **data )
{
int data_length;
int index;
unsigned char block_size;
// Everything following are data sub-blocks, until a 0-sized block is
// encountered.
data_length = 0;
*data = NULL;
index = 0;
while ( 1 )
{
READ(&block_size, 1);
if ( block_size == 0 ) // end of sub-blocks
{
break;
}
data_length += block_size;
*data = (unsigned char*)realloc( *data, data_length );
// TODO this could be split across block size boundaries
READ(*data + index, block_size);
index += block_size;
}
return data_length;
}
unsigned char* process_image_descriptor( unsigned char* buffer,
rgb *gct,
int gct_size,
int resolution_bits )
{
image_descriptor_t image_descriptor;
int disposition;
int compressed_data_length;
unsigned char *compressed_data = NULL;
unsigned char lzw_code_size;
int uncompressed_data_length = 0;
unsigned char *uncompressed_data = NULL;
// TODO there could actually be lots of these
READ(&image_descriptor, 9);
// TODO if LCT = true, read the LCT
disposition = 1;
READ(&lzw_code_size, 1);
compressed_data_length = read_sub_blocks( buffer, &compressed_data );
// width = image_descriptor.image_width;
// height = image_descriptor.image_height;
uncompressed_data_length = image_descriptor.image_width *
image_descriptor.image_height;
uncompressed_data = (unsigned char*)malloc( uncompressed_data_length );
uncompress( lzw_code_size, compressed_data, compressed_data_length,
uncompressed_data );
if ( compressed_data ) free( compressed_data );
//if ( uncompressed_data )
// free( uncompressed_data );
return uncompressed_data;
}
static int process_extension( unsigned char* buffer )
{
extension_t extension;
graphic_control_extension_t gce;
application_extension_t application;
plaintext_extension_t plaintext;
unsigned char *extension_data = NULL;
int extension_data_length;
READ(&extension, 2);
switch ( extension.extension_code )
{
case GRAPHIC_CONTROL:
READ(&gce, 4);
break;
case APPLICATION_EXTENSION:
READ(&application, 11);
break;
case 0xFE:
// comment extension; do nothing - all the data is in the
// sub-blocks that follow.
break;
case 0x01:
READ(&plaintext, 12);
break;
default:
fprintf( stderr, "Unrecognized extension code.\n" );
exit( 0 );
}
// All extensions are followed by data sub-blocks; even if it's
// just a single data sub-block of length 0
extension_data_length = read_sub_blocks( buffer, &extension_data );
if ( extension_data != NULL )
free( extension_data );
return 1;
}
/**
* @param gif_file the file descriptor of a file containing a
* GIF-encoded file. This should point to the first byte in
* the file when invoked.
*/
unsigned char* LoadPalette(unsigned char *buffer) {
unsigned char header[7];
screen_descriptor_t screen_descriptor;
int color_resolution_bits;
int global_color_table_size = 0; // number of entries in global_color_table
rgb *global_color_table = NULL;
READ(header, 6);
READ(&screen_descriptor, 7);
color_resolution_bits = ((screen_descriptor.fields & 0x70) >> 4) + 1;
global_color_table = (rgb *)calloc(1, 768);
if (screen_descriptor.fields & 0x80) {
global_color_table_size = 1 << (((screen_descriptor.fields & 0x07) + 1));
//global_color_table = (rgb *)malloc(3 * global_color_table_size);
READ(global_color_table, 3 * global_color_table_size);
}
return (unsigned char*)global_color_table;
}
static unsigned char* process_gif_stream(unsigned char *buffer, unsigned short* w, unsigned short* h)
{
unsigned char header[ 7 ];
screen_descriptor_t screen_descriptor;
int color_resolution_bits;
int global_color_table_size =0; // number of entries in global_color_table
rgb *global_color_table = NULL;
unsigned char block_type = 0x0;
// A GIF file starts with a Header (section 17)
READ(header, 6);
header[ 6 ] = 0x0;
// XXX there's another format, GIF87a, that you may still find
// floating around.
if ( strcmp( "GIF89a", (char*)header ) )
{
fprintf( stderr,
"Invalid GIF file (header is '%s', should be 'GIF89a')\n",
header );
return NULL;
}
// Followed by a logical screen descriptor
// Note that this works because GIFs specify little-endian order; on a
// big-endian machine, the height & width would need to be reversed.
// Can't use sizeof here since GCC does byte alignment;
// sizeof( screen_descriptor_t ) = 8!
READ(&screen_descriptor, 7);
color_resolution_bits = ( ( screen_descriptor.fields & 0x70 ) >> 4 ) + 1;
if ( screen_descriptor.fields & 0x80 )
{
//int i;
// If bit 7 is set, the next block is a global color table; read it
global_color_table_size = 1 <<
( ( ( screen_descriptor.fields & 0x07 ) + 1 ) );
global_color_table = ( rgb * ) malloc( 3 * global_color_table_size );
// XXX this could conceivably return a short count...
READ(global_color_table, 3 * global_color_table_size);
}
while ( block_type != TRAILER )
{
READ(&block_type, 1);
switch ( block_type )
{
case IMAGE_DESCRIPTOR:
return process_image_descriptor(buffer,
global_color_table,
global_color_table_size,
color_resolution_bits);
break;
case EXTENSION_INTRODUCER:
if ( !process_extension( buffer ) )
{
return NULL;
}
break;
case TRAILER:
break;
default:
fprintf( stderr, "Bailing on unrecognized block type %.02x\n",
block_type );
return NULL;
}
}
return NULL;
}
unsigned char* LoadGif(unsigned char *buffer, unsigned short* w, unsigned short* h) {
return process_gif_stream(buffer, w, h);
}
/*int main( int argc, char *argv[] )
{
FILE* gif_file;
if ( argc < 2 )
{
fprintf( stderr, "Usage: %s <path-to-gif-file>\n", argv[ 0 ] );
exit( 0 );
}
gif_file = fopen( argv[ 1 ], "rb" );
if ( gif_file == NULL )
{
fprintf( stderr, "Unable to open file '%s'", argv[ 1 ] );
perror( ": " );
}
process_gif_stream( gif_file );
fclose( gif_file );
}*/

14
source/info.cpp Normal file
View File

@@ -0,0 +1,14 @@
#include "info.h"
namespace info
{
int num_piramide;
int num_habitacio;
int diners;
int diamants;
int vida;
int momies;
int engendros;
bool nou_personatge;
bool pepe_activat;
};

14
source/info.h Normal file
View File

@@ -0,0 +1,14 @@
#pragma once
namespace info
{
extern int num_piramide;
extern int num_habitacio;
extern int diners;
extern int diamants;
extern int vida;
extern int momies;
extern int engendros;
extern bool nou_personatge;
extern bool pepe_activat;
};

509
source/jail_audio.cpp Normal file
View File

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

41
source/jail_audio.h Normal file
View File

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

234
source/jdraw8.cpp Normal file
View File

@@ -0,0 +1,234 @@
#include "jdraw8.h"
#include "jfile.h"
#include <fstream>
#include "gif.h"
#include "jshader.h"
#define SCREEN_WIDTH 960
#define SCREEN_HEIGHT 720
JD8_Surface screen = NULL;
JD8_Palette main_palette = NULL;
Uint32* pixel_data = NULL;
int screenWidth = 320;
int screenHeight = 200;
Uint32 contadorFPS = 0;
Uint32 tempsFPS = SDL_GetTicks();
char *fps = (char *)malloc(10);
SDL_Window* sdlWindow = NULL;
SDL_Renderer* sdlRenderer = NULL;
SDL_Texture* sdlTexture = NULL;
SDL_Texture* backBuffer = NULL;
void JD8_Init(const char *title) {
screen = (JD8_Surface)calloc( 1, 64000 );
main_palette = (JD8_Palette)calloc( 1, 768 );
pixel_data = (Uint32*)calloc(1, 320 * 200 * 4); // 1048576 );
sdlWindow = SDL_CreateWindow( title, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_OPENGL );
SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
//SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "nearest");
sdlRenderer = SDL_CreateRenderer(sdlWindow, NULL);
sdlTexture = SDL_CreateTexture(sdlRenderer, SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_STREAMING, 320, 200);
backBuffer = SDL_CreateTexture(sdlRenderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, 320, 200);
int filesize = 0;
char *buffer = file_getfilebuffer("crtpi.glsl", filesize, true);
shader::init(sdlWindow, backBuffer, buffer);
free(buffer);
}
void JD8_Quit() {
if( screen != NULL ) free( screen );
if( main_palette != NULL ) free( main_palette );
if( pixel_data != NULL ) free( pixel_data );
SDL_DestroyRenderer(sdlRenderer);
SDL_DestroyWindow( sdlWindow );
}
void JD8_ClearScreen(Uint8 color) {
memset( screen, color, 64000 );
}
JD8_Surface JD8_NewSurface() {
JD8_Surface surface = (JD8_Surface)malloc( 64000 );
memset( surface, 0, 64000 );
return surface;
}
JD8_Surface JD8_LoadSurface(const char *file) {
int filesize = 0;
char *buffer = file_getfilebuffer(file, filesize);
unsigned short w, h;
Uint8* pixels = LoadGif((unsigned char*)buffer, &w, &h);
free(buffer);
if (pixels == NULL) {
printf("Unable to load bitmap: %s\n", SDL_GetError());
exit(1);
}
JD8_Surface image = JD8_NewSurface();
memcpy(image, pixels, 64000);
free(pixels);
return image;
}
JD8_Palette JD8_LoadPalette(const char *file) {
int filesize = 0;
char *buffer = NULL;
buffer = file_getfilebuffer(file, filesize);
JD8_Palette palette = (JD8_Palette)LoadPalette((unsigned char*)buffer);
return palette;
}
void JD8_SetScreenPalette(JD8_Palette palette) {
if (main_palette == palette) return;
if( main_palette != NULL) free( main_palette );
main_palette = palette;
}
void JD8_FillSquare(int ini, int height, Uint8 color) {
const int offset = ini * 320;
const int size = height * 320;
memset(&screen[offset], color, size);
}
void JD8_Blit(JD8_Surface surface) {
memcpy( screen, surface, 64000 );
}
void JD8_Blit(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh) {
int src_pointer = sx + (sy*320);
int dst_pointer = x + (y*320);
for( int i = 0; i < sh; i++ ) {
memcpy( &screen[dst_pointer], &surface[src_pointer], sw );
src_pointer += 320;
dst_pointer += 320;
}
}
void JD8_BlitToSurface(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, JD8_Surface dest) {
int src_pointer = sx + (sy*320);
int dst_pointer = x + (y*320);
for( int i = 0; i < sh; i++ ) {
memcpy( &dest[dst_pointer], &surface[src_pointer], sw );
src_pointer += 320;
dst_pointer += 320;
}
}
void JD8_BlitCK(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, Uint8 colorkey ) {
int src_pointer = sx + (sy*320);
int dst_pointer = x + (y*320);
for( int j = 0; j < sh; j++ ) {
for( int i = 0; i < sw; i++ ) {
if( surface[src_pointer+i] != colorkey ) screen[dst_pointer+i] = surface[src_pointer+i];
}
src_pointer += 320;
dst_pointer += 320;
}
}
void JD8_BlitCKCut(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, Uint8 colorkey) {
int src_pointer = sx + (sy * 320);
int dst_pointer = x + (y * 320);
for (int j = 0; j < sh; j++) {
for (int i = 0; i < sw; i++) {
if (surface[src_pointer + i] != colorkey && (x+i >= 0) && (y+j >= 0) && (x+i < 320) && (y+j < 200)) screen[dst_pointer + i] = surface[src_pointer + i];
}
src_pointer += 320;
dst_pointer += 320;
}
}
void JD8_BlitCKScroll(int y, JD8_Surface surface, int sx, int sy, int sh, Uint8 colorkey) {
int dst_pointer = y * 320;
for (int j = sy; j < sy+sh; j++) {
for (int i = 0; i < 320; i++) {
int x = (i+sx) % 320;
if (surface[x + j*320] != colorkey) screen[dst_pointer] = surface[x + j * 320];
dst_pointer++;
}
}
}
void JD8_BlitCKToSurface(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, JD8_Surface dest, Uint8 colorkey) {
int src_pointer = sx + (sy*320);
int dst_pointer = x + (y*320);
for( int j = 0; j < sh; j++ ) {
for( int i = 0; i < sw; i++ ) {
if( surface[src_pointer+i] != colorkey ) dest[dst_pointer+i] = surface[src_pointer+i];
}
src_pointer += 320;
dst_pointer += 320;
}
}
SDL_Rect rect{0, 0, SCREEN_WIDTH, SCREEN_HEIGHT};
void JD8_Flip() {
for( int x = 0; x < 320; x++ ) {
for( int y = 0; y < 200; y++ ) {
Uint32 color = 0xFF000000 + main_palette[screen[x + ( y * 320 )]].r + ( main_palette[screen[x + ( y * 320 )]].g << 8 ) + ( main_palette[screen[x + ( y * 320 )]].b << 16 );
pixel_data[x + ( y * 320 )] = color;
}
}
SDL_UpdateTexture(sdlTexture, NULL, pixel_data, 320 * sizeof(Uint32));
SDL_SetRenderTarget(sdlRenderer, backBuffer);
SDL_RenderTexture(sdlRenderer, sdlTexture, NULL, NULL);
shader::render();
//SDL_RenderPresent(sdlRenderer);
}
void JD8_FreeSurface(JD8_Surface surface) {
free( surface );
}
Uint8 JD8_GetPixel( JD8_Surface surface, int x, int y ) {
return surface[x + (y*320)];
}
void JD8_PutPixel( JD8_Surface surface, int x, int y, Uint8 pixel ) {
surface[x + (y*320)] = pixel;
}
void JD8_SetPaletteColor(Uint8 index, Uint8 r, Uint8 g, Uint8 b) {
main_palette[index].r = r << 2;
main_palette[index].g = g << 2;
main_palette[index].b = b << 2;
}
void JD8_FadeOut() {
for( int j = 0; j < 32; j++ ) {
for( int i = 0; i < 256; i++ ) {
if( main_palette[i].r >= 8 ) main_palette[i].r-=8; else main_palette[i].r=0;
if( main_palette[i].g >= 8 ) main_palette[i].g-=8; else main_palette[i].g=0;
if( main_palette[i].b >= 8 ) main_palette[i].b-=8; else main_palette[i].b=0;
}
JD8_Flip();
}
}
#define MAX(a, b) (a) > (b) ? (a) : (b)
void JD8_FadeToPal( JD8_Palette pal ) {
for( int j = 0; j < 32; j++ ) {
for( int i = 0; i < 256; i++ ) {
if( main_palette[i].r <= int(pal[i].r)-8 ) main_palette[i].r+=8; else main_palette[i].r=pal[i].r;
if( main_palette[i].g <= int(pal[i].g)-8 ) main_palette[i].g+=8; else main_palette[i].g=pal[i].g;
if( main_palette[i].b <= int(pal[i].b)-8 ) main_palette[i].b+=8; else main_palette[i].b=pal[i].b;
}
JD8_Flip();
}
}

61
source/jdraw8.h Normal file
View File

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

231
source/jfile.cpp Normal file
View File

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

18
source/jfile.h Normal file
View File

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

43
source/jgame.cpp Normal file
View File

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

16
source/jgame.h Normal file
View File

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

52
source/jinput.cpp Normal file
View File

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

12
source/jinput.h Normal file
View File

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

231
source/jshader.cpp Normal file
View File

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

44
source/jshader.h Normal file
View File

@@ -0,0 +1,44 @@
#pragma once
#include <SDL3/SDL.h>
// TIPS:
// =======================================================================
// Abans de crear el renderer, cridar a la següent funció:
//
// SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
//
// Aixó li diu que volem un renderer que use especificament opengl. A més,
// al crear el renderer li tenim que dir que el volem que use acceeració
// per hardware, i que soporte render a textura. Per exemple:
//
// SDL_Renderer *ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED |
// SDL_RENDERER_TARGETTEXTURE);
//
// Per altra part, al crear la textura tenim que definir que puga ser target
// de renderitzat (SDL_TEXTUREACCESS_TARGET), per exemple:
//
// SDL_Texture *tex = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
// SDL_TEXTUREACCESS_TARGET, 320, 240);
//
// Els shaders li'ls passem com una cadena, som nosaltres els que s'encarreguem
// de carregarlos de disc, amb fopen, ifstream, jfile o el que vullgues.
// Si els tens en un std::string, passa-li-la com "cadena.c_str()".
//
// Poden ser els dos el mateix arxiu, com fa libRetro, jo desde dins ja fique
// els defines necessaris. Si es el mateix arxiu, pots no ficar el quart paràmetre.
//
// Els shaders de libRetro no funcionen directament, hi ha que fer algunes modificacions.
//
// El pintat final de la teua escena l'has de fer com si "backBuffer" fora la pantalla.
//
// Ah! una cosa mes: al compilar, en Linux afegir "-lGL", en Windows afegir "-lopengl32".
// En Mac ni idea
namespace shader
{
const bool init(SDL_Window* win, SDL_Texture* backBuffer,
const char* vertexShader, const char* fragmentShader=nullptr);
void render();
}

80
source/main.cpp Normal file
View File

@@ -0,0 +1,80 @@
#include "jgame.h"
#include "jdraw8.h"
#include "jail_audio.h"
#include "jfile.h"
#include "info.h"
#include "modulegame.h"
#include "modulesequence.h"
#include "time.h"
#include <string>
/*
#ifndef WIN32
#include <libgen.h>
#endif
*/
int main( int argc, char* args[] ) {
//file_setresourcefilename("data.jrf");
/*#ifdef WIN32
JF_SetResourceFile("data.jrf");
#else
char res_file[255] = "";
strcpy(res_file, dirname(args[0]));
#ifdef __APPLE__
strcat(res_file, "/../Resources/data.jrf");
#else
strcat(res_file, "/data.jrf");
#endif
printf("ARXIU DE RECURSOS: %s\n", res_file);
JF_SetResourceFile(res_file);
#endif
*/
srand( unsigned(time(NULL)) );
JG_Init();
JD8_Init("Aventures En Egipte");
JA_Init(48000, SDL_AUDIO_S16, 2);
info::num_habitacio = 1;
info::num_piramide = 255;
info::diners = 0;
info::diamants = 0;
info::vida = 5;
info::momies = 0;
info::nou_personatge = false;
info::pepe_activat = false;
FILE* ini = fopen("trick.ini", "rb");
if (ini != NULL) {
info::nou_personatge = true;
fclose(ini);
}
int gameState = 1;
while (gameState != -1) {
switch (gameState) {
case 0:
ModuleGame* moduleGame;
moduleGame = new ModuleGame();
gameState = moduleGame->Go();
delete moduleGame;
break;
case 1:
ModuleSequence* moduleSequence;
moduleSequence = new ModuleSequence();
gameState = moduleSequence->Go();
delete moduleSequence;
break;
}
}
JA_Quit();
JD8_Quit();
JG_Finalize();
return 0;
}

292
source/mapa.cpp Normal file
View File

@@ -0,0 +1,292 @@
#include "mapa.h"
#include "jgame.h"
#include "jinput.h"
#include <stdlib.h>
Mapa::Mapa( JD8_Surface gfx, Prota* sam ) {
this->gfx = gfx;
this->sam = sam;
this->preparaFondoEstatic();
this->preparaTombes();
this->ultim_vertex.columna = 255;
this->frame_torxes = 0;
this->farao = false;
this->clau = false;
this->porta_oberta = false;
this->nova_momia = false;
}
Mapa::~Mapa(void) {
JD8_FreeSurface( this->fondo );
}
void Mapa::draw() {
if( info::num_piramide != 4 ) {
switch( sam->o ) {
case 0: // Down
JD8_BlitCKToSurface( sam->x, sam->y, this->gfx, 15, 125 + sam->frame_pejades, 15, 1, this->fondo, 255 );
break;
case 1: // Up
JD8_BlitCKToSurface( sam->x, sam->y + 15, this->gfx, 0, 125 + ( 14 - sam->frame_pejades ), 15, 1, this->fondo, 255 );
break;
case 2: // Right
JD8_BlitCKToSurface( sam->x + 7, sam->y, this->gfx, 30 + sam->frame_pejades, 125, 1, 15, this->fondo, 255 );
break;
case 3: // Left
JD8_BlitCKToSurface( sam->x + 8, sam->y, this->gfx, 45 + ( 14 - sam->frame_pejades ), 125, 1, 15, this->fondo, 255 );
break;
}
}
JD8_Blit( this->fondo );
// Pinta tombes
for (int y = 0; y < 4; y++) {
for (int x = 0; x < 4; x++) {
JD8_BlitCK(35 + (x * 65), 45 + (y * 35), this->gfx, this->tombes[x + y * 4].x, this->tombes[x + y * 4].y, 50, 20, 255);
}
}
JD8_BlitCK( 45, 15, this->gfx, 30 + ( this->frame_torxes * 25 ), 80, 25, 15, 255 );
JD8_BlitCK( 95, 15, this->gfx, 30 + ( this->frame_torxes * 25 ), 80, 25, 15, 255 );
JD8_BlitCK( 195, 15, this->gfx, 30 + ( this->frame_torxes * 25 ), 80, 25, 15, 255 );
JD8_BlitCK( 245, 15, this->gfx, 30 + ( this->frame_torxes * 25 ), 80, 25, 15, 255 );
};
void Mapa::update() {
if( ( ( sam->x - 20 ) % 65 == 0 ) && ( ( sam->y - 30 ) % 35 == 0 ) && ( ( this->ultim_vertex.columna != ( sam->x - 20 ) / 65 ) || ( this->ultim_vertex.fila != ( sam->y - 30 ) / 35 ) ) ) {
this->vertex.columna = ( sam->x - 20 ) / 65;
this->vertex.fila = ( sam->y - 30 ) / 35;
if( this->ultim_vertex.columna != 255 ) this->comprovaUltimCami();
this->ultim_vertex = this->vertex;
}
if( this->porta_oberta && sam->x == 150 && sam->y == 30 ) {
if( JI_KeyPressed( SDL_SCANCODE_UP ) ) {
this->sam->o = 4;
this->sam->y -= 15;
}
}
if( JG_GetCycleCounter()%8 == 0 ) {
this->frame_torxes++;
this->frame_torxes = this->frame_torxes % 4;
}
}
bool Mapa::novaMomia() {
bool resultat = nova_momia;
nova_momia = false;
return resultat;
}
void Mapa::preparaFondoEstatic() {
// Prepara el fondo est<73>tic de l'habitaci<63>
this->fondo = JD8_NewSurface();
if (info::num_piramide == 6) {
JD8_BlitToSurface(9, 2, this->gfx, 227, 185, 92, 7, this->fondo); // Text "SECRETA"
}
else {
JD8_BlitToSurface(9, 2, this->gfx, 60, 185, 39, 7, this->fondo); // Text "NIVELL"
JD8_BlitToSurface(72, 6, this->gfx, 153, 189, 3, 1, this->fondo); // Ralleta entre num piramide i num habitacio
}
JD8_BlitToSurface(130, 2, this->gfx, 225, 192, 19, 8, this->fondo); // Montonet de monedes + signe '='
JD8_BlitToSurface(220, 2, this->gfx, 160, 185, 48, 7, this->fondo); // Text "ENERGIA"
if (info::diners >= 200) JD8_BlitToSurface(175, 3, this->gfx, 60, 193, 7, 6, this->fondo);
// Pinta taulells
for( int y = 0; y < 11; y++ ) {
for( int x = 0; x < 19; x++ ) {
switch( info::num_piramide ) {
case 1:
JD8_BlitToSurface( 20+(x*15), 30+(y*15), this->gfx, 0, 80, 15, 15, this->fondo );
break;
case 2:
JD8_BlitToSurface( 20+(x*15), 30+(y*15), this->gfx, 25, 95, 15, 15, this->fondo );
break;
case 3:
JD8_BlitToSurface( 20+(x*15), 30+(y*15), this->gfx, 40, 95, 15, 15, this->fondo );
break;
case 4:
JD8_BlitToSurface( 20+(x*15), 30+(y*15), this->gfx, 175 + ((rand()%3)*15), 80, 15, 15, this->fondo );
break;
case 5:
JD8_BlitToSurface( 20+(x*15), 30+(y*15), this->gfx, 130, 80, 15, 15, this->fondo );
break;
case 6:
JD8_BlitToSurface(20 + (x * 15), 30 + (y * 15), this->gfx, 145, 80, 15, 15, this->fondo);
break;
}
}
}
// Pinta vores de les parets
JD8_BlitCKToSurface( 5, 15, this->gfx, 30, 110, 15, 15, this->fondo, 255 );
JD8_BlitCKToSurface( 295, 15, this->gfx, 45, 110, 15, 15, this->fondo, 255 );
JD8_BlitCKToSurface( 5, 180, this->gfx, 0, 155, 15, 20, this->fondo, 255 );
JD8_BlitCKToSurface( 295, 180, this->gfx, 15, 155, 15, 20, this->fondo, 255 );
// Pinta parets verticals
for( int i = 0; i < 10; i++ ) {
JD8_BlitToSurface( 5, 30+(i*15), this->gfx, 0, 110, 15, 15, this->fondo );
JD8_BlitToSurface( 295, 30+(i*15), this->gfx, 15, 110, 15, 15, this->fondo );
}
// Pinta parets hortzintals
for( int i = 0; i < 11; i++ ) {
JD8_BlitToSurface( 20+(i*25), 185, this->gfx, 0, 95, 25, 15, this->fondo );
JD8_BlitToSurface( 20+(i*25), 15, this->gfx, 0, 95, 25, 15, this->fondo );
}
// Pinta la porta
JD8_BlitCKToSurface( 150, 18, this->gfx, 0, 143, 15, 12, this->fondo, 255 );
if( info::num_piramide == 2 ) {
JD8_BlitToSurface( 5, 100, this->gfx, 30, 140, 15, 15, this->fondo );
}
}
void swap( Uint8& a, Uint8& b ) {
Uint8 temp = a;
a = b;
b = temp;
}
void Mapa::preparaTombes() {
const Uint8 contingut = info::num_piramide == 6 ? CONTE_DIAMANT : CONTE_RES;
int cx = info::num_piramide == 6 ? 270 : 0;
int cy = info::num_piramide == 6 ? 50 : 0;
for( int i = 0; i < 16; i++ ) {
this->tombes[i].contingut = contingut;
this->tombes[i].oberta = false;
this->tombes[i].costat[0] = false;
this->tombes[i].costat[1] = false;
this->tombes[i].costat[2] = false;
this->tombes[i].costat[3] = false;
this->tombes[i].x = cx;
this->tombes[i].y = cy;
}
if (info::num_piramide == 6) return;
this->tombes[0].contingut = CONTE_FARAO;
this->tombes[1].contingut = CONTE_CLAU;
this->tombes[2].contingut = CONTE_PERGAMI;
this->tombes[3].contingut = CONTE_MOMIA;
for( int i = 4; i < 8; i++ ) this->tombes[i].contingut = CONTE_RES;
for( int i = 8; i < 16; i++ ) this->tombes[i].contingut = CONTE_TRESOR;
for( int i = 0; i < 50; i++ ) swap( this->tombes[rand()%16].contingut, this->tombes[rand()%16].contingut );
}
Uint8 minim( Uint8 a, Uint8 b ) {
return (a<b)?a:b;
}
void Mapa::comprovaUltimCami() {
Uint8 col_aux = abs( this->vertex.columna - this->ultim_vertex.columna );
Uint8 fil_aux = abs( this->vertex.fila - this->ultim_vertex.fila );
if( col_aux > fil_aux ) { // Cam<61> horitzontal
Uint8 cami_fila = this->vertex.fila;
Uint8 cami_columna = minim( this->vertex.columna, this->ultim_vertex.columna );
Sint8 caixa_avall = ( cami_fila << 2 ) + cami_columna;
Sint8 caixa_amunt = caixa_avall - 4;
if( caixa_avall < 16 ) {
this->tombes[caixa_avall].costat[0] = true;
this->comprovaCaixa( caixa_avall );
}
if( caixa_amunt >= 0 ) {
this->tombes[caixa_amunt].costat[2] = true;
this->comprovaCaixa( caixa_amunt );
}
} else { // Cam<61> vertical
Uint8 cami_columna = this->vertex.columna;
Uint8 cami_fila = minim( this->vertex.fila, this->ultim_vertex.fila );
Sint8 caixa_dreta = ( cami_fila << 2 ) + cami_columna;
Sint8 caixa_esquerra = caixa_dreta - 1;
if( caixa_dreta <= ( cami_fila << 2 ) + 3 ) {
this->tombes[caixa_dreta].costat[3] = true;
this->comprovaCaixa( caixa_dreta );
}
if( caixa_esquerra >= ( cami_fila << 2 ) ) {
this->tombes[caixa_esquerra].costat[1] = true;
this->comprovaCaixa( caixa_esquerra );
}
}
}
void Mapa::comprovaCaixa( Uint8 num )
{
// Si la tomba ja està oberta, no hi ha res que mirar
if( this->tombes[num].oberta ) return;
// Si algun costat encara no està passat, no hi ha res que fer
for( int i = 0; i < 4; i++ ) if( !this->tombes[num].costat[i] ) return;
// Sinó, pos la acabem d'obrir
this->tombes[num].oberta = true;
// Comprobem el premi del kinder sorpresa
switch( this->tombes[num].contingut )
{
case CONTE_RES:
this->tombes[num].x = 50;
break;
case CONTE_TRESOR:
this->tombes[num].x = 100;
info::diners++;
break;
case CONTE_FARAO:
this->tombes[num].x = 150;
this->farao = true;
break;
case CONTE_CLAU:
this->tombes[num].x = 200;
this->clau = true;
break;
case CONTE_MOMIA:
this->tombes[num].y = 175;
this->nova_momia = true;
break;
case CONTE_PERGAMI:
this->tombes[num].x = 250;
this->sam->pergami = true;
break;
case CONTE_DIAMANT:
this->tombes[num].y = 70;
info::diamants++;
info::diners += VALOR_DIAMANT;
if (info::diamants == 16) this->farao = this->clau = true;
break;
}
this->comprovaPorta();
}
void Mapa::comprovaPorta() {
if( this->clau && this->farao ) {
JD8_BlitCKToSurface( 150, 18, this->gfx, 15, 143, 15, 12, this->fondo, 255 );
porta_oberta = true;
}
}

64
source/mapa.h Normal file
View File

@@ -0,0 +1,64 @@
#pragma once
#include "jdraw8.h"
#include "info.h"
#include "prota.h"
#define CONTE_RES 0
#define CONTE_TRESOR 1
#define CONTE_FARAO 2
#define CONTE_CLAU 3
#define CONTE_MOMIA 4
#define CONTE_PERGAMI 5
#define CONTE_DIAMANT 6
#define VALOR_DIAMANT 5
struct Tomba {
bool costat[4];
Uint8 contingut;
bool oberta;
Uint16 x, y;
};
struct Vertex {
Uint8 columna;
Uint8 fila;
};
class Mapa {
public:
Mapa( JD8_Surface gfx, Prota* sam );
~Mapa(void);
void draw();
void update();
bool novaMomia();
void comprovaCaixa( Uint8 num );
Tomba tombes[16];
protected:
void preparaFondoEstatic();
void preparaTombes();
void comprovaUltimCami();
void comprovaPorta();
JD8_Surface gfx;
JD8_Surface fondo;
Vertex vertex;
Vertex ultim_vertex;
Uint8 frame_torxes;
Prota* sam;
bool farao;
bool clau;
bool porta_oberta;
bool nova_momia;
};

62
source/marcador.cpp Normal file
View File

@@ -0,0 +1,62 @@
#include "marcador.h"
Marcador::Marcador( JD8_Surface gfx, Prota* sam ) {
this->gfx = gfx;
this->sam = sam;
}
Marcador::~Marcador(void) {
}
void Marcador::draw() {
if (info::num_piramide < 6) {
this->pintaNumero(55, 2, info::num_piramide);
this->pintaNumero(80, 2, info::num_habitacio);
}
this->pintaNumero( 149, 2, info::diners / 100 );
this->pintaNumero( 156, 2, ( info::diners % 100 ) / 10 );
this->pintaNumero( 163, 2, info::diners % 10 );
if( this->sam->pergami ) JD8_BlitCK( 190, 1, this->gfx, 209, 185, 15, 14, 255 );
JD8_BlitCK( 271, 1, this->gfx, 0, 20, 15, info::vida*3, 255 );
if( info::vida < 5 ) JD8_BlitCK( 271, 1+(info::vida*3), this->gfx, 75, 20, 15, 15-(info::vida*3), 255 );
}
void Marcador::pintaNumero( Uint16 x, Uint16 y, Uint8 num ) {
switch( num ) {
case 0:
JD8_BlitCK( x, y, this->gfx, 141, 193, 10, 7, 255 );
break;
case 1:
JD8_BlitCK( x, y, this->gfx, 100, 185, 10, 7, 255 );
break;
case 2:
JD8_BlitCK( x, y, this->gfx, 110, 185, 10, 7, 255 );
break;
case 3:
JD8_BlitCK( x, y, this->gfx, 120, 185, 10, 7, 255 );
break;
case 4:
JD8_BlitCK( x, y, this->gfx, 130, 185, 10, 7, 255 );
break;
case 5:
JD8_BlitCK( x, y, this->gfx, 140, 185, 10, 7, 255 );
break;
case 6:
JD8_BlitCK( x, y, this->gfx, 101, 193, 10, 7, 255 );
break;
case 7:
JD8_BlitCK( x, y, this->gfx, 111, 193, 10, 7, 255 );
break;
case 8:
JD8_BlitCK( x, y, this->gfx, 121, 193, 10, 7, 255 );
break;
case 9:
JD8_BlitCK( x, y, this->gfx, 131, 193, 10, 7, 255 );
break;
}
}

23
source/marcador.h Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
#include "jdraw8.h"
#include "info.h"
#include "prota.h"
class Marcador {
public:
Marcador( JD8_Surface gfx, Prota* sam );
~Marcador(void);
void draw();
protected:
void pintaNumero( Uint16 x, Uint16 y, Uint8 num );
JD8_Surface gfx;
Prota* sam;
};

166
source/modulegame.cpp Normal file
View File

@@ -0,0 +1,166 @@
#include "modulegame.h"
#include "jgame.h"
#include "jdraw8.h"
#include "jail_audio.h"
#include "jinput.h"
#include "jfile.h"
ModuleGame::ModuleGame() {
this->gfx = JD8_LoadSurface( info::pepe_activat ? "frames2.gif" : "frames.gif" );
JG_SetUpdateTicks(10);
this->sam = new Prota( this->gfx );
this->mapa = new Mapa( this->gfx, this->sam );
this->marcador = new Marcador( this->gfx, this->sam );
if( info::num_piramide == 2 ) {
this->bola = new Bola( this->gfx, this->sam );
} else {
this->bola = NULL;
}
this->momies = NULL;
this->final = 0;
this->iniciarMomies();
}
ModuleGame::~ModuleGame(void) {
JD8_FadeOut();
if( this->bola != NULL ) delete this->bola;
if( this->momies != NULL ) {
this->momies->clear();
delete this->momies;
}
delete this->marcador;
delete this->mapa;
delete this->sam;
JD8_FreeSurface( this->gfx );
}
int ModuleGame::Go() {
this->Draw();
const char* music = info::num_piramide == 3 ? "00000008.ogg" : (info::num_piramide == 2 ? "00000007.ogg" : (info::num_piramide == 6 ? "00000002.ogg" : "00000006.ogg"));
const char *current_music = JA_GetMusicFilename();
if ( (JA_GetMusicState()!=JA_MUSIC_PLAYING) || !(strcmp(music, current_music) == 0)) {
int size;
char *buffer = file_getfilebuffer(music, size);
JA_PlayMusic(JA_LoadMusic((Uint8*)buffer, size, music));
}
JD8_FadeToPal( JD8_LoadPalette(info::pepe_activat ? "frames2.gif" : "frames.gif") );
while (this->final == 0 && !JG_Quitting()) {
this->Draw();
this->Update();
}
//JS_FadeOutMusic();
if( this->final == 1 ) {
info::num_habitacio++;
if( info::num_habitacio == 6 ) {
info::num_habitacio = 1;
info::num_piramide++;
}
if (info::num_piramide == 6 && info::num_habitacio == 2) info::num_piramide++;
} else if (this->final == 2) {
info::num_piramide = 100;
}
if( JG_Quitting() ) {
return -1;
} else {
if (info::num_habitacio == 1 || info::num_piramide == 100 || info::num_piramide == 7) {
return 1;
} else {
return 0;
}
}
}
void ModuleGame::Draw() {
this->mapa->draw();
this->marcador->draw();
this->sam->draw();
if( this->momies != NULL ) this->momies->draw();
if( this->bola != NULL ) this->bola->draw();
JD8_Flip();
}
void ModuleGame::Update() {
if (JG_ShouldUpdate()) {
JI_Update();
this->final = this->sam->update();
if( this->momies != NULL && this->momies->update() ) {
Momia* seguent = this->momies->next;
delete this->momies;
this->momies = seguent;
info::momies--;
}
if( this->bola != NULL ) this->bola->update();
this->mapa->update();
if( this->mapa->novaMomia() ) {
if( this->momies != NULL ) {
this->momies->insertar( new Momia( this->gfx, true, 0, 0, this->sam ) );
info::momies++;
} else {
this->momies = new Momia( this->gfx, true, 0, 0, this->sam );
info::momies++;
}
}
if( JI_CheatActivated( "reviu" ) ) info::vida = 5;
if( JI_CheatActivated( "alone" ) ) {
if( this->momies != NULL ) {
this->momies->clear();
delete this->momies;
this->momies = NULL;
info::momies = 0;
}
}
if( JI_CheatActivated( "obert" ) ) {
for( int i = 0; i < 16; i++ ) {
this->mapa->tombes[i].costat[0] = true;
this->mapa->tombes[i].costat[1] = true;
this->mapa->tombes[i].costat[2] = true;
this->mapa->tombes[i].costat[3] = true;
this->mapa->comprovaCaixa( i );
}
}
if( JI_KeyPressed( SDL_SCANCODE_ESCAPE ) ) {
JG_QuitSignal();
}
}
}
void ModuleGame::iniciarMomies() {
if( info::num_habitacio == 1 ) { info::momies = 1; } else { info::momies++; }
if (info::num_piramide == 6) info::momies = 8;
int x = 20;
int y = 170;
bool dimonis = info::num_piramide == 6;
for( int i = 0; i < info::momies; i++ ) {
if( this->momies == NULL) {
this->momies = new Momia( this->gfx, dimonis, x, y, this->sam );
} else {
this->momies->insertar( new Momia( this->gfx, dimonis, x, y, this->sam ) );
}
x += 65;
if( x == 345 ) { x = 20; y -= 35; }
}
}

35
source/modulegame.h Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include "info.h"
#include "mapa.h"
#include "prota.h"
#include "marcador.h"
#include "momia.h"
#include "bola.h"
class ModuleGame {
public:
ModuleGame();
~ModuleGame(void);
int Go();
private:
void Draw();
void Update();
void iniciarMomies();
Uint8 final;
JD8_Surface gfx;
Mapa* mapa;
Prota* sam;
Marcador* marcador;
Momia* momies;
Bola* bola;
};

948
source/modulesequence.cpp Normal file
View File

@@ -0,0 +1,948 @@
#include "modulesequence.h"
#include "jgame.h"
#include "jdraw8.h"
#include "jinput.h"
#include "jfile.h"
#include "jail_audio.h"
#include <stdlib.h>
#include <string>
ModuleSequence::ModuleSequence() {
}
ModuleSequence::~ModuleSequence(void) {
}
int ModuleSequence::Go() {
if( info::num_piramide == 6 && info::diners < 200 ) info::num_piramide = 7;
switch( info::num_piramide ) {
case 255: // Intro
doIntro();
break;
case 0: // Men<65>
doMenu();
break;
case 1: // Slides
case 7:
doSlides();
break;
case 2: // Pre-pir<69>mide
case 3:
case 4:
case 5:
doBanner();
break;
case 6: // Pre-Secreta
doSecreta();
break;
case 8: // Credits
doCredits();
break;
case 100: // Mort
doMort();
break;
}
JD8_FadeOut();
if( JG_Quitting() ) {
return -1;
} else {
if( info::num_piramide == 255 ) {
info::num_piramide = 0;
return 1;
} else if( info::num_piramide == 0 ) {
info::num_piramide = 1;
//info::num_piramide = 6;
//info::diners = 200;
return 1;
} else if( info::num_piramide == 7 ) {
info::num_piramide = 8;
return 1;
} else if( info::num_piramide == 8 ) {
info::num_piramide = 255;
return 1;
} else if( info::num_piramide == 100 ) {
info::num_piramide = 0;
return 1;
} else {
return 0;
}
}
return 0;
}
const int minim( const int a, const int b ) {
if( b < a ) { return b; } else { return a; }
}
void play_music(const char *music, bool loop = -1)
{
int size;
char *buffer = file_getfilebuffer(music, size);
JA_PlayMusic(JA_LoadMusic((Uint8*)buffer, size, music), loop);
}
void ModuleSequence::doIntro() {
JG_SetUpdateTicks(1000);
play_music("00000003.ogg");
JD8_Surface gfx = JD8_LoadSurface( "logo.gif" );
JD8_Palette pal = JD8_LoadPalette( "logo.gif" );
JD8_SetScreenPalette( pal );
JD8_ClearScreen( 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JG_SetUpdateTicks(100);
JD8_Blit( 43, 78, gfx, 43, 155, 27, 45 );
JD8_Blit( 68, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_Blit( 43, 78, gfx, 43, 155, 53, 45 );
JD8_Blit( 96, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_Blit( 43, 78, gfx, 43, 155, 66, 45 );
JD8_Blit( 109, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JG_SetUpdateTicks(200);
JD8_Blit( 43, 78, gfx, 43, 155, 92, 45 );
JD8_Blit( 136, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 92, 45 );
//JD8_Blit( 136, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JG_SetUpdateTicks(100);
JD8_Blit( 43, 78, gfx, 43, 155, 118, 45 );
JD8_Blit( 160, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_Blit( 43, 78, gfx, 43, 155, 145, 45 );
JD8_Blit( 188, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_Blit( 43, 78, gfx, 43, 155, 178, 45 );
JD8_Blit( 221, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_Blit( 43, 78, gfx, 43, 155, 205, 45 );
JD8_Blit( 248, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JG_SetUpdateTicks(200);
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
JD8_Blit( 274, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
JD8_Blit( 274, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
JD8_Blit( 274, 78, gfx, 274, 155, 27, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
for( int j = 0; j < 256; j++ ) {
for( int i = 16; i < 32; i++ ) {
if( i == 17 ) {
if( pal[i].r < 255 ) pal[i].r++;
if( pal[i].g < 255 ) pal[i].g++;
if( pal[i].b < 255 ) pal[i].b++;
}
if( pal[i].b < pal[i].g ) pal[i].b++;
if( pal[i].b > pal[i].g ) pal[i].b--;
if( pal[i].r < pal[i].g ) pal[i].r++;
if( pal[i].r > pal[i].g ) pal[i].r--;
}
JD8_Flip();
}
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
JG_SetUpdateTicks(20);
Uint16 fr1 = 13;
Uint16 fr2 = fr1;
Uint16 fr3 = 11;
Uint16 fr4 = fr3;
Uint16 fr5 = 20;
Uint16 fr6 = 8;
Uint16 fr7 = 29;
Uint16 fr8 = 4;
Uint16 fr9 = 16;
Uint16 fr10 = fr9;
Uint16 fr11 = 6;
Uint16 creu = 75;
Uint16 interrogant = 90;
Uint16 fr_ani_1[13]; // camina dreta
Uint16 fr_ani_2[13]; // camina esquerra
Uint16 fr_ani_3[11]; // trau el mapa DRETA
Uint16 fr_ani_4[11]; // trau el mapa ESQUERRA
Uint16 fr_ani_5[20]; // bot de susto
Uint16 fr_ani_6[8]; // momia
Uint16 fr_ani_7[29]; // deixa caure el PAPER i SOMBRA
Uint16 fr_ani_8[4]; // PEDRA
Uint16 fr_ani_9[16]; // prota BALL
Uint16 fr_ani_10[16]; // momia BALL
Uint16 fr_ani_11[6]; // altaveu
for( int i=0; i < fr1; i++ ) fr_ani_1[i] = i*15;
for( int i=0; i < fr2; i++ ) fr_ani_2[i] = i*15; //15
for( int i=0; i < fr3; i++ ) fr_ani_3[i] = i*15; //30
for( int i=0; i < fr4; i++ ) fr_ani_4[i] = i*15; //45
for( int i=0; i <= 9; i++ ) fr_ani_5[i] = (i+11)*15; //45
for( int i=10; i <= 19; i++ ) fr_ani_5[i] = fr_ani_5[19-i];
for( int i=0; i < fr6; i++ ) fr_ani_6[i] = i*15; //60
for( int i=0; i <= 13; i++ ) fr_ani_7[i] = (i+5)*15; //75
for( int i=14; i < fr7; i++ ) fr_ani_7[i] = (i-14)*15; //105
for( int i=0; i < fr8; i++ ) fr_ani_8[i] = (i+1)*15; //75
for( int i=0; i < fr9; i++ ) fr_ani_9[i] = i*15; //120
for( int i=0; i < fr10; i++ ) fr_ani_10[i] = i*15; //135
for( int i=0; i < fr11; i++ ) fr_ani_11[i] = (i+1)*15; //90
fr_ani_11[fr11-1] = fr_ani_11[3];
switch( rand()%3 ) {
case 0:
// camina cap a la DRETA }
for( int i = 0; i <= 200; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_1[(i div 5) mod fr1],15,15,i,150);
JD8_BlitCK( i, 150, gfx, fr_ani_1[(i / 5) % fr1], 0, 15, 15, 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// trau el MAPA DRETA }
for( int i = 0; i <= 200; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_3[minim((i div 5),fr3-1)],15,15,200,150);
JD8_BlitCK( 200, 150, gfx, fr_ani_3[minim((i / 5), fr3-1)], 30, 15, 15, 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// guarda el MAPA }
for( int i = 200; i >= 0; i-- ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_3[minim((i div 5),fr3-1)],15,15,200,150);
JD8_BlitCK( 200, 150, gfx, fr_ani_3[minim((i / 5), fr3-1)], 30, 15, 15, 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// camina cap a la ESQUERRA }
for( int i = 200; i >= 80; i-- ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_2[(i div 5) mod fr2],15,15,i,150);
JD8_BlitCK( i, 150, gfx, fr_ani_2[(i / 5) % fr2], 15, 15, 15, 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// trau el MAPA ESQUERRA }
for( int i = 0; i <= 200; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_4[minim((i div 5),fr4-1)],15,15,80,150);
JD8_BlitCK( 80, 150, gfx, fr_ani_4[minim((i / 5), fr4-1)], 45, 15, 15, 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// momia cap a la ESQUERRA }
for( int i = 300; i >= 95; i-- ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_6[(i div 10) mod fr6],15,15,i,150);
JD8_BlitCK( i, 150, gfx, fr_ani_6[(i / 5) % fr6], 60, 15, 15, 0 );
//Put_sprite(from,where,fr_ani_4[fr4-1],15,15,80,150);
JD8_BlitCK( 80, 150, gfx, fr_ani_4[fr4-1], 45, 15, 15, 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// girar-se }
for( int i = 0; i <= 50; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_1[1],15,15,80,150);
JD8_BlitCK( 80, 150, gfx, fr_ani_1[1], 0, 15, 15, 0 );
//Put_sprite(from,where,fr_ani_6[4],15,15,95,150);
JD8_BlitCK( 95, 150, gfx, fr_ani_6[4], 60, 15, 15, 0 );
//Put_sprite(from,where,interrogant,15,15,80,133);
JD8_BlitCK( 80, 133, gfx, 0, interrogant, 15, 15, 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// bot de SUSTO }
for( int i = 0; i <= 49; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_5[minim((i div 5),fr5-1)],15,15,80,150-((i mod 50) div 5));
JD8_BlitCK( 80, 150-((i % 50) / 5), gfx, fr_ani_5[minim(i/5, fr5-1)], 45, 15, 15, 0 );
//Put_sprite(from,where,fr_ani_6[4],15,15,95,150);
JD8_BlitCK( 95, 150, gfx, fr_ani_6[4], 60, 15, 15, 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// bot de SUSTO }
for( int i = 50; i <= 99; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_5[minim((i div 5),fr5-1)],15,15,80,140+((i mod 50) div 5));
JD8_BlitCK( 80, 140+((i % 50) / 5), gfx, fr_ani_5[minim(i/5, fr5-1)], 45, 15, 15, 0 );
//Put_sprite(from,where,fr_ani_6[4],15,15,95,150);
JD8_BlitCK( 95, 150, gfx, fr_ani_6[4], 60, 15, 15, 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// camina cap a la ESQUERRA }
for( int i = 80; i >= 0; i-- ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_2[(i div 5) mod fr2],15,15,i,150);
JD8_BlitCK( i, 150, gfx, fr_ani_2[(i/5) % fr2], 15, 15, 15, 0 );
//Put_sprite(from,where,fr_ani_6[4],15,15,95,150);
JD8_BlitCK( 95, 150, gfx, fr_ani_6[4], 60, 15, 15, 0 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// final }
for( int i = 0; i <= 150; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_6[4],15,15,95,150);
JD8_BlitCK( 95, 150, gfx, fr_ani_6[4], 60, 15, 15, 0 );
//Put_sprite(from,where,interrogant,15,15,95,133);
JD8_BlitCK( 95, 133, gfx, 0, interrogant, 15, 15, 0 );
JD8_Flip();
}
//-----}
break;
case 1:
// camina cap a la DRETA }
for( int i = 0; i <= 200; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,creu,15,15,200,155);
JD8_BlitCK( 200, 155, gfx, 0, creu, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_1[(i div 5) mod fr1],15,15,i,150);
JD8_BlitCK( i, 150, gfx, fr_ani_1[(i/5) % fr1], 0, 15, 15, 255 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// trau el MAPA DRETA }
for( int i = 0; i <= 300; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,creu,15,15,200,155);
JD8_BlitCK( 200, 155, gfx, 0, creu, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_3[minim((i div 5),fr3-1)],15,15,200,150);
JD8_BlitCK( 200, 150, gfx, fr_ani_3[minim(i/5, fr3-1)], 30, 15, 15, 255 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// INTERROGANT }
for( int i = 0; i <= 100; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,creu,15,15,200,155);
JD8_BlitCK( 200, 155, gfx, 0, creu, 15, 15, 255 );
//Put_sprite(from,where,interrogant,15,15,200,134);
JD8_BlitCK( 200, 134, gfx, 0, interrogant, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_3[fr3-1],15,15,200,150);
JD8_BlitCK( 200, 150, gfx, fr_ani_3[fr3-1], 30, 15, 15, 255 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// deixa caure el MAPA i SOMBRA }
for( int i = 0; i <= 200; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,creu,15,15,200,155);
JD8_BlitCK( 200, 155, gfx, 0, creu, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_7[minim((i div 5),fr7-1)],15,15,200,150);
if( minim(i/5, fr7-1) <= 13 ) {
JD8_BlitCK( 200, 150, gfx, fr_ani_7[minim(i/5, fr7-1)], 75, 15, 15, 255 );
} else {
JD8_BlitCK( 200, 150, gfx, fr_ani_7[minim(i/5, fr7-1)], 105, 15, 15, 255 );
}
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// SOMBRA i PEDRA }
for( int i = 0; i <= 75; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,creu,15,15,200,155);
JD8_BlitCK( 200, 155, gfx, 0, creu, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_7[fr7-1],15,15,200,150);
JD8_BlitCK( 200, 150, gfx, fr_ani_7[fr7-1], 105, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_8[0],15,15,200,i*2);
JD8_BlitCK( 200, i*2, gfx, fr_ani_8[0], 75, 15, 15, 255 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// trencar PEDRA }
for( int i = 0; i <= 19; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,creu,15,15,200,155);
JD8_BlitCK( 200, 155, gfx, 0, creu, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_8[i div 10],15,15,200,150);
JD8_BlitCK( 200, 150, gfx, fr_ani_8[i/10], 75, 15, 15, 255 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// FINAL }
for( int i = 0; i <= 200; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,creu,15,15,200,155);
JD8_BlitCK( 200, 155, gfx, 0, creu, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_8[1],15,15,200,150);
JD8_BlitCK( 200, 150, gfx, fr_ani_8[1], 75, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_8[2],15,15,185,150);
JD8_BlitCK( 185, 150, gfx, fr_ani_8[2], 75, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_8[3],15,15,215,150);
JD8_BlitCK( 215, 150, gfx, fr_ani_8[3], 75, 15, 15, 255 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
break;
case 2:
// camina cap a la DRETA }
for( int i = 0; i <= 145; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_1[(i div 5) mod fr1],15,15,i,150);
JD8_BlitCK( i, 150, gfx, fr_ani_1[(i/5) % fr1], 0, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_6[(i div 10) mod fr6],15,15,304-i,150);
JD8_BlitCK( 304-i, 150, gfx, fr_ani_6[(i/10) % fr6], 60, 15, 15, 255 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// els dos quets }
for( int i = 0; i <= 100; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_1[1],15,15,145,150);
JD8_BlitCK( 145, 150, gfx, fr_ani_1[1], 0, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_6[1],15,15,160,150);
JD8_BlitCK( 160, 150, gfx, fr_ani_6[1], 60, 15, 15, 255 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// aparicio altaveu }
for( int i = 0; i <= 50; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_11[(i div 10) mod 2],15,15,125,150);
JD8_BlitCK( 125, 150, gfx, fr_ani_11[(i/10) % 2], 90, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_1[1],15,15,145,150);
JD8_BlitCK( 145, 150, gfx, fr_ani_1[1], 0, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_6[1],15,15,160,150);
JD8_BlitCK( 160, 150, gfx, fr_ani_6[1], 60, 15, 15, 255 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
// BALL }
for( int i = 0; i <= 800; i++ ) {
JD8_ClearScreen( 0 );
JD8_Blit( 43, 78, gfx, 43, 155, 231, 45 );
//Put_sprite(from,where,fr_ani_9[(i div 10) mod fr9],15,15,145,150);
JD8_BlitCK( 145, 150, gfx, fr_ani_9[(i/10) % fr9], 120, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_10[(i div 10) mod fr10],15,15,160,150);
JD8_BlitCK( 160, 150, gfx, fr_ani_10[(i/10) % fr10], 135, 15, 15, 255 );
//Put_sprite(from,where,fr_ani_11[((i div 5) mod 4)+2],15,15,125,150);
JD8_BlitCK( 125, 150, gfx, fr_ani_11[((i/5) % 4)+2], 90, 15, 15, 255 );
JD8_Flip();
while( !JG_ShouldUpdate() ) { JI_Update(); if( JI_AnyKey() || JG_Quitting() ) { JD8_FreeSurface( gfx ); return; } }
}
break;
}
JD8_FreeSurface( gfx );
}
void ModuleSequence::doMenu() {
JG_SetUpdateTicks(20);
JD8_Surface fondo = JD8_LoadSurface( "menu.gif" );
JD8_Surface gfx = JD8_LoadSurface( "menu2.gif" );
JD8_Palette pal = JD8_LoadPalette( "menu2.gif" );
JD8_Blit( fondo );
JD8_BlitCK( 100, 25, gfx, 0, 74, 124, 68, 255 ); // logo
JD8_BlitCK( 130, 100, gfx, 0, 0, 80, 74, 255 );
JD8_BlitCK( 0, 150, gfx, 0, 150, 320, 50, 255 );
JD8_FadeToPal( pal );
contador = 0;
int palmeres = 0;
int horitzo = 0;
int camello = 0;
JI_Update();
while( !JI_AnyKey() && !JG_Quitting() && !JI_KeyPressed(SDL_SCANCODE_P)) {
JD8_Blit( 0, 0, fondo, 0, 0, 320, 100 ); // fondo sol estatic
JD8_BlitCK( horitzo, 100, fondo, 0, 100, 320-horitzo, 100, 255 ); // fondo moviment
JD8_BlitCK( 0, 100, fondo, 320-horitzo, 100, horitzo, 100, 255 );
JD8_BlitCK( 100, 25, gfx, 0, 74, 124, 68, 255 ); // logo
JD8_BlitCK( 130, 100, gfx, camello*80, 0, 80, 74, 255 ); // camello
JD8_BlitCK( palmeres, 150, gfx, 0, 150, 320-palmeres, 50, 255 ); // palemeres moviment
JD8_BlitCK( 0, 150, gfx, 320-palmeres, 150, palmeres, 50, 255 );
JD8_BlitCK( 87, 167, gfx, 127, 124, 150, 24, 255 ); // jdes
JD8_BlitCK( 303, 193, gfx, 305, 143, 15, 5, 255 ); // versio
if( contador%100 > 30 ) JD8_BlitCK( 98, 130, gfx, 161, 92, 127, 9, 255 ); // pulsa tecla...
if ((contador % 100 > 30) && info::nou_personatge) JD8_BlitCK(68, 141, gfx, 128, 105, 189, 9, 255); // 'p' per a personatge nou...
JD8_Flip();
if( JG_ShouldUpdate() ) {
if( contador%4 == 0 ) { palmeres--; if( palmeres < 0 ) palmeres = 319; }
if( contador%8 == 0 ) { camello++; if( camello == 4 ) camello = 0; }
if( contador%16 == 0 ) { horitzo--; if( horitzo < 0 ) horitzo = 319; }
contador++;
JI_Update();
}
}
info::pepe_activat = JI_KeyPressed(SDL_SCANCODE_P);
JI_DisableKeyboard(60);
JD8_FreeSurface( fondo );
JD8_FreeSurface( gfx );
free( pal );
}
void ModuleSequence::doSlides() {
JG_SetUpdateTicks(20);
const char* arxiu;
if( info::num_piramide == 7 ) {
play_music("00000005.ogg", 1);
if (info::diners < 200) {
arxiu = "intro2.gif";
} else {
arxiu = "intro3.gif";
}
} else {
arxiu = "intro.gif";
}
JD8_Surface gfx = JD8_LoadSurface( arxiu );
JD8_Palette pal_aux = JD8_LoadPalette( arxiu );
JD8_Palette pal = (JD8_Palette)malloc( 768 );
memcpy( pal, pal_aux, 768 );
JD8_ClearScreen( 255 );
JD8_SetScreenPalette( pal );
bool exit = false;
int step = 0;
contador = 1;
while( !exit && !JG_Quitting() ) {
if (JG_ShouldUpdate()) {
JI_Update();
if( JI_AnyKey() ) {
exit = true;
}
switch( step ) {
case 0:
JD8_Blit( 320 - ( contador * 4 ), 65, gfx, 0, 0, contador*4, 65 );
JD8_Flip();
contador++;
if( contador == 80 ) step++;
break;
case 3:
JD8_Blit( 0, 65, gfx, 320 - ( contador * 4 ), 65, contador*4, 65 );
JD8_Flip();
contador++;
if( contador == 80 ) step++;
break;
case 6:
JD8_Blit( 320 - ( contador * 4 ), 65, gfx, 0, 130, contador*4, 65 );
JD8_Flip();
contador++;
if( contador == 80 ) step++;
break;
case 1:
case 4:
case 7:
contador--;
if (contador == -150) { contador = 0; step++; }
break;
case 2:
case 5:
JD8_FadeOut();
memcpy( pal, pal_aux, 768 );
JD8_ClearScreen( 255 );
step++;
break;
case 8:
if (info::num_piramide != 7) JA_FadeOutMusic(250);
exit = true;
break;
}
}
}
JD8_FreeSurface( gfx );
free( pal_aux );
}
void ModuleSequence::doBanner() {
play_music("00000004.ogg");
this->contador = 5000;
JD8_Surface gfx = JD8_LoadSurface( "ffase.gif" );
JD8_Palette pal = JD8_LoadPalette( "ffase.gif" );
JD8_ClearScreen( 0 );
JD8_Blit( 81, 24, gfx, 81, 155, 168, 21 );
JD8_Blit( 39, 150, gfx, 39, 175, 248, 20 );
switch( info::num_piramide ) {
case 2:
JD8_Blit( 82, 60, gfx, 0, 0, 160, 75 );
break;
case 3:
JD8_Blit( 82, 60, gfx, 160, 0, 160, 75 );
break;
case 4:
JD8_Blit( 82, 60, gfx, 0, 75, 160, 75 );
break;
case 5:
JD8_Blit( 82, 60, gfx, 160, 75, 160, 75 );
break;
}
JD8_FadeToPal( pal );
bool exit = false;
while( !exit && !JG_Quitting() ) {
if (JG_ShouldUpdate()) {
JI_Update();
if( JI_AnyKey() ) {
exit = true;
}
contador--;
if( contador == 0 ) exit = true;
}
}
JA_FadeOutMusic(250);
}
void ModuleSequence::doSecreta() {
play_music("00000002.ogg");
JG_SetUpdateTicks(20);
JD8_FadeOut();
JD8_Surface gfx = JD8_LoadSurface("tomba1.gif");
JD8_Palette pal_aux = JD8_LoadPalette("tomba1.gif");
JD8_Palette pal = (JD8_Palette)malloc(768);
memcpy(pal, pal_aux, 768);
JD8_ClearScreen(255);
JD8_SetScreenPalette(pal);
bool exit = false;
int step = 0;
contador = 1;
while (!exit && !JG_Quitting()) {
if (JG_ShouldUpdate()) {
JI_Update();
if (JI_AnyKey()) {
exit = true;
}
switch (step) {
case 0:
JD8_Blit(70, 60, gfx, 0, contador, 178, 70); //Put_Sprite(from, where, 0 + (320 * i), 178, 70, 70, 60);
JD8_BlitCK(70, 60, gfx, 178, contador >> 1, 142, 70, 255); //Put_Sprite(from, where, 178 + (320 * (i div 2)), 142, 70, 70, 60);
JD8_Flip();
contador++;
if (contador == 128) step++;
break;
case 1:
case 4:
case 7:
case 9:
contador--;
if (contador == 0) step++;
break;
case 2:
JD8_ClearScreen(255);
JD8_Flip();
gfx = JD8_LoadSurface("tomba2.gif");
pal_aux = JD8_LoadPalette("tomba2.gif");
memcpy(pal, pal_aux, 768);
JD8_SetScreenPalette(pal);
step++;
break;
case 3:
JD8_Blit(55, 53, gfx, 0, 158-contador, 211, contador); //Put_Sprite(from, where, 0 + ((158 - i) * 320), 211, i, 55, 53);
JD8_Flip();
contador++;
if (contador == 94) step++;
break;
case 5:
JD8_ClearScreen(0);
JD8_Flip();
JD8_SetPaletteColor(254, 12, 11, 11);
JD8_SetPaletteColor(253, 12, 11, 11);
step++;
break;
case 6:
JD8_Blit(80, 68, gfx, 160 - (contador*2), 0, contador*2, 64); //Put_Sprite(from, where, 160 - (i * 2), (i * 2), 64, 80, 68);
JD8_Flip();
contador++;
if (contador == 80) step++;
break;
case 8:
JD8_SetPaletteColor(254, contador+12, 11, 11);
JD8_SetPaletteColor(253, (contador+12) >> 1, 11, 11);
JD8_Flip();
contador++;
if (contador == 51) step++;
break;
case 10:
JD8_FadeOut();
memcpy(pal, pal_aux, 768);
JD8_ClearScreen(255);
JA_FadeOutMusic(250);
exit = true;
break;
}
}
}
JD8_FreeSurface(gfx);
free(pal_aux);
}
void ModuleSequence::doCredits() {
struct { Uint16 x, y; } frames_coche[8] = { { 214, 152 }, { 214, 104 }, { 214, 56 }, { 214, 104 }, { 214, 152 }, { 214, 8 }, { 108, 152 }, { 214, 8 } };
const Uint32 n_frames_coche = 8;
const Uint32 velocitat_coche = 3;
JD8_Surface vaddr2 = JD8_LoadSurface("final.gif");
JD8_Surface vaddr3 = JD8_LoadSurface("finals.gif");
JD8_Palette pal = JD8_LoadPalette("final.gif");
JD8_SetScreenPalette(pal);
int contador = 0;
bool exit = false;
contador = 1;
while (!exit && !JG_Quitting()) {
if (JG_ShouldUpdate()) {
JI_Update();
if (JI_AnyKey() || contador >= 3100) {
exit = true;
}
JD8_ClearScreen(255);
if (contador < 2750) {
JD8_BlitCKCut(115, 200 - (contador / 6), vaddr2, 0, 0, 80, 200, 0);
}
if ((contador > 1200) && (contador < 2280)) {
JD8_BlitCKCut(100, 200 - ((contador-1200) / 6), vaddr2, 85, 0, 120, 140, 0);
} else if (contador >= 2250) {
JD8_BlitCK(100, 20, vaddr2, 85, 0, 120, 140, 0);
}
if (info::diamants == 16) {
//scroll_final_joc(vaddr3, vaddr, contador_final);
JD8_BlitCKScroll(50, vaddr3, ((contador >> 3) % 320) + 1, 0, 50, 255);
JD8_BlitCKScroll(50, vaddr3, ((contador >> 2) % 320) + 1, 50, 50, 255);
JD8_BlitCKScroll(50, vaddr3, ((contador >> 1) % 320) + 1, 100, 50, 255);
JD8_BlitCKScroll(50, vaddr3, (contador % 320) + 1, 150, 50, 255);
JD8_BlitCK(100, 50, vaddr2, frames_coche[(contador / velocitat_coche) % n_frames_coche].x, frames_coche[(contador / velocitat_coche) % n_frames_coche].y, 106, 48, 255);
} else {
JD8_BlitCK(0, 50, vaddr3, 0, 0, 320, 50, 255);
JD8_BlitCK(0, 50, vaddr3, 0, 50, 320, 50, 255);
}
JD8_FillSquare(0, 50, 255);
JD8_FillSquare(100, 10, 255);
JD8_Flip();
contador++;
}
}
FILE* ini = fopen("trick.ini", "wb");
fwrite("1", 1, 1, ini);
fclose(ini);
info::nou_personatge = true;
JD8_FreeSurface(vaddr3);
JD8_FreeSurface(vaddr2);
}
void ModuleSequence::doMort() {
play_music("00000001.ogg");
JI_DisableKeyboard(60);
info::vida = 5;
this->contador = 1000;
JD8_Surface gfx = JD8_LoadSurface( "gameover.gif" );
JD8_Palette pal = JD8_LoadPalette( "gameover.gif" );
JD8_ClearScreen( 0 );
JD8_Blit( gfx );
JD8_FadeToPal( pal );
bool exit = false;
while( !exit && !JG_Quitting() ) {
if (JG_ShouldUpdate()) {
JI_Update();
if( JI_AnyKey() ) {
exit = true;
}
contador--;
if( contador == 0 ) exit = true;
}
}
play_music("00000003.ogg");
}

25
source/modulesequence.h Normal file
View File

@@ -0,0 +1,25 @@
#pragma once
#include "info.h"
class ModuleSequence {
public:
ModuleSequence();
~ModuleSequence(void);
int Go();
private:
void doIntro();
void doMenu();
void doSlides();
void doBanner();
void doSecreta();
void doCredits();
void doMort();
int contador;
};

177
source/momia.cpp Normal file
View File

@@ -0,0 +1,177 @@
#include "momia.h"
#include "jgame.h"
#include <stdlib.h>
Momia::Momia( JD8_Surface gfx, bool dimoni, Uint16 x, Uint16 y, Prota* sam ) : Sprite( gfx ) {
this->dimoni = dimoni;
this->sam = sam;
this->entitat = (Entitat*)malloc( sizeof( Entitat ) );
// Frames
this->entitat->num_frames = 20;
this->entitat->frames = (Frame*)malloc( this->entitat->num_frames * sizeof( Frame ) );
Uint16 frame = 0;
for( int y = 0; y < 4; y++ ) {
for( int x = 0; x < 5; x++ ) {
this->entitat->frames[frame].w = 15;
this->entitat->frames[frame].h = 15;
if( info::num_piramide == 4 ) this->entitat->frames[frame].h -= 5;
this->entitat->frames[frame].x = (x*15)+75;
if( this->dimoni ) this->entitat->frames[frame].x += 75;
this->entitat->frames[frame].y = 20+(y*15);
frame++;
}
}
// Animacions
this->entitat->num_animacions = 4;
this->entitat->animacions = (Animacio*)malloc( this->entitat->num_animacions * sizeof( Animacio ) );
for( int i = 0; i < 4; i++ ) {
this->entitat->animacions[i].num_frames = 8;
this->entitat->animacions[i].frames = (Uint8*)malloc( 8 );
this->entitat->animacions[i].frames[0] = 0 + (i*5);
this->entitat->animacions[i].frames[1] = 1 + (i*5);
this->entitat->animacions[i].frames[2] = 2 + (i*5);
this->entitat->animacions[i].frames[3] = 1 + (i*5);
this->entitat->animacions[i].frames[4] = 0 + (i*5);
this->entitat->animacions[i].frames[5] = 3 + (i*5);
this->entitat->animacions[i].frames[6] = 4 + (i*5);
this->entitat->animacions[i].frames[7] = 3 + (i*5);
}
this->cur_frame = 0;
this->o = rand()%4;
this->cycles_per_frame = 4;
this->next = NULL;
if( this->dimoni ) {
if( x == 0 ) {
this->x = 150;
} else {
this->x = x;
}
if( y == 0 ) {
if( this->sam->y > 100 ) {
this->y = 30;
} else {
this->y = 170;
}
} else {
this->y = y;
}
this->engendro = new Engendro( gfx, this->x, this->y );
} else {
this->engendro = NULL;
this->x = x;
this->y = y;
}
}
void Momia::clear() {
if( this->next != NULL ) this->next->clear();
if( this->engendro != NULL) delete this->engendro;
delete this->next;
}
void Momia::draw() {
if( this->engendro != NULL ) {
this->engendro->draw();
} else {
Sprite::draw();
if( info::num_piramide == 4 ) {
if( ( JG_GetCycleCounter() % 40 ) < 20 ) {
JD8_BlitCK(this->x, this->y, this->gfx, 220, 80, 15, 15, 255 );
} else {
JD8_BlitCK(this->x, this->y, this->gfx, 235, 80, 15, 15, 255 );
}
}
}
if( this->next != NULL ) this->next->draw();
}
bool Momia::update() {
bool morta = false;
if( this->engendro != NULL ) {
if( this->engendro->update() ) {
delete this->engendro;
this->engendro = NULL;
}
} else {
if( this->sam->o < 4 && ( this->dimoni || info::num_piramide == 5 || JG_GetCycleCounter()%2 == 0 ) ) {
if( ( this->x - 20 ) % 65 == 0 && ( this->y - 30 ) % 35 == 0 ) {
if( this->dimoni ) {
if( rand()%2 == 0 ) {
if( this->x > this->sam->x ) { this->o = 3; }
else if( this->x < this->sam->x ) { this->o = 2; }
else if( this->y < this->sam->y ) { this->o = 0; }
else if( this->y > this->sam->y ) { this->o = 1; }
} else {
if( this->y < this->sam->y ) { this->o = 0; }
else if( this->y > this->sam->y ) { this->o = 1; }
else if( this->x > this->sam->x ) { this->o = 3; }
else if( this->x < this->sam->x ) { this->o = 2; }
}
} else {
this->o = rand()%4;
}
}
switch( this->o ) {
case 0:
if( y < 170 ) this->y++;
break;
case 1:
if( y > 30 ) this->y--;
break;
case 2:
if( x < 280 ) this->x++;
break;
case 3:
if( x > 20 ) this->x--;
break;
}
if( JG_GetCycleCounter() % this->cycles_per_frame == 0 ) {
this->cur_frame++;
if( this->cur_frame == this->entitat->animacions[this->o].num_frames ) this->cur_frame = 0;
}
if( this->x > ( this->sam->x - 7 ) && this->x < ( this->sam->x + 7 ) && this->y > ( this->sam->y - 7 ) && this->y < ( this->sam->y + 7 ) ) {
morta = true;
if( this->sam->pergami ) {
this->sam->pergami = false;
} else {
info::vida--;
if( info::vida == 0 ) this->sam->o = 5;
}
}
}
}
if( this->next != NULL ) {
if( this->next->update() ) {
Momia* seguent = this->next->next;
delete this->next;
this->next = seguent;
info::momies--;
}
}
return morta;
}
void Momia::insertar( Momia* momia ) {
if( this->next != NULL ) {
this->next->insertar( momia );
} else {
this->next = momia;
}
}

27
source/momia.h Normal file
View File

@@ -0,0 +1,27 @@
#pragma once
#include "sprite.h"
#include "prota.h"
#include "engendro.h"
#include "info.h"
class Momia : public Sprite {
public:
Momia( JD8_Surface gfx, bool dimoni, Uint16 x, Uint16 y, Prota* sam );
void clear();
void draw();
bool update();
void insertar( Momia* momia );
bool dimoni;
Momia* next;
protected:
Prota* sam;
Engendro* engendro;
};

150
source/prota.cpp Normal file
View File

@@ -0,0 +1,150 @@
#include "prota.h"
#include "jgame.h"
#include "jinput.h"
#include <stdlib.h>
Prota::Prota( JD8_Surface gfx ) : Sprite( gfx ) {
this->entitat = (Entitat*)malloc( sizeof( Entitat ) );
this->entitat->num_frames = 82;
this->entitat->frames = (Frame*)malloc( this->entitat->num_frames * sizeof( Frame ) );
Uint16 frame = 0;
for( int y = 0; y < 4; y++ ) {
for( int x = 0; x < 5; x++ ) {
this->entitat->frames[frame].w = 15;
this->entitat->frames[frame].h = 15;
if( info::num_piramide == 4 ) this->entitat->frames[frame].h -= 5;
this->entitat->frames[frame].x = x*15;
this->entitat->frames[frame].y = 20+(y*15);
frame++;
}
}
for( int y = 95; y < 185; y+=30 ) {
for( int x = 60; x < 315; x+=15 ) {
if( x != 300 || y != 155 ) {
this->entitat->frames[frame].w = 15;
this->entitat->frames[frame].h = 30;
if( info::num_piramide == 4 ) this->entitat->frames[frame].h -= 5;
this->entitat->frames[frame].x = x;
this->entitat->frames[frame].y = y;
frame++;
}
}
}
for( int y = 20; y < 50; y+=15 ) {
for( int x = 225; x < 315; x+=15 ) {
this->entitat->frames[frame].w = 15;
this->entitat->frames[frame].h = 15;
if( info::num_piramide == 4 ) this->entitat->frames[frame].h -= 5;
this->entitat->frames[frame].x = x;
this->entitat->frames[frame].y = y;
frame++;
}
}
this->entitat->num_animacions = 6;
this->entitat->animacions = (Animacio*)malloc( this->entitat->num_animacions * sizeof( Animacio ) );
for( int i = 0; i < 4; i++ ) {
this->entitat->animacions[i].num_frames = 8;
this->entitat->animacions[i].frames = (Uint8*)malloc( 8 );
this->entitat->animacions[i].frames[0] = 0 + (i*5);
this->entitat->animacions[i].frames[1] = 1 + (i*5);
this->entitat->animacions[i].frames[2] = 2 + (i*5);
this->entitat->animacions[i].frames[3] = 1 + (i*5);
this->entitat->animacions[i].frames[4] = 0 + (i*5);
this->entitat->animacions[i].frames[5] = 3 + (i*5);
this->entitat->animacions[i].frames[6] = 4 + (i*5);
this->entitat->animacions[i].frames[7] = 3 + (i*5);
}
this->entitat->animacions[4].num_frames = 50;
this->entitat->animacions[4].frames = (Uint8*)malloc( 50 );
for( int i = 0; i < 50; i++ ) this->entitat->animacions[4].frames[i] = i + 20;
this->entitat->animacions[5].num_frames = 48;
this->entitat->animacions[5].frames = (Uint8*)malloc( 48 );
for( int i = 0; i < 12; i++ ) this->entitat->animacions[5].frames[i] = i + 70;
for (int i = 12; i < 48; i++) this->entitat->animacions[5].frames[i] = 81;
this->cur_frame = 0;
this->x = 150;
this->y = 30;
this->o = 0;
this->cycles_per_frame = 4;
this->pergami = false;
this->frame_pejades = 0;
}
void Prota::draw() {
Sprite::draw();
if( info::num_piramide == 4 && this->o != 4) {
if( ( JG_GetCycleCounter() % 40 ) < 20 ) {
JD8_BlitCK(this->x, this->y, this->gfx, 220, 80, 15, 15, 255 );
} else {
JD8_BlitCK(this->x, this->y, this->gfx, 235, 80, 15, 15, 255 );
}
}
}
Uint8 Prota::update() {
Uint8 eixir = 0;
if( this->o < 4 ) {
Uint8 dir = 4;
if ( JI_KeyPressed(SDL_SCANCODE_DOWN) ) {
if( (this->x-20)%65 == 0 ) this->o = 0;
dir = this->o;
}
if ( JI_KeyPressed(SDL_SCANCODE_UP) ) {
if( (this->x-20)%65 == 0 ) this->o = 1;
dir = this->o;
}
if( JI_KeyPressed( SDL_SCANCODE_RIGHT ) ) {
if( (this->y-30)%35 == 0 ) this->o = 2;
dir = this->o;
}
if( JI_KeyPressed( SDL_SCANCODE_LEFT ) ) {
if( (this->y-30)%35 == 0 ) this->o = 3;
dir = this->o;
}
switch( dir ) {
case 0:
if( this->y < 170 ) this->y++;
break;
case 1:
if( this->y > 30 ) this->y--;
break;
case 2:
if( this->x < 280 ) this->x++;
break;
case 3:
if( this->x > 20 ) this->x--;
break;
}
if( dir == 4 ) {
this->cur_frame = 0;
} else {
this->frame_pejades++;
if( this->frame_pejades == 15 ) this->frame_pejades = 0;
if( JG_GetCycleCounter() % this->cycles_per_frame == 0 ) {
this->cur_frame++;
if( this->cur_frame == this->entitat->animacions[this->o].num_frames ) this->cur_frame = 0;
}
}
eixir = false;
} else {
if( JG_GetCycleCounter() % this->cycles_per_frame == 0 ) {
this->cur_frame++;
if( this->cur_frame == this->entitat->animacions[this->o].num_frames ) {
if( this->o == 4 ) { eixir = 1; } else { eixir = 2; }
}
}
}
return eixir;
}

21
source/prota.h Normal file
View File

@@ -0,0 +1,21 @@
#pragma once
#include "sprite.h"
#include "info.h"
class Prota : public Sprite {
public:
Prota( JD8_Surface gfx );
void draw();
Uint8 update();
Uint8 frame_pejades;
bool pergami;
protected:
};

38
source/sprite.cpp Normal file
View File

@@ -0,0 +1,38 @@
#include "sprite.h"
#include <stdlib.h>
Sprite::Sprite( JD8_Surface gfx ) {
this->gfx = gfx;
this->entitat = NULL;
}
Sprite::~Sprite(void) {
if( this->entitat != NULL ) {
if( this->entitat->num_frames > 0 ) free( this->entitat->frames );
if( this->entitat->num_animacions > 0 ) {
for( int i = 0; i < this->entitat->num_animacions; i++ ) {
if( this->entitat->animacions[i].num_frames > 0 ) free( this->entitat->animacions[i].frames );
}
}
free( this->entitat );
}
}
void Sprite::draw() {
JD8_BlitCK( this->x, this->y, this->gfx, this->entitat->frames[this->entitat->animacions[this->o].frames[this->cur_frame]].x,
this->entitat->frames[this->entitat->animacions[this->o].frames[this->cur_frame]].y,
this->entitat->frames[this->entitat->animacions[this->o].frames[this->cur_frame]].w,
this->entitat->frames[this->entitat->animacions[this->o].frames[this->cur_frame]].h,
255);
}

44
source/sprite.h Normal file
View File

@@ -0,0 +1,44 @@
#pragma once
#include "jdraw8.h"
struct Frame {
Uint16 x;
Uint16 y;
Uint16 w;
Uint16 h;
};
struct Animacio {
Uint8 num_frames;
Uint8* frames;
};
struct Entitat {
Uint8 num_frames;
Frame* frames;
Uint8 num_animacions;
Animacio* animacions;
};
class Sprite {
public:
Sprite( JD8_Surface gfx );
~Sprite(void);
void draw();
Entitat* entitat;
Uint8 cur_frame;
Uint16 x;
Uint16 y;
Uint16 o;
protected:
JD8_Surface gfx;
Uint8 cycles_per_frame;
};

5584
source/stb_vorbis.h Normal file
View File

File diff suppressed because it is too large Load Diff