JailDoctor/aee
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Primer commit

Browse Source
This commit is contained in:
Raimon Zamora
2014-12-30 22:46:46 +01:00
commit 4a359c46f5
33 changed files with 2778 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.hgignore Normal file
View File

@@ -0,0 +1,3 @@
syntax: glob
recursos/*

68
bola.cpp Executable file
View File

@@ -0,0 +1,68 @@
#include "bola.h"
#include "jgame.h"
Bola::Bola( JD8_Surface gfx, Info* info, Prota* sam ) : Sprite( gfx ) {
this->info = info;
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;
this->info->vida--;
if( this->info->vida == 0 ) this->sam->o = 5;
}
} else {
this->contador--;
if( this->contador == 0 ) this->x = 20;
}
}

23
bola.h Executable file
View File

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

BIN
data.jrf Executable file
View File

Binary file not shown.

63
engendro.cpp Executable file
View File

@@ -0,0 +1,63 @@
#include "engendro.h"
#include "jgame.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
engendro.h Executable 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;
};

11
info.h Executable file
View File

@@ -0,0 +1,11 @@
#pragma once
struct Info {
int num_piramide;
int num_habitacio;
int diners;
int diamants;
int vida;
int momies;
int engendros;
};

238
jdraw8.cpp Executable file
View File

@@ -0,0 +1,238 @@
#include "jdraw8.h"
#include "SDL2/SDL_image.h"
#include "SDL2/SDL_opengl.h"
#include "jfile.h"
#include <fstream>
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_GLContext gContext;
SDL_Window* window = NULL;
SDL_Surface* screenSurface = NULL;
void JD8_Init(char *title) {
screen = (JD8_Surface)calloc( 1, 64000 );
main_palette = (JD8_Palette)calloc( 1, 768 );
pixel_data = (Uint32*)calloc( 1, 1048576 );
//SDL_SetVideoMode( 640, 480, 32, SDL_OPENGL );
window = SDL_CreateWindow( title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN );
gContext = SDL_GL_CreateContext( window );
//if( SDL_GL_SetSwapInterval( 1 ) < 0 ) { printf( "Warning: Unable to set VSync! SDL Error: %s\n", SDL_GetError() ); }
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 2 );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 1 );
glClearColor( 0, 0, 0, 0 );
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0, 320, 200, 0, -1, 1 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glEnable(GL_TEXTURE_2D);
GLuint textureName;
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &textureName);
glBindTexture(GL_TEXTURE_2D, textureName);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixel_data);
}
void JD8_Quit() {
if( screen != NULL ) free( screen );
if( main_palette != NULL ) free( main_palette );
if( pixel_data != NULL ) free( pixel_data );
SDL_DestroyWindow( window );
}
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(char *file) {
int filesize = 0;
char *buffer = JF_GetBufferFromResource(file, filesize);
SDL_RWops *rw = SDL_RWFromMem(buffer, filesize);
SDL_Surface *temp = IMG_Load_RW(rw, 1);
free(buffer);
if (temp == NULL) {
printf("Unable to load bitmap: %s\n", SDL_GetError());
exit(1);
}
JD8_Surface image = JD8_NewSurface();
memcpy( image, temp->pixels, 64000 );
SDL_FreeSurface(temp);
return image;
}
JD8_Palette JD8_LoadPalette(char *file) {
int filesize = 0;
char *buffer = NULL;
buffer = JF_GetBufferFromResource(file, filesize);
SDL_RWops *rw = NULL;
rw = SDL_RWFromMem(buffer, filesize);
if( rw == NULL ) { printf("ERROR: No s'ha pogut crear el RWops"); exit(1); }
SDL_Surface *temp = NULL;
temp = IMG_Load_RW(rw, 1);
if( temp == NULL ) { printf("ERROR! No s'ha pogut crear la SDL_Surface: %s", SDL_GetError()); exit(1); }
free(buffer);
JD8_Palette palette = (JD8_Palette)malloc( 768 );
for( int i = 0; i < 256; i++ ) {
palette[i].r = temp->format->palette->colors[i].r;
palette[i].g = temp->format->palette->colors[i].g;
palette[i].b = temp->format->palette->colors[i].b;
}
SDL_FreeSurface(temp);
return palette;
}
void JD8_SetScreenPalette(JD8_Palette palette) {
if( main_palette != NULL) free( main_palette );
main_palette = palette;
}
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_BlitCKToSurface(int x, int y, JD8_Surface surface, int sx, int sy, int sw, int sh, JD8_Surface dest, Uint8 colorkey ) {
int src_pointer = sx + (sy*320);
int dst_pointer = x + (y*320);
for( int j = 0; j < sh; j++ ) {
for( int i = 0; i < sw; i++ ) {
if( surface[src_pointer+i] != colorkey ) dest[dst_pointer+i] = surface[src_pointer+i];
}
src_pointer += 320;
dst_pointer += 320;
}
}
void JD8_Flip() {
for( int x = 0; x < 320; x++ ) {
for( int y = 0; y < 200; y++ ) {
Uint32 color = 0xFF000000 + main_palette[screen[x + ( y * 320 )]].r + ( main_palette[screen[x + ( y * 320 )]].g << 8 ) + ( main_palette[screen[x + ( y * 320 )]].b << 16 );
pixel_data[y + ( x * 512 )] = color;
}
}
glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 512, 512, GL_RGBA, GL_UNSIGNED_BYTE, pixel_data);
glBegin( GL_QUADS );
glTexCoord2f( 0.0, 0.0 );
glVertex3f( 0.0, 0.0, 0.0 );
glTexCoord2f( 0.0, 1.0 );
glVertex3f( 512.0, 0.0, 0.0 );
glTexCoord2f( 1.0, 1.0 );
glVertex3f( 512.0, 512.0, 0.0 );
glTexCoord2f( 1.0, 0.0 );
glVertex3f( 0.0, 512.0, 0.0 );
glEnd();
SDL_GL_SwapWindow(window);
}
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_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();
}
}

53
jdraw8.h Executable file
View File

@@ -0,0 +1,53 @@
#pragma once
#include "SDL2/SDL.h"
struct Color {
Uint8 r;
Uint8 g;
Uint8 b;
};
typedef Uint8* JD8_Surface;
typedef Color* JD8_Palette;
void JD8_Init(char *title);
void JD8_Quit();
void JD8_ClearScreen(Uint8 color);
JD8_Surface JD8_NewSurface();
JD8_Surface JD8_LoadSurface(char *file);
JD8_Palette JD8_LoadPalette(char *file);
void JD8_SetScreenPalette(JD8_Palette palette);
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_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_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();

162
jfile.cpp Executable file
View File

@@ -0,0 +1,162 @@
#include "jfile.h"
#include "SDL2/SDL.h"
#include <fstream>
#pragma pack(push,1)
struct DATA_Header {
char magic[4];
Uint32 num_files;
Uint32 index_offset;
};
struct DATA_Info {
Uint32 offset;
Uint32 length;
char name[13];
};
struct DATA_Index {
DATA_Info* file_info;
};
struct DATA_File {
DATA_Header header;
DATA_Index index;
};
#pragma pack(pop)
const char *resourceFileName = "data.jrf";
DATA_File *data_file = NULL;
void JF_SetResourceFile(char *p_resourceFileName) {
resourceFileName = p_resourceFileName;
}
void JF_GetDataFile() {
std::ifstream fd( resourceFileName, std::ios::in | std::ios::binary );
if( fd.fail() ) {
perror("No s'ha pogut obrir l'arxiu de recursos");
exit(1);
}
data_file = (DATA_File*)malloc( sizeof( DATA_File ) );
fd.read( (char*)&data_file->header, sizeof( DATA_Header ) );
fd.seekg( data_file->header.index_offset );
data_file->index.file_info = (DATA_Info*)malloc( data_file->header.num_files * sizeof( DATA_Info ) );
fd.read( (char*)data_file->index.file_info, data_file->header.num_files * sizeof( DATA_Info ) );
fd.close();
}
char *JF_GetBufferFromResource(char *resourcename, int& filesize) {
if( data_file == NULL ) {
JF_GetDataFile();
}
bool found = false;
int count = 0;
while( !found && count < data_file->header.num_files ) {
found = ( strcmp( resourcename, data_file->index.file_info[count].name ) == 0 );
if( !found ) count++;
}
if( !found ) {
perror("El recurs no s'ha trobat en l'arxiu de recursos");
exit(1);
}
filesize = data_file->index.file_info[count].length;
std::ifstream fd( resourceFileName, std::ios::in | std::ios::binary );
if( fd.fail() ) {
perror("No s'ha pogut obrir l'arxiu de recursos");
exit(1);
}
fd.seekg( data_file->index.file_info[count].offset );
char* buffer = (char*)malloc( filesize );
fd.read( buffer, filesize );
fd.close();
return buffer;
}
// //Read the first INT, which will tell us how many files are in this resource
// int numfiles;
// int resultat = read(fd, &numfiles, sizeof(int));
//
//#ifdef _WIN32
// int final = eof(fd);
//#endif
//
// //Get the pointers to the stored files
// int *filestart = (int *) malloc(sizeof(int) * numfiles);
// resultat = read(fd, filestart, sizeof(int) * numfiles);
//
// //Loop through the files, looking for the file in question
// int filenamesize;
// char *buffer;
// int i;
// for(i=0;i<numfiles;i++)
// {
// int result = 129;
// char *filename;
// //Seek to the location
// lseek(fd, filestart[i], SEEK_SET);
// //Get the filesize value
// read(fd, filesize, sizeof(int));
// //Get the size of the filename string
// read(fd, &filenamesize, sizeof(int));
// //Size the buffer and read the filename
// filename = (char *) malloc(filenamesize + 1);
// result = read(fd, filename, filenamesize);
// //Remember to terminate the string properly!
// filename[filenamesize] = '\0';
// //Compare to the string we're looking for
// if (strcmp(filename, resourcename) == 0)
// {
// //Get the contents of the file
// buffer = (char *) malloc(*filesize);
// read(fd, buffer, *filesize);
// free(filename);
// break;
// }
// //Free the filename buffer
// free(filename);
// }
//
// //Release memory
// free(filestart);
//
// //Close the resource file!
// close(fd);
//
// //Did we find the file within the resource that we were looking for?
// if (buffer == NULL)
// {
// printf("Unable to find '%s' in the resource file!\n", resourcename);
// exit(1);
// }
//
// //Return the buffer
// return buffer;
//}
void JF_Quit() {
if( data_file != NULL ) {
free( data_file->index.file_info );
free( data_file );
}
}

7
jfile.h Executable file
View File

@@ -0,0 +1,7 @@
#pragma once
void JF_SetResourceFile(char *p_resourceFileName);
char *JF_GetBufferFromResource(char *resourcename, int& filesize);
void JF_Quit();

43
jgame.cpp Executable file
View File

@@ -0,0 +1,43 @@
#include "jgame.h"
bool eixir = false;
int updateTicks = 0;
Uint32 updateTime = 0;
Uint32 cycle_counter = 0;
void JG_Init() {
SDL_Init( SDL_INIT_EVERYTHING );
//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;
}

27
jgame.h Executable file
View File

@@ -0,0 +1,27 @@
#pragma once
#include "SDL2/SDL.h"
#ifndef NDEBUG
#ifndef DPRINT(text, ...)
#define DPRINT(text, ...) dprintf(__FILE__, __LINE__, text, __VA_ARGS__)
void dprintf(const char* szFile, long lLine, const char* fmt, ...);
#endif
#else // #ifdef NDEBUG
#ifndef DPRINT(text, ...)
#define DPRINT(text, ...) ((void)0)
#endif
#endif
void JG_Init();
void JG_Finalize();
void JG_QuitSignal();
bool JG_Quitting();
void JG_SetUpdateTicks(Uint32 milliseconds);
bool JG_ShouldUpdate();
Uint32 JG_GetCycleCounter();

44
jinput.cpp Executable file
View File

@@ -0,0 +1,44 @@
#include "jinput.h"
#include "jgame.h"
const Uint8 *keystates;// = SDL_GetKeyboardState( NULL );
SDL_Event event;
Uint8 cheat[5];
bool key_pressed = false;
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 );
while ( SDL_PollEvent( &event ) ) {
if ( event.type == SDL_QUIT ) JG_QuitSignal();
if( event.type == SDL_KEYUP ) {
key_pressed = true;
JI_moveCheats( event.key.keysym.sym );
}
}
}
bool JI_KeyPressed(int key) {
return (keystates[key] != 0);
}
bool JI_CheatActivated( const char* cheat_code ) {
bool found = true;
for( int i = 0; i < strlen( cheat_code ); i++ ) {
if( cheat[i] != cheat_code[i] ) found = false;
}
return found;
}
bool JI_AnyKey() {
return key_pressed;
}

10
jinput.h Executable file
View File

@@ -0,0 +1,10 @@
#pragma once
#include "SDL2/SDL.h"
void JI_Update();
bool JI_KeyPressed(int key);
bool JI_CheatActivated( const char* cheat_code );
bool JI_AnyKey();

72
jsound.cpp Executable file
View File

@@ -0,0 +1,72 @@
#include "jsound.h"
#include "jfile.h"
Mix_Music *music = NULL;
bool JS_Init() {
Mix_OpenAudio(MIX_DEFAULT_FREQUENCY, MIX_DEFAULT_FORMAT, 2, 1024);
Mix_AllocateChannels(8);
return true;
}
void JS_LoadMusic(char *musicFilename)
{
if (music != NULL) {
Mix_HaltMusic();
Mix_FreeMusic(music);
}
Mix_VolumeMusic(MIX_MAX_VOLUME);
int filesize = 0;
char *buffer = JF_GetBufferFromResource(musicFilename, filesize);
SDL_RWops *rw = SDL_RWFromMem(buffer, filesize);
music = Mix_LoadMUS_RW(rw, 1);
}
void JS_SetMusicVolume(int volume) {
Mix_VolumeMusic(volume);
}
void JS_PlayMusic(int loops) {
Mix_PlayMusic(music, loops);
}
void JS_PauseMusic() {
Mix_PauseMusic();
}
void JS_FadeOutMusic() {
Mix_FadeOutMusic(500);
}
bool JS_MusicPlaying() {
return (Mix_PlayingMusic() == 1);// && (Mix_FadingMusic() != MIX_FADING_OUT);
}
JS_Sound *JS_LoadSound(char *soundFilename) {
int filesize = 0;
char *buffer = JF_GetBufferFromResource(soundFilename, filesize);
SDL_RWops *rw = SDL_RWFromMem(buffer, filesize);
return Mix_LoadWAV_RW(rw, false);
}
void JS_SetSoundVolume(JS_Sound *sound, int volume) {
Mix_VolumeChunk(sound, volume);
}
void JS_PlaySound(JS_Sound *sound) {
Mix_PlayChannel(-1, sound, 0);
}
void JS_FreeSound(JS_Sound *sound) {
Mix_FreeChunk(sound);
}
void JS_Finalize() {
Mix_FreeMusic(music);
Mix_CloseAudio();
}

28
jsound.h Executable file
View File

@@ -0,0 +1,28 @@
#pragma once
#include "SDL2/SDL_mixer.h"
typedef Mix_Chunk JS_Sound;
bool JS_Init();
void JS_LoadMusic(char *musicFilename);
void JS_SetMusicVolume(int volume);
void JS_PlayMusic(int loops);
void JS_PauseMusic();
void JS_FadeOutMusic();
bool JS_MusicPlaying();
JS_Sound *JS_LoadSound(char *soundFilename);
void JS_SetSoundVolume(JS_Sound *sound, int volume);
void JS_PlaySound(JS_Sound *sound);
void JS_FreeSound(JS_Sound *sound);
void JS_Finalize();

56
main.cpp Executable file
View File

@@ -0,0 +1,56 @@
#include "jgame.h"
#include "jdraw8.h"
#include "jfile.h"
#include "info.h"
#include "modulegame.h"
#include "modulesequence.h"
#include "time.h"
#include <libgen.h>
int main( int argc, char* args[] ) {
char res_file[255] = "";
strcpy(res_file, dirname(args[0]));
strcat(res_file, "/data.jrf");
printf("ARXIU DE RECURSOS: %s\n", res_file);
JF_SetResourceFile(res_file);
srand( time(NULL) );
JG_Init();
JD8_Init("Aventures En Egipte");
Info info;
info.num_habitacio = 1;
info.num_piramide = 255;
info.diners = 0;
info.diamants = 0;
info.vida = 5;
info.momies = 0;
int gameState = 1;
while (gameState != -1) {
switch (gameState) {
case 0:
ModuleGame* moduleGame;
moduleGame = new ModuleGame( &info );
gameState = moduleGame->Go();
delete moduleGame;
break;
case 1:
ModuleSequence* moduleSequence;
moduleSequence = new ModuleSequence( &info );
gameState = moduleSequence->Go();
delete moduleSequence;
break;
}
}
JF_Quit();
JD8_Quit();
JG_Finalize();
return 0;
}

7
makefile Executable file
View File

@@ -0,0 +1,7 @@
TARGET=aee
all:
g++ *.cpp -w -lSDL2 -lGL -lSDL2_image -lSDL2_mixer -o $(TARGET)
clean:
rm -rf ./$(TARGET)

272
mapa.cpp Executable file
View File

@@ -0,0 +1,272 @@
#include "mapa.h"
#include "jgame.h"
#include "jinput.h"
Mapa::Mapa( JD8_Surface gfx, Info* info, Prota* sam ) {
this->gfx = gfx;
this->info = info;
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( this->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 );
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();
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"
// 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;
}
}
}
// Pinta tombes
for( int y = 0; y < 4; y++ ) {
for( int x = 0; x < 4; x++ ) {
JD8_BlitCKToSurface( 35+(x*65), 45+(y*35), this->gfx, 0, 0, 50, 20, this->fondo, 255 );
}
}
// 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() {
for( int i = 0; i < 16; i++ ) {
this->tombes[i].contingut = CONTE_RES;
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[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 ) {
if( !this->tombes[num].oberta ) {
this->tombes[num].oberta = true;
for( int i = 0; i < 4; i++ ) if( !this->tombes[num].costat[i] ) this->tombes[num].oberta = false;
if( this->tombes[num].oberta ) {
int x = num % 4;
int y = num / 4;
switch( this->tombes[num].contingut ) {
case CONTE_RES:
JD8_BlitCKToSurface( 35+(x*65), 45+(y*35), this->gfx, 50, 0, 50, 20, this->fondo, 255 );
break;
case CONTE_TRESOR:
JD8_BlitCKToSurface( 35+(x*65), 45+(y*35), this->gfx, 100, 0, 50, 20, this->fondo, 255 );
info->diners++;
break;
case CONTE_FARAO:
JD8_BlitCKToSurface( 35+(x*65), 45+(y*35), this->gfx, 150, 0, 50, 20, this->fondo, 255 );
this->farao = true;
break;
case CONTE_CLAU:
JD8_BlitCKToSurface( 35+(x*65), 45+(y*35), this->gfx, 200, 0, 50, 20, this->fondo, 255 );
this->clau = true;
break;
case CONTE_MOMIA:
JD8_BlitCKToSurface( 35+(x*65), 45+(y*35), this->gfx, 0, 175, 50, 20, this->fondo, 255 );
this->nova_momia = true;
break;
case CONTE_PERGAMI:
JD8_BlitCKToSurface( 35+(x*65), 45+(y*35), this->gfx, 250, 0, 50, 20, this->fondo, 255 );
this->sam->pergami = true;
break;
case CONTE_DIAMANT:
JD8_BlitCKToSurface( 35+(x*65), 45+(y*35), this->gfx, 150, 0, 50, 20, this->fondo, 255 );
info->diamants++;
info->diners += VALOR_DIAMANT;
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
mapa.h Executable 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;
};
struct Vertex {
Uint8 columna;
Uint8 fila;
};
class Mapa {
public:
Mapa( JD8_Surface gfx, Info* info, 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;
Info* info;
Uint8 frame_torxes;
Prota* sam;
bool farao;
bool clau;
bool porta_oberta;
bool nova_momia;
};

62
marcador.cpp Executable file
View File

@@ -0,0 +1,62 @@
#include "marcador.h"
Marcador::Marcador( JD8_Surface gfx, Info* info, Prota* sam ) {
this->gfx = gfx;
this->info = info;
this->sam = sam;
}
Marcador::~Marcador(void) {
}
void Marcador::draw() {
this->pintaNumero( 55, 2, this->info->num_piramide );
this->pintaNumero( 80, 2, this->info->num_habitacio );
this->pintaNumero( 149, 2, this->info->diners / 100 );
this->pintaNumero( 156, 2, ( this->info->diners % 100 ) / 10 );
this->pintaNumero( 163, 2, this->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, this->info->vida*3, 255 );
if( this->info->vida < 5 ) JD8_BlitCK( 271, 1+(this->info->vida*3), this->gfx, 75, 20, 15, 15-(this->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;
}
}

24
marcador.h Executable file
View File

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

152
modulegame.cpp Executable file
View File

@@ -0,0 +1,152 @@
#include "modulegame.h"
#include "jgame.h"
#include "jdraw8.h"
#include "jinput.h"
#include "jfile.h"
ModuleGame::ModuleGame( Info* info ) {
this->info = info;
this->gfx = JD8_LoadSurface( "frames.gif" );
JG_SetUpdateTicks(10);
this->sam = new Prota( this->gfx, this->info );
this->mapa = new Mapa( this->gfx, this->info, this->sam );
this->marcador = new Marcador( this->gfx, this->info, this->sam );
if( this->info->num_piramide == 2 ) {
this->bola = new Bola( this->gfx, this->info, 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();
JD8_FadeToPal( JD8_LoadPalette( "frames.gif" ) );
while (this->final == 0 && !JG_Quitting()) {
this->Draw();
this->Update();
}
if( this->final == 1 ) {
this->info->num_habitacio++;
if( this->info->num_habitacio == 6 ) {
this->info->num_habitacio = 1;
this->info->num_piramide++;
}
}
if( JG_Quitting() ) {
return -1;
} else {
if( this->info->num_habitacio == 1 ) {
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;
this->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, this->info, true, 0, 0, this->sam ) );
this->info->momies++;
} else {
this->momies = new Momia( this->gfx, this->info, true, 0, 0, this->sam );
this->info->momies++;
}
}
if( JI_CheatActivated( "reviu" ) ) this->info->vida = 5;
if( JI_CheatActivated( "alone" ) ) {
if( this->momies != NULL ) {
this->momies->clear();
delete this->momies;
this->momies = NULL;
this->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( this->info->num_habitacio == 10 ) { this->info->momies = 1; } else { this->info->momies++; }
int x = 20;
int y = 170;
for( int i = 0; i < info->momies; i++ ) {
if( this->momies == NULL) {
this->momies = new Momia( this->gfx, this->info, false, x, y, this->sam );
} else {
this->momies->insertar( new Momia( this->gfx, this->info, false, x, y, this->sam ) );
}
x += 65;
if( x == 345 ) { x = 20; y -= 35; }
}
}

36
modulegame.h Executable file
View File

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

739
modulesequence.cpp Executable file
View File

@@ -0,0 +1,739 @@
#include "modulesequence.h"
#include "jgame.h"
#include "jdraw8.h"
#include "jinput.h"
ModuleSequence::ModuleSequence( Info* info ) {
this->info = info;
}
ModuleSequence::~ModuleSequence(void) {
}
int ModuleSequence::Go() {
if( this->info->num_piramide == 6 && this->info->diners < 200 ) this->info->num_piramide = 7;
switch( this->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;
}
JD8_FadeOut();
if( JG_Quitting() ) {
return -1;
} else {
if( this->info->num_piramide == 255 ) {
this->info->num_piramide = 0;
return 1;
} else if( this->info->num_piramide == 0 ) {
this->info->num_piramide = 1;
return 1;
} else if( this->info->num_piramide == 7 ) {
this->info->num_piramide = 8;
return 1;
} else if( this->info->num_piramide == 8 ) {
this->info->num_piramide = 255;
} else {
return 0;
}
}
}
const int minim( const int a, const int b ) {
if( b < a ) { return b; } else { return a; }
}
void ModuleSequence::doIntro() {
JG_SetUpdateTicks(1000);
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() ) {
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...
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();
}
}
JD8_FreeSurface( fondo );
JD8_FreeSurface( gfx );
free( pal );
}
void ModuleSequence::doSlides() {
JG_SetUpdateTicks(20);
char* arxiu;
if( this->info->num_piramide == 7 ) {
if( this->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 == 1 ) step++;
break;
case 2:
case 5:
JD8_FadeOut();
memcpy( pal, pal_aux, 768 );
JD8_ClearScreen( 255 );
step++;
break;
case 8:
exit = true;
break;
}
}
}
JD8_FreeSurface( gfx );
free( pal_aux );
}
void ModuleSequence::doBanner() {
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( this->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;
}
}
}
void ModuleSequence::doSecreta() {
}
void ModuleSequence::doCredits() {
}

25
modulesequence.h Executable file
View File

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

177
momia.cpp Executable file
View File

@@ -0,0 +1,177 @@
#include "momia.h"
#include "jgame.h"
Momia::Momia( JD8_Surface gfx, Info* info, bool dimoni, Uint16 x, Uint16 y, Prota* sam ) : Sprite( gfx ) {
this->info = info;
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( this->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( this->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 || this->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 {
this->info->vida--;
if( this->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;
this->info->momies--;
}
}
return morta;
}
void Momia::insertar( Momia* momia ) {
if( this->next != NULL ) {
this->next->insertar( momia );
} else {
this->next = momia;
}
}

28
momia.h Executable file
View File

@@ -0,0 +1,28 @@
#pragma once
#include "sprite.h"
#include "prota.h"
#include "engendro.h"
#include "info.h"
class Momia : public Sprite {
public:
Momia( JD8_Surface gfx, Info* info, 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;
Info* info;
Engendro* engendro;
};

163
prota.cpp Executable file
View File

@@ -0,0 +1,163 @@
#include "prota.h"
#include "jgame.h"
#include "jinput.h"
Prota::Prota( JD8_Surface gfx, Info* info ) : Sprite( gfx ) {
this->info = info;
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( this->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( this->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( this->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 = 12;
this->entitat->animacions[5].frames = (Uint8*)malloc( 12 );
for( int i = 0; i < 12; i++ ) this->entitat->animacions[5].frames[i] = i + 70;
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( this->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 = 0;
if ( JI_KeyPressed(SDL_SCANCODE_DOWN) ) {
if( (this->x-20)%65 == 0 ) {
this->o = 0;
dir = 1;
} else {
dir = this->o + 1;
}
}
if ( JI_KeyPressed(SDL_SCANCODE_UP) ) {
if( (this->x-20)%65 == 0 ) {
this->o = 1;
dir = 2;
} else {
dir = this->o + 1;
}
}
if( JI_KeyPressed( SDL_SCANCODE_RIGHT ) ) {
if( (this->y-30)%35 == 0 ) {
this->o = 2;
dir = 3;
} else {
dir = this->o + 1;
}
}
if( JI_KeyPressed( SDL_SCANCODE_LEFT ) ) {
if( (this->y-30)%35 == 0 ) {
this->o = 3;
dir = 4;
} else {
dir = this->o + 1;
}
}
switch( dir ) {
case 1:
if( this->y < 170 ) this->y++;
break;
case 2:
if( this->y > 30 ) this->y--;
break;
case 3:
if( this->x < 280 ) this->x++;
break;
case 4:
if( this->x > 20 ) this->x--;
break;
}
if( dir == 0 ) {
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;
}

22
prota.h Executable file
View File

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

37
sprite.cpp Executable file
View File

@@ -0,0 +1,37 @@
#include "sprite.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
sprite.h Executable 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;
};