commit 4a359c46f55d1a200c1f83457cc071555dc57cb7 Author: Raimon Zamora Date: Tue Dec 30 22:46:46 2014 +0100 Primer commit diff --git a/.hgignore b/.hgignore new file mode 100644 index 0000000..27ad211 --- /dev/null +++ b/.hgignore @@ -0,0 +1,3 @@ +syntax: glob + +recursos/* diff --git a/bola.cpp b/bola.cpp new file mode 100755 index 0000000..fca6c70 --- /dev/null +++ b/bola.cpp @@ -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; + } + +} diff --git a/bola.h b/bola.h new file mode 100755 index 0000000..392e180 --- /dev/null +++ b/bola.h @@ -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; + +}; diff --git a/data.jrf b/data.jrf new file mode 100755 index 0000000..7da3b2d Binary files /dev/null and b/data.jrf differ diff --git a/engendro.cpp b/engendro.cpp new file mode 100755 index 0000000..74c4728 --- /dev/null +++ b/engendro.cpp @@ -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; +} diff --git a/engendro.h b/engendro.h new file mode 100755 index 0000000..525deae --- /dev/null +++ b/engendro.h @@ -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; + +}; diff --git a/info.h b/info.h new file mode 100755 index 0000000..453438e --- /dev/null +++ b/info.h @@ -0,0 +1,11 @@ +#pragma once + +struct Info { + int num_piramide; + int num_habitacio; + int diners; + int diamants; + int vida; + int momies; + int engendros; +}; diff --git a/jdraw8.cpp b/jdraw8.cpp new file mode 100755 index 0000000..7bce66d --- /dev/null +++ b/jdraw8.cpp @@ -0,0 +1,238 @@ +#include "jdraw8.h" +#include "SDL2/SDL_image.h" +#include "SDL2/SDL_opengl.h" +#include "jfile.h" +#include + +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(); + } +} diff --git a/jdraw8.h b/jdraw8.h new file mode 100755 index 0000000..c854aaf --- /dev/null +++ b/jdraw8.h @@ -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(); diff --git a/jfile.cpp b/jfile.cpp new file mode 100755 index 0000000..92101cf --- /dev/null +++ b/jfile.cpp @@ -0,0 +1,162 @@ +#include "jfile.h" +#include "SDL2/SDL.h" +#include + +#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;iindex.file_info ); + free( data_file ); + } +} diff --git a/jfile.h b/jfile.h new file mode 100755 index 0000000..3f36d29 --- /dev/null +++ b/jfile.h @@ -0,0 +1,7 @@ +#pragma once + +void JF_SetResourceFile(char *p_resourceFileName); + +char *JF_GetBufferFromResource(char *resourcename, int& filesize); + +void JF_Quit(); \ No newline at end of file diff --git a/jgame.cpp b/jgame.cpp new file mode 100755 index 0000000..29f7a2a --- /dev/null +++ b/jgame.cpp @@ -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; +} diff --git a/jgame.h b/jgame.h new file mode 100755 index 0000000..8146f59 --- /dev/null +++ b/jgame.h @@ -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(); diff --git a/jinput.cpp b/jinput.cpp new file mode 100755 index 0000000..ba01b35 --- /dev/null +++ b/jinput.cpp @@ -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; +} diff --git a/jinput.h b/jinput.h new file mode 100755 index 0000000..d5e47be --- /dev/null +++ b/jinput.h @@ -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(); diff --git a/jsound.cpp b/jsound.cpp new file mode 100755 index 0000000..7c8f9a2 --- /dev/null +++ b/jsound.cpp @@ -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(); +} + diff --git a/jsound.h b/jsound.h new file mode 100755 index 0000000..b77cd75 --- /dev/null +++ b/jsound.h @@ -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(); diff --git a/main.cpp b/main.cpp new file mode 100755 index 0000000..845f172 --- /dev/null +++ b/main.cpp @@ -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 + +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; +} + diff --git a/makefile b/makefile new file mode 100755 index 0000000..a0a85ec --- /dev/null +++ b/makefile @@ -0,0 +1,7 @@ +TARGET=aee +all: + g++ *.cpp -w -lSDL2 -lGL -lSDL2_image -lSDL2_mixer -o $(TARGET) + +clean: + rm -rf ./$(TARGET) + diff --git a/mapa.cpp b/mapa.cpp new file mode 100755 index 0000000..3396657 --- /dev/null +++ b/mapa.cpp @@ -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àtic de l'habitació + 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 (avertex.columna - this->ultim_vertex.columna ); + Uint8 fil_aux = abs( this->vertex.fila - this->ultim_vertex.fila ); + + if( col_aux > fil_aux ) { // Camí 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í 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; + } + +} diff --git a/mapa.h b/mapa.h new file mode 100755 index 0000000..0a60da9 --- /dev/null +++ b/mapa.h @@ -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; + +}; diff --git a/marcador.cpp b/marcador.cpp new file mode 100755 index 0000000..b51b4aa --- /dev/null +++ b/marcador.cpp @@ -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; + } +} diff --git a/marcador.h b/marcador.h new file mode 100755 index 0000000..6a6d6f5 --- /dev/null +++ b/marcador.h @@ -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; + +}; diff --git a/modulegame.cpp b/modulegame.cpp new file mode 100755 index 0000000..210e309 --- /dev/null +++ b/modulegame.cpp @@ -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; } + } +} diff --git a/modulegame.h b/modulegame.h new file mode 100755 index 0000000..2a6dbab --- /dev/null +++ b/modulegame.h @@ -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; + +}; diff --git a/modulesequence.cpp b/modulesequence.cpp new file mode 100755 index 0000000..f00c418 --- /dev/null +++ b/modulesequence.cpp @@ -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ú + doMenu(); + break; + case 1: // Slides + case 7: + doSlides(); + break; + case 2: // Pre-pirà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() { +} + diff --git a/modulesequence.h b/modulesequence.h new file mode 100755 index 0000000..37e393b --- /dev/null +++ b/modulesequence.h @@ -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; +}; diff --git a/momia.cpp b/momia.cpp new file mode 100755 index 0000000..4db97a8 --- /dev/null +++ b/momia.cpp @@ -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; + } +} diff --git a/momia.h b/momia.h new file mode 100755 index 0000000..c06fc09 --- /dev/null +++ b/momia.h @@ -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; + +}; diff --git a/prota.cpp b/prota.cpp new file mode 100755 index 0000000..ba7d56b --- /dev/null +++ b/prota.cpp @@ -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; +} + diff --git a/prota.h b/prota.h new file mode 100755 index 0000000..aefd2af --- /dev/null +++ b/prota.h @@ -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; + +}; diff --git a/sprite.cpp b/sprite.cpp new file mode 100755 index 0000000..f7fe8b6 --- /dev/null +++ b/sprite.cpp @@ -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); + +} + + diff --git a/sprite.h b/sprite.h new file mode 100755 index 0000000..dd4f777 --- /dev/null +++ b/sprite.h @@ -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; + +};