VAR/GameLib
1
1
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

(20140701)

Browse Source
This commit is contained in:
Valeriano A.R.
2014-07-01 00:00:00 +02:00
parent e283956e98
commit 7e6bd08390
27 changed files with 9164 additions and 707 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
GameEnts.c
View File

@@ -48,43 +48,43 @@ AudioSnd snd_burn;
AudioSnd snd_fillhole; AudioSnd snd_fillhole;
AudioSnd snd_drag; AudioSnd snd_drag;
Entity *ent_player; Entity ent_player;
Entity *ent_barrel; Entity ent_barrel;
Entity *ent_column; Entity ent_column;
Entity *ent_column_faded; Entity ent_column_faded;
Entity *ent_rock; Entity ent_rock;
Entity *ent_lamp; Entity ent_lamp;
Entity *ent_floor; Entity ent_floor;
Entity *ent_floor_right; Entity ent_floor_right;
Entity *ent_floor_left; Entity ent_floor_left;
Entity *ent_floor_center; Entity ent_floor_center;
Entity *ent_hole_spiked; Entity ent_hole_spiked;
Entity *ent_hole_filled; Entity ent_hole_filled;
Entity *ent_hole_lava; Entity ent_hole_lava;
Entity *ent_arrowshooter_up; Entity ent_arrowshooter_up;
Entity *ent_arrowshooter_down; Entity ent_arrowshooter_down;
Entity *ent_arrowshooter_left; Entity ent_arrowshooter_left;
Entity *ent_arrowshooter_right; Entity ent_arrowshooter_right;
Entity *ent_arrow_up; Entity ent_arrow_up;
Entity *ent_arrow_down; Entity ent_arrow_down;
Entity *ent_arrow_left; Entity ent_arrow_left;
Entity *ent_arrow_right; Entity ent_arrow_right;
Entity *ent_exitpoint; Entity ent_exitpoint;
Entity *ent_endpoint; Entity ent_endpoint;
Entity *ent_savepoint; Entity ent_savepoint;
Entity *ent_teleporter; Entity ent_teleporter;
Entity *ent_teleporter_dest; Entity ent_teleporter_dest;
Entity *ent_fire; Entity ent_fire;
Entity *ent_player_broken; Entity ent_player_broken;
extern int game_level; extern int game_level;
extern int game_level_point; extern int game_level_point;
extern int game_level_reset; extern int game_level_reset;
void player_proc(Entity *e,int ft){ void player_proc(Entity e,int ft){
vec2 vel; vec2 vel;
int pos[2],size[2],delta[2]; int pos[2],size[2],delta[2];
@@ -144,7 +144,7 @@ void player_proc(Entity *e,int ft){
GameLib_SetPos(pos); GameLib_SetPos(pos);
} }
int player_collision(Entity *e1,Entity *e2,float t,vec2 n){ int player_collision(Entity e1,Entity e2,float t,vec2 n){
if(e2->type==Ent_Barrel){ if(e2->type==Ent_Barrel){
float vlen; float vlen;
vec2 vdir; vec2 vdir;
@@ -164,7 +164,7 @@ int player_collision(Entity *e1,Entity *e2,float t,vec2 n){
return(1); return(1);
} }
void barrel_proc(Entity *e,int ft){ void barrel_proc(Entity e,int ft){
float qvel; float qvel;
int tnow; int tnow;
@@ -179,11 +179,11 @@ void barrel_proc(Entity *e,int ft){
} }
void hole_spiked_overlap(Entity *e1,Entity *e2){ void hole_spiked_overlap(Entity e1,Entity e2){
Entity *e; Entity e;
if(e2->type==Ent_Barrel){ if(e2->type==Ent_Barrel){
Entity *e; Entity e;
// Disable future overlaps // Disable future overlaps
e1->overlap=NULL; e1->overlap=NULL;
@@ -212,8 +212,8 @@ void hole_spiked_overlap(Entity *e1,Entity *e2){
} }
void hole_lava_overlap(Entity *e1,Entity *e2){ void hole_lava_overlap(Entity e1,Entity e2){
Entity *e; Entity e;
if(e2->type==Ent_Barrel){ if(e2->type==Ent_Barrel){
// "Burn the barrel" // "Burn the barrel"
@@ -235,8 +235,8 @@ void hole_lava_overlap(Entity *e1,Entity *e2){
} }
int arrow_collision(Entity *e1,Entity *e2,float t,vec2 n){ int arrow_collision(Entity e1,Entity e2,float t,vec2 n){
Entity *e; Entity e;
if(e1->postproc) if(e1->postproc)
return(0); return(0);
@@ -261,13 +261,13 @@ int arrow_collision(Entity *e1,Entity *e2,float t,vec2 n){
return(0); return(0);
} }
void arrowshooter_oncopy(Entity *e){ void arrowshooter_oncopy(Entity e){
e->A=rand()%30; e->A=rand()%30;
} }
void arrowshooter_proc(Entity *e,int ft){ void arrowshooter_proc(Entity e,int ft){
if(e->A==0){ if(e->A==0){
Entity *e2; Entity e2;
e2=Entity_Copy(e->child); e2=Entity_Copy(e->child);
vec2_copy(e2->pos,e->pos); vec2_copy(e2->pos,e->pos);
@@ -280,13 +280,13 @@ void arrowshooter_proc(Entity *e,int ft){
} }
} }
Entity *_savepoint=NULL; Entity _savepoint=NULL;
void savepoint_ondelete(Entity *e){ void savepoint_ondelete(Entity e){
if(_savepoint==e){ if(_savepoint==e){
_savepoint=NULL; _savepoint=NULL;
} }
} }
void savepoint_overlap(Entity *e1,Entity *e2){ void savepoint_overlap(Entity e1,Entity e2){
if(e2->type==Ent_Player){ if(e2->type==Ent_Player){
// Save the point // Save the point
if(game_level_point!=e1->A){ if(game_level_point!=e1->A){
@@ -305,7 +305,7 @@ void savepoint_overlap(Entity *e1,Entity *e2){
} }
} }
void exitpoint_overlap(Entity *e1,Entity *e2){ void exitpoint_overlap(Entity e1,Entity e2){
if(e2->type==Ent_Player){ if(e2->type==Ent_Player){
// Exit the level // Exit the level
game_level++; game_level++;
@@ -319,7 +319,7 @@ void exitpoint_overlap(Entity *e1,Entity *e2){
} }
} }
void endpoint_overlap(Entity *e1,Entity *e2){ void endpoint_overlap(Entity e1,Entity e2){
if(e2->type==Ent_Player){ if(e2->type==Ent_Player){
// Go to end // Go to end
game_level_reset=3; game_level_reset=3;
@@ -331,7 +331,7 @@ void endpoint_overlap(Entity *e1,Entity *e2){
} }
} }
void timeoutent_proc(Entity *e,int ft){ void timeoutent_proc(Entity e,int ft){
if(e->A==0){ if(e->A==0){
GameLib_DelEntity(e); GameLib_DelEntity(e);
}else{ }else{
@@ -339,7 +339,7 @@ void timeoutent_proc(Entity *e,int ft){
} }
} }
int teleporter_searchdest(Entity *ent,void *d){ int teleporter_searchdest(Entity ent,void *d){
int a=*(int*)d; int a=*(int*)d;
if(ent->type!=Ent_Teleporter_Dest){ if(ent->type!=Ent_Teleporter_Dest){
return 0; return 0;
@@ -351,8 +351,8 @@ int teleporter_searchdest(Entity *ent,void *d){
return 0; return 0;
} }
void teleporter_overlap(Entity *e1,Entity *e2){ void teleporter_overlap(Entity e1,Entity e2){
Entity *dest=NULL; Entity dest=NULL;
// Search the destination // Search the destination
dest=GameLib_SearchEnt(teleporter_searchdest,&e1->A); dest=GameLib_SearchEnt(teleporter_searchdest,&e1->A);
@@ -364,84 +364,84 @@ void teleporter_overlap(Entity *e1,Entity *e2){
void GameEnts_Init(){ void GameEnts_Init(){
Entity *ent; Entity ent;
////////////////////////////// //////////////////////////////
// Load Resources // Load Resources
img_barrel=Draw_LoadImage("data/barrel.bmp"); img_barrel=Draw_LoadImage("data/barrel.png");
Draw_SetOffset(img_barrel,-16,-32); Draw_SetOffset(img_barrel,-16,-32);
img_barrel2=Draw_LoadImage("data/barrel2.bmp"); img_barrel2=Draw_LoadImage("data/barrel2.png");
Draw_SetOffset(img_barrel2,-16,-16); Draw_SetOffset(img_barrel2,-16,-16);
img_floor=Draw_LoadImage("data/floor.bmp"); img_floor=Draw_LoadImage("data/floor.png");
Draw_SetOffset(img_floor,-16,-16); Draw_SetOffset(img_floor,-16,-16);
img_floor_left=Draw_LoadImage("data/floor_left.bmp"); img_floor_left=Draw_LoadImage("data/floor_left.png");
Draw_SetOffset(img_floor_left,-16,-16); Draw_SetOffset(img_floor_left,-16,-16);
img_floor_right=Draw_LoadImage("data/floor_right.bmp"); img_floor_right=Draw_LoadImage("data/floor_right.png");
Draw_SetOffset(img_floor_right,-16,-16); Draw_SetOffset(img_floor_right,-16,-16);
img_floor_center=Draw_LoadImage("data/floor_center.bmp"); img_floor_center=Draw_LoadImage("data/floor_center.png");
Draw_SetOffset(img_floor_center,-16,-16); Draw_SetOffset(img_floor_center,-16,-16);
img_column=Draw_LoadImage("data/column.bmp"); img_column=Draw_LoadImage("data/column.png");
Draw_SetOffset(img_column,-16,-80); Draw_SetOffset(img_column,-16,-80);
img_column_faded=Draw_LoadImage("data/column_faded.bmp"); img_column_faded=Draw_LoadImage("data/column_faded.png");
Draw_SetOffset(img_column_faded,-16,-80); Draw_SetOffset(img_column_faded,-16,-80);
img_rock=Draw_LoadImage("data/rock.bmp"); img_rock=Draw_LoadImage("data/rock.png");
Draw_SetOffset(img_rock,-16,-32); Draw_SetOffset(img_rock,-16,-32);
img_lamp=Draw_LoadImage("data/lamp.bmp"); img_lamp=Draw_LoadImage("data/lamp.png");
Draw_SetOffset(img_lamp,-16,-48); Draw_SetOffset(img_lamp,-16,-48);
img_hole_spiked=Draw_LoadImage("data/hole_spiked.bmp"); img_hole_spiked=Draw_LoadImage("data/hole_spiked.png");
Draw_SetOffset(img_hole_spiked,-16,-16); Draw_SetOffset(img_hole_spiked,-16,-16);
anim_hole_lava=Anim_LoadAnim("data/hole_lava.bmp",2,3); anim_hole_lava=Anim_LoadAnim("data/hole_lava.png",2,3);
Anim_SetOffset(anim_hole_lava,-16,-16); Anim_SetOffset(anim_hole_lava,-16,-16);
img_player_up=Draw_LoadImage("data/player_up.bmp"); img_player_up=Draw_LoadImage("data/player_up.png");
Draw_SetOffset(img_player_up,-16,-48); Draw_SetOffset(img_player_up,-16,-48);
img_player_down=Draw_LoadImage("data/player_down.bmp"); img_player_down=Draw_LoadImage("data/player_down.png");
Draw_SetOffset(img_player_down,-16,-48); Draw_SetOffset(img_player_down,-16,-48);
img_player_left=Draw_LoadImage("data/player_left.bmp"); img_player_left=Draw_LoadImage("data/player_left.png");
Draw_SetOffset(img_player_left,-16,-48); Draw_SetOffset(img_player_left,-16,-48);
img_player_right=Draw_LoadImage("data/player_right.bmp"); img_player_right=Draw_LoadImage("data/player_right.png");
Draw_SetOffset(img_player_right,-16,-48); Draw_SetOffset(img_player_right,-16,-48);
img_savepoint=Draw_LoadImage("data/save_point.bmp"); img_savepoint=Draw_LoadImage("data/save_point.png");
Draw_SetOffset(img_savepoint,-16,-16); Draw_SetOffset(img_savepoint,-16,-16);
anim_savepoint_active=Anim_LoadAnim("data/save_point_active.bmp",2,5); anim_savepoint_active=Anim_LoadAnim("data/save_point_active.png",2,5);
Anim_SetOffset(anim_savepoint_active,-16,-16); Anim_SetOffset(anim_savepoint_active,-16,-16);
anim_exitpoint=Anim_LoadAnim("data/exit_point.bmp",2,10); anim_exitpoint=Anim_LoadAnim("data/exit_point.png",2,10);
Anim_SetOffset(anim_exitpoint,-16,-48); Anim_SetOffset(anim_exitpoint,-16,-48);
img_endpoint=Draw_LoadImage("data/end_point.bmp"); img_endpoint=Draw_LoadImage("data/end_point.png");
Draw_SetOffset(img_endpoint,-16,-32); Draw_SetOffset(img_endpoint,-16,-32);
img_arrowshooter_up=Draw_LoadImage("data/arrowshooter_up.bmp"); img_arrowshooter_up=Draw_LoadImage("data/arrowshooter_up.png");
Draw_SetOffset(img_arrowshooter_up,-16,-16); Draw_SetOffset(img_arrowshooter_up,-16,-16);
img_arrowshooter_down=Draw_LoadImage("data/arrowshooter_down.bmp"); img_arrowshooter_down=Draw_LoadImage("data/arrowshooter_down.png");
Draw_SetOffset(img_arrowshooter_down,-16,-16); Draw_SetOffset(img_arrowshooter_down,-16,-16);
img_arrowshooter_left=Draw_LoadImage("data/arrowshooter_left.bmp"); img_arrowshooter_left=Draw_LoadImage("data/arrowshooter_left.png");
Draw_SetOffset(img_arrowshooter_left,-16,-16); Draw_SetOffset(img_arrowshooter_left,-16,-16);
img_arrowshooter_right=Draw_LoadImage("data/arrowshooter_right.bmp"); img_arrowshooter_right=Draw_LoadImage("data/arrowshooter_right.png");
Draw_SetOffset(img_arrowshooter_right,-16,-16); Draw_SetOffset(img_arrowshooter_right,-16,-16);
img_arrow_up=Draw_LoadImage("data/arrow_up.bmp"); img_arrow_up=Draw_LoadImage("data/arrow_up.png");
Draw_SetOffset(img_arrow_up,-16,-16); Draw_SetOffset(img_arrow_up,-16,-16);
img_arrow_down=Draw_LoadImage("data/arrow_down.bmp"); img_arrow_down=Draw_LoadImage("data/arrow_down.png");
Draw_SetOffset(img_arrow_down,-16,-16); Draw_SetOffset(img_arrow_down,-16,-16);
img_arrow_left=Draw_LoadImage("data/arrow_left.bmp"); img_arrow_left=Draw_LoadImage("data/arrow_left.png");
Draw_SetOffset(img_arrow_left,-16,-16); Draw_SetOffset(img_arrow_left,-16,-16);
img_arrow_right=Draw_LoadImage("data/arrow_right.bmp"); img_arrow_right=Draw_LoadImage("data/arrow_right.png");
Draw_SetOffset(img_arrow_right,-16,-16); Draw_SetOffset(img_arrow_right,-16,-16);
anim_fire=Anim_LoadAnim("data/fire.bmp",3,5); anim_fire=Anim_LoadAnim("data/fire.png",3,5);
Anim_SetOffset(anim_fire,-16,-48); Anim_SetOffset(anim_fire,-16,-48);
img_player_broken=Draw_LoadImage("data/player_broken.bmp"); img_player_broken=Draw_LoadImage("data/player_broken.png");
Draw_SetOffset(img_player_broken,-16,-48); Draw_SetOffset(img_player_broken,-16,-48);

52
GameEnts.h
View File

@@ -21,31 +21,31 @@ enum {
Ent_Teleporter_Dest, Ent_Teleporter_Dest,
Ent_Effect Ent_Effect
} EntityType; } EntityType;
extern Entity *ent_player; extern Entity ent_player;
extern Entity *ent_barrel; extern Entity ent_barrel;
extern Entity *ent_column; extern Entity ent_column;
extern Entity *ent_column_faded; extern Entity ent_column_faded;
extern Entity *ent_rock; extern Entity ent_rock;
extern Entity *ent_lamp; extern Entity ent_lamp;
extern Entity *ent_floor; extern Entity ent_floor;
extern Entity *ent_floor_right; extern Entity ent_floor_right;
extern Entity *ent_floor_left; extern Entity ent_floor_left;
extern Entity *ent_floor_center; extern Entity ent_floor_center;
extern Entity *ent_hole_spiked; extern Entity ent_hole_spiked;
extern Entity *ent_hole_filled; extern Entity ent_hole_filled;
extern Entity *ent_hole_lava; extern Entity ent_hole_lava;
extern Entity *ent_arrowshooter_up; extern Entity ent_arrowshooter_up;
extern Entity *ent_arrowshooter_down; extern Entity ent_arrowshooter_down;
extern Entity *ent_arrowshooter_left; extern Entity ent_arrowshooter_left;
extern Entity *ent_arrowshooter_right; extern Entity ent_arrowshooter_right;
extern Entity *ent_arrow_up; extern Entity ent_arrow_up;
extern Entity *ent_arrow_down; extern Entity ent_arrow_down;
extern Entity *ent_arrow_left; extern Entity ent_arrow_left;
extern Entity *ent_arrow_right; extern Entity ent_arrow_right;
extern Entity *ent_exitpoint; extern Entity ent_exitpoint;
extern Entity *ent_endpoint; extern Entity ent_endpoint;
extern Entity *ent_savepoint; extern Entity ent_savepoint;
extern Entity *ent_teleporter; extern Entity ent_teleporter;
extern Entity *ent_teleporter_dest; extern Entity ent_teleporter_dest;
#endif #endif

12
GameLib/Audio.c
View File

@@ -4,6 +4,9 @@
#define _WIN32_WINNT 0x0501 #define _WIN32_WINNT 0x0501
#include <windows.h> #include <windows.h>
#endif #endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <SDL/SDL.h> #include <SDL/SDL.h>
#include "Audio.h" #include "Audio.h"
@@ -63,7 +66,11 @@ int Audio_Init(){
as.freq = 44100; as.freq = 44100;
as.format = AUDIO_S16SYS; as.format = AUDIO_S16SYS;
as.channels = 2; as.channels = 2;
#ifdef EMSCRIPTEN
as.samples = 4096;
#else
as.samples = 1024; as.samples = 1024;
#endif
as.callback = Audio_MixerCallback; as.callback = Audio_MixerCallback;
if(SDL_OpenAudio(&as, &as2) < 0){ if(SDL_OpenAudio(&as, &as2) < 0){
printf("Audio_Init: Failure opening audio.\n"); printf("Audio_Init: Failure opening audio.\n");
@@ -191,7 +198,7 @@ void Audio_Frame(){
// Loads a sound, giving a reference. // Loads a sound, giving a reference.
AudioSnd Audio_LoadSound(char *filename){ AudioSnd Audio_LoadSound(char *filename){
AudioWave *wave; AudioWave *wave;
#ifndef EMSCRIPTEN
// Allocate and load the sound // Allocate and load the sound
wave=malloc(sizeof(AudioWave)); wave=malloc(sizeof(AudioWave));
if( SDL_LoadWAV(filename, if( SDL_LoadWAV(filename,
@@ -222,6 +229,9 @@ AudioSnd Audio_LoadSound(char *filename){
_waves=wave; _waves=wave;
return((AudioSnd)wave); return((AudioSnd)wave);
#else
return(NULL);
#endif
} }

529
GameLib/Draw.c
View File

@@ -2,6 +2,7 @@
#include <math.h> #include <math.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h>
#include <string.h> #include <string.h>
#ifdef WIN32 #ifdef WIN32
@@ -10,23 +11,39 @@
#include <GL/gl.h> #include <GL/gl.h>
#include <GL/glext.h> #include <GL/glext.h>
#else #else
#ifdef MACOSX #ifdef EMSCRIPTEN
#include <Cocoa/Cocoa.h> //#include <GLES2/gl2.h>
#include <OpenGL/OpenGL.h> //#define GL_GLEXT_PROTOTYPES 1
#include <OpenGL/gl.h> //#include <GLES2/gl2ext.h>
#include <OpenGL/glu.h> #include <emscripten.h>
#include <OpenGL/glext.h> #include <GL/gl.h>
#else #else
#include <GL/gl.h> #include <GL/gl.h>
#endif #endif
#endif #endif
#include "lodepng.c"
#include <SDL/SDL.h> #include <SDL/SDL.h>
#include "Time.h" #include "Time.h"
#include "Util.h" #include "Util.h"
#include "Draw.h" #include "QuadArray2D.h"
#include "Input.h"
#include "Audio.h" #include "Audio.h"
#include "Input.h"
#include "Draw.h"
////////////////////////////////////////////////
// DrawImage //
///////////////
// Image container.
typedef struct TDrawImage TDrawImage, *DrawImage;
struct TDrawImage {
unsigned char *data;
int x,y;
int w,h;
GLuint tex;
};
// Globals // Globals
@@ -35,6 +52,13 @@ int _width;
int _height; int _height;
long long proc_t_frame=33333; long long proc_t_frame=33333;
long long draw_t_frame=16667; long long draw_t_frame=16667;
int _fps=60;
QuadArray2D _quadArray=NULL;
DrawImage _currentImg=NULL;
float _color[4];
///////////////////////////// /////////////////////////////
// Draw_Init // Draw_Init
@@ -57,7 +81,7 @@ int Draw_Init(int width,int height,char *title,int pfps,int fps){
// Initialize SDL // Initialize SDL
if(SDL_Init(SDL_INIT_VIDEO)<0){ if(SDL_Init(SDL_INIT_VIDEO)<0){
printf("Draw_Init: Failure initializing SDL.\n"); printf("Draw_Init: Failure initializing SDL.\n");
printf("Draw_Init: SDL Error: %s\n",SDL_GetError()); printf("\tSDL Error: %s\n",SDL_GetError());
return(0); return(0);
} }
@@ -69,7 +93,6 @@ int Draw_Init(int width,int height,char *title,int pfps,int fps){
SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 8); SDL_GL_SetAttribute (SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 24); SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute (SDL_GL_STENCIL_SIZE, 8); SDL_GL_SetAttribute (SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute (SDL_GL_SWAP_CONTROL, 0);
SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
@@ -77,18 +100,19 @@ int Draw_Init(int width,int height,char *title,int pfps,int fps){
_screen=SDL_SetVideoMode(width,height,32,SDL_HWSURFACE|SDL_OPENGL); _screen=SDL_SetVideoMode(width,height,32,SDL_HWSURFACE|SDL_OPENGL);
if( _screen == NULL){ if( _screen == NULL){
printf("Draw_Init: Failure initializing video mode.\n"); printf("Draw_Init: Failure initializing video mode.\n");
printf("Draw_Init: SDL Error: %s\n",SDL_GetError()); printf("\tSDL Error: %s\n",SDL_GetError());
return(0); return(0);
} }
SDL_WM_SetCaption(title, NULL); SDL_WM_SetCaption(title, NULL);
proc_t_frame=1000000/pfps; proc_t_frame=1000000/pfps;
draw_t_frame=1000000/fps; draw_t_frame=1000000/fps;
_fps=fps;
_width=width; _width=width;
_height=height; _height=height;
// Set the desired state // Set the desired state
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); //glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING); glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
@@ -126,83 +150,123 @@ int Draw_Init(int width,int height,char *title,int pfps,int fps){
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
// Initialize the triangle array
_quadArray=QuadArray2D_Create(400);
Draw_SetColor(1.0f,1.0f,1.0f,1.0f);
return(1); return(1);
} }
/////////////////////////////
// Draw_LoopIteration
//
// One iteracion of the loop updating the game window.
int (*_proc_func)()=NULL;
void (*_draw_func)(float f)=NULL;
long long _accTime;
int Draw_LoopIteration(){
SDL_Event event;
Uint8* keys;
int done=0;
// Update screen
SDL_GL_SwapBuffers();
// Process Events
while(SDL_PollEvent(&event) ){
if(event.type == SDL_QUIT ){
done=1;
}
if(event.type == SDL_KEYDOWN ){
if(event.key.keysym.sym == SDLK_ESCAPE ) {
done=1;
}
}
}
#ifndef EMSCRIPTEN
// Process keys for Draw
keys=(Uint8 *)SDL_GetKeyState(NULL);
if(keys[SDLK_F12]){
// Screenshot key
Draw_SaveScreenshoot("shot.bmp");
}
#endif
// Sound Frame
Audio_Frame();
// Process
if(_proc_func){
if(_accTime>100000){
_accTime=100000;
}
while(_accTime>=proc_t_frame && !done){
Input_Frame();
if(!_proc_func()){
done=1;
}
_accTime-=proc_t_frame;
}
}
// Draw
if(_draw_func){
float frameFactor=0.0f;
frameFactor=(float)_accTime/(float)proc_t_frame;
_draw_func(frameFactor);
Draw_Flush();
}
return done;
}
#ifdef EMSCRIPTEN
long long _procTime1;
long long _procTime2;
void Draw_LoopIterationAux(){
Draw_LoopIteration();
// Update time
_procTime2=Time_GetTime();
_accTime+=_procTime2-_procTime1;
_procTime1=_procTime2;
}
#endif
///////////////////////////// /////////////////////////////
// Draw_Loop // Draw_Loop
// //
// Loops updating the game window. // Loops updating the game window.
void Draw_Loop(int (*proc)(),void (*draw)()){ void Draw_Loop(int (*proc)(),void (*draw)(float f)){
int done=0; long long newTime;
SDL_Event event; long long procTime1,procTime2,drawTime1,drawTime2,waitTime;
Uint8* keys;
long long time,time2,timed;
long long t_frame=0;
t_frame=proc_t_frame; _proc_func=proc;
time=Time_GetTime(); _draw_func=draw;
while(!done){ #ifndef EMSCRIPTEN
_accTime=proc_t_frame;
procTime1=drawTime1=Time_GetTime();
while(!Draw_LoopIteration()){
// Update screen // Wait to round draw_t_frame
SDL_GL_SwapBuffers(); drawTime2=Time_GetTime();
waitTime=draw_t_frame-(drawTime2-drawTime1);
Time_Pause(waitTime);
drawTime2=Time_GetTime();
drawTime1=drawTime2;
// Process Events // Update time
while(SDL_PollEvent(&event) ){ procTime2=Time_GetTime();
if(event.type == SDL_QUIT ){ _accTime+=procTime2-procTime1;
done=1; procTime1=procTime2;
}
if(event.type == SDL_KEYDOWN ){
if(event.key.keysym.sym == SDLK_ESCAPE ) {
done=1;
}
}
}
// Process keys for Draw
keys=SDL_GetKeyState(NULL);
if(keys[SDLK_F12]){
// Screenshot key
Draw_SaveScreenshoot("shot.bmp");
}
// Sound Frame
Audio_Frame();
// Process and draw
if(proc){
while(t_frame>=proc_t_frame && !done){
Input_Frame();
if(!proc()){
done=1;
}
t_frame-=proc_t_frame;
}
}
if(draw){
draw();
}
// Measure time
time2=Time_GetTime();
timed=time2-time;
if(timed<draw_t_frame){
Time_Pause(draw_t_frame-timed);
time2=Time_GetTime();
t_frame+=time2-time;
}else{
t_frame+=timed;
}
time=time2;
// FIX: Limit process frame rate
if(t_frame>50000){
t_frame=50000;
}
} }
#else
_accTime=proc_t_frame;
_procTime1=Time_GetTime();
emscripten_set_main_loop(Draw_LoopIterationAux, _fps, 1);
#endif
} }
@@ -215,123 +279,84 @@ void Draw_Clean(
unsigned char g, unsigned char g,
unsigned char b) unsigned char b)
{ {
glClearColor(r/256.0f,g/256.0f,b/256.0f,1.0f); glClearColor(r/255.0f,g/255.0f,b/255.0f,1.0f);
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
} }
////////////////////////////////////////////////
// DrawImage //
///////////////
// Image container.
typedef struct Tag_DrawImage {
SDL_Surface *surf;
GLuint tex;
int x,y;
} DrawImage;
/////////////////////////////
// Draw_LoadSurface
//
// Loads a surface.
SDL_Surface *Draw_LoadSurface(char *filename){
SDL_Surface *surf;
// Load the BMP as a surface
surf=SDL_LoadBMP(filename);
if(surf == NULL){
printf("Draw_LoadImage: Failure Loading image: %s\n",filename);
printf("Draw_LoadImage: SDL Error: %s\n",SDL_GetError());
return(NULL);
}
if (surf->format->BytesPerPixel==4) {
// Swap RGB to BGR
Uint32 *ptr,*ptr_end;
ptr=(Uint32 *)surf->pixels;
ptr_end=ptr+(surf->w*surf->h);
while (ptr<ptr_end) {
unsigned char temp;
unsigned char *pixel;
pixel=(unsigned char *)ptr;
temp=pixel[2];
pixel[2]=pixel[0];
pixel[0]=temp;
ptr++;
}
}
return(surf);
}
///////////////////////////// /////////////////////////////
// Draw_UploadGLTexture // Draw_UploadGLTexture
// //
// Uploads a OpenGL texture. // Uploads a OpenGL texture.
GLuint Draw_UploadGLTexture(SDL_Surface *surf){ GLuint Draw_UploadGLTexture(int w, int h, unsigned char *pixels){
GLuint tex; GLuint tex;
// Generate OpenGL texture // Generate OpenGL texture
glGenTextures(1, &tex); glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex); glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// Load OpenGL texture // Load OpenGL texture
glBindTexture(GL_TEXTURE_2D, tex); glBindTexture(GL_TEXTURE_2D, tex);
glPixelStorei( GL_UNPACK_ROW_LENGTH, surf->w ); //glPixelStorei( GL_UNPACK_ROW_LENGTH, w );
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
// surf->w, surf->h, 0,
// GL_RGBA, GL_UNSIGNED_BYTE, surf->pixels);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
surf->w, surf->h, 0, w, h, 0,
GL_RGBA, GL_UNSIGNED_BYTE, surf->pixels); GL_RGBA, GL_UNSIGNED_BYTE, pixels);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,
// imagen->ancho, imagen->alto, 0,
// GL_RGB, GL_UNSIGNED_BYTE, imagen->data);
return(tex); return(tex);
} }
/////////////////////////////
// Draw_CreateImage
//
DrawImg Draw_CreateImage(int w,int h){
DrawImage image;
// Create the image container
image=malloc(sizeof(TDrawImage));
image->data=malloc(w*h*4);
image->x=0;
image->y=0;
image->w=w;
image->h=h;
image->tex=-1;
return((DrawImg)image);
}
///////////////////////////// /////////////////////////////
// Draw_LoadImage // Draw_LoadImage
// //
// Loads a image, giving a reference. // Loads a image, giving a reference.
DrawImg Draw_LoadImage(char *filename){ DrawImg Draw_LoadImage(char *filename){
DrawImage *image; DrawImage image;
SDL_Surface *surf;
// Try loading PNG images
// Loads the surface if(EndsWith(filename,".png") || EndsWith(filename,".PNG")){
surf=Draw_LoadSurface(filename); image=malloc(sizeof(TDrawImage));
if(surf == NULL){ unsigned error = lodepng_decode32_file(
return(NULL); &image->data,
(unsigned*)&image->w,
(unsigned*)&image->h,
filename);
if(error){
printf("Draw_LoadImage: PNG decoder error %u: %s\n", error, lodepng_error_text(error));
return(NULL);
}
image->x=-(int)(image->w/2);
image->y=-(int)(image->h/2);
image->tex=-1;
return (DrawImg)image;
} }
printf("Draw_LoadImage: Image type not supported: %s\n",filename);
// Create the image container return(NULL);
image=malloc(sizeof(DrawImage));
image->surf=surf;
image->tex=Draw_UploadGLTexture(surf);
//image->x=0;
//image->y=0;
image->x=-(surf->w/2);
image->y=-(surf->h/2);
return((DrawImg)image);
} }
@@ -340,11 +365,11 @@ DrawImg Draw_LoadImage(char *filename){
// //
// Gets the image size. // Gets the image size.
void Draw_GetSize(DrawImg img,int *w,int *h){ void Draw_GetSize(DrawImg img,int *w,int *h){
DrawImage *image=img; DrawImage image=img;
// Gets the image size // Gets the image size
*w=image->surf->w; *w=image->w;
*h=image->surf->h; *h=image->h;
} }
@@ -354,14 +379,14 @@ void Draw_GetSize(DrawImg img,int *w,int *h){
// //
// Sets and Gets the image offset. // Sets and Gets the image offset.
void Draw_SetOffset(DrawImg img,int x,int y){ void Draw_SetOffset(DrawImg img,int x,int y){
DrawImage *image=img; DrawImage image=img;
// Sets the image offset // Sets the image offset
image->x=x; image->x=x;
image->y=y; image->y=y;
} }
void Draw_GetOffset(DrawImg img,int *x,int *y){ void Draw_GetOffset(DrawImg img,int *x,int *y){
DrawImage *image=img; DrawImage image=img;
// Gets the image offset // Gets the image offset
*x=image->x; *x=image->x;
@@ -369,35 +394,65 @@ void Draw_GetOffset(DrawImg img,int *x,int *y){
} }
/////////////////////////////
// Draw_Flush
//
// Performs all the queued draw actions.
void Draw_Flush(){
if(_currentImg==NULL){
return;
}
if(_currentImg->tex==-1){
_currentImg->tex=Draw_UploadGLTexture(_currentImg->w, _currentImg->h, _currentImg->data);
}
// Draw the quad array
glBindTexture(GL_TEXTURE_2D, _currentImg->tex);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer( 4, GL_FLOAT, Vertex2D_Length*sizeof(float),
(GLvoid *)(_quadArray->vertexData+4) );
glTexCoordPointer( 2, GL_FLOAT, Vertex2D_Length*sizeof(float),
(GLvoid *)(_quadArray->vertexData+2) );
glVertexPointer( 2, GL_FLOAT, Vertex2D_Length*sizeof(float),
(GLvoid *)(_quadArray->vertexData) );
glDrawArrays(GL_QUADS,0,_quadArray->nVertex);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
// Empty it
QuadArray2D_Clean(_quadArray);
}
///////////////////////////// /////////////////////////////
// Draw_DrawImg // Draw_DrawImg
// //
// Draws an image. // Draws an image.
void Draw_DrawImg(DrawImg img,int x,int y){ void Draw_DrawImg(DrawImg img,int x,int y){
DrawImage *image=img; DrawImage image=img;
int x1,x2,y1,y2; float x1,x2,y1,y2;
// Prepare // Prepare
x1=x+image->x; x1=x+image->x;
y1=_height-(y+image->y); y1=_height-(y+image->y);
x2=(x+image->x)+image->surf->w; x2=(x+image->x)+image->w;
y2=_height-((y+image->y)+image->surf->h); y2=_height-((y+image->y)+image->h);
// Draw a quad // Draw a quad
glBindTexture(GL_TEXTURE_2D, image->tex); if(_currentImg!=image){
glBegin (GL_QUADS); Draw_Flush();
glTexCoord2f (1, 0); _currentImg=image;
glVertex2i (x2, y1); }
QuadArray2D_AddQuad(_quadArray,
glTexCoord2f (0, 0); x1,y1,0.0f,0.0f,
glVertex2i (x1, y1); x2,y2,1.0f,1.0f,
_color);
glTexCoord2f (0, 1);
glVertex2i (x1, y2);
glTexCoord2f (1, 1);
glVertex2i (x2, y2);
glEnd ();
} }
@@ -406,7 +461,7 @@ void Draw_DrawImg(DrawImg img,int x,int y){
// //
// Draws an image, resizing. // Draws an image, resizing.
void Draw_DrawImgResized(DrawImg img,int x,int y,float w,float h){ void Draw_DrawImgResized(DrawImg img,int x,int y,float w,float h){
DrawImage *image=img; DrawImage image=img;
int x1,x2,y1,y2; int x1,x2,y1,y2;
// Prepare // Prepare
@@ -416,20 +471,14 @@ void Draw_DrawImgResized(DrawImg img,int x,int y,float w,float h){
y2=_height-((y+image->y)+h); y2=_height-((y+image->y)+h);
// Draw a quad // Draw a quad
glBindTexture(GL_TEXTURE_2D, image->tex); if(_currentImg!=image){
glBegin (GL_QUADS); Draw_Flush();
glTexCoord2f (1, 0); _currentImg=image;
glVertex2i (x2, y1); }
QuadArray2D_AddQuad(_quadArray,
glTexCoord2f (0, 0); x1,y1,0.0f,0.0f,
glVertex2i (x1, y1); x2,y2,1.0f,1.0f,
_color);
glTexCoord2f (0, 1);
glVertex2i (x1, y2);
glTexCoord2f (1, 1);
glVertex2i (x2, y2);
glEnd ();
} }
@@ -439,7 +488,7 @@ void Draw_DrawImgResized(DrawImg img,int x,int y,float w,float h){
// //
// Draws an image part. // Draws an image part.
void Draw_DrawImgPart(DrawImg img,int x,int y,int w,int i){ void Draw_DrawImgPart(DrawImg img,int x,int y,int w,int i){
DrawImage *image=img; DrawImage image=img;
int x1,x2,y1,y2; int x1,x2,y1,y2;
float us,u1,u2; float us,u1,u2;
@@ -447,26 +496,20 @@ void Draw_DrawImgPart(DrawImg img,int x,int y,int w,int i){
x1=x+image->x; x1=x+image->x;
y1=_height-(y+image->y); y1=_height-(y+image->y);
x2=(x+image->x)+w; x2=(x+image->x)+w;
y2=_height-((y+image->y)+image->surf->h); y2=_height-((y+image->y)+image->h);
us=1.0f/image->surf->w; us=1.0f/image->w;
u1=us*i*w; u1=us*i*w;
u2=u1+us*w; u2=u1+us*w;
// Draw a quad // Draw a quad
glBindTexture(GL_TEXTURE_2D, image->tex); if(_currentImg!=image){
glBegin (GL_QUADS); Draw_Flush();
glTexCoord2f (u2, 0); _currentImg=image;
glVertex2i (x2, y1); }
QuadArray2D_AddQuad(_quadArray,
glTexCoord2f (u1, 0); x1,y1,u1,0.0f,
glVertex2i (x1, y1); x2,y2,u2,1.0f,
_color);
glTexCoord2f (u1, 1);
glVertex2i (x1, y2);
glTexCoord2f (u2, 1);
glVertex2i (x2, y2);
glEnd ();
} }
@@ -476,6 +519,10 @@ void Draw_DrawImgPart(DrawImg img,int x,int y,int w,int i){
// //
void Draw_SetColor(float r,float g,float b,float a){ void Draw_SetColor(float r,float g,float b,float a){
glColor4f(r,g,b,a); glColor4f(r,g,b,a);
_color[0]=r;
_color[1]=g;
_color[2]=b;
_color[3]=a;
} }
@@ -491,51 +538,41 @@ typedef struct {
///////////////////////////// /////////////////////////////
// Draw_DefaultFont // Draw_DefaultImage
// //
// Creates a surface with the default font. // Creates a image with the default font.
#include "FontData.h" #include "FontData.h"
SDL_Surface *Draw_DefaultFontSurface( DrawImage Draw_DefaultFontImage(
unsigned char r, unsigned char r,
unsigned char g, unsigned char g,
unsigned char b, unsigned char b,
unsigned char a) unsigned char a)
{ {
SDL_Surface *surf; DrawImage img;
int x,y,c; int x,y,c;
Uint32 color,color2; Uint32 color,color2;
// Create the surface // Create the image and colors
surf = SDL_CreateRGBSurface(SDL_SWSURFACE, img=Draw_CreateImage(8*256,8);
8*256, 8, 32,0,0,0,0);
surf->format->Amask=0xFF000000;
surf->format->Ashift=24;
SDL_SetAlpha(surf, SDL_SRCALPHA, 255);
// HACK: Set the colors in BGR order
color =SDL_MapRGBA(surf->format,b,g,r,a);
color2=SDL_MapRGBA(surf->format,b,g,r,0);
// Draw the font // Draw the font
SDL_LockSurface(surf);
for(c=0;c<256;c++){ for(c=0;c<256;c++){
for(y=0;y<8;y++){ for(y=0;y<8;y++){
for(x=0;x<8;x++){ for(x=0;x<8;x++){
int offset=((c*8+x)+(8*256*y))*4;
img->data[offset+0]=r;
img->data[offset+1]=g;
img->data[offset+2]=b;
if(((fontdata_8x8[c*8+y]>>(7-x)) & 0x01)==1){ if(((fontdata_8x8[c*8+y]>>(7-x)) & 0x01)==1){
//Imagen_PutPixel(dest,c*8+x,y,color); img->data[offset+3]=0xFF;
((Uint32 *)surf->pixels)[(c*8+x)+(8*256*y)]=
color;
}else{ }else{
//Imagen_PutPixel(dest,c*8+x,y,color2); img->data[offset+3]=0x00;
((Uint32 *)surf->pixels)[(c*8+x)+(8*256*y)]=
color2;
} }
} }
} }
} }
SDL_UnlockSurface(surf);
return(surf); return(img);
} }
@@ -553,10 +590,7 @@ DrawFnt Draw_DefaultFont(
// Create the default font // Create the default font
font=malloc(sizeof(DrawFont)); font=malloc(sizeof(DrawFont));
font->img.surf=Draw_DefaultFontSurface(r,g,b,a); font->img=Draw_DefaultFontImage(r,g,b,a);
font->img.tex=Draw_UploadGLTexture(font->img.surf);
font->img.x=0;
font->img.y=0;
font->w=8; font->w=8;
font->h=8; font->h=8;
font->min=0; font->min=0;
@@ -574,12 +608,9 @@ DrawFnt Draw_LoadFont(char *fichero,int min,int max){
// Create the font form the image // Create the font form the image
font=malloc(sizeof(DrawFont)); font=malloc(sizeof(DrawFont));
font->img.surf=Draw_LoadSurface(fichero); font->img=Draw_LoadImage(fichero);
font->img.tex=Draw_UploadGLTexture(font->img.surf); font->w=font->img->w/(max-min);
font->img.x=0; font->h=font->img->h;
font->img.y=0;
font->w=font->img.surf->w/(max-min);
font->h=font->img.surf->h;
font->min=min; font->min=min;
font->max=max; font->max=max;
@@ -599,7 +630,7 @@ void Draw_DrawText(DrawFnt f,char *text,int x,int y){
ptr=text; ptr=text;
while(*ptr){ while(*ptr){
if((*ptr)<font->max){ if((*ptr)<font->max){
Draw_DrawImgPart((DrawImg)&font->img,x,y,font->w,(*ptr)-font->min); Draw_DrawImgPart(font->img,x,y,font->w,(*ptr)-font->min);
} }
x+=font->w; x+=font->w;
ptr++; ptr++;

15
GameLib/Draw.h
View File

@@ -15,7 +15,7 @@ int Draw_Init(int width,int height,char *title,int pfps,int fps);
// Draw_Loop // Draw_Loop
// //
// Loops updating the game window. // Loops updating the game window.
void Draw_Loop(int (*proc)(),void (*draw)()); void Draw_Loop(int (*proc)(),void (*draw)(float f));
///////////////////////////// /////////////////////////////
@@ -28,6 +28,13 @@ void Draw_Clean(
unsigned char b); unsigned char b);
/////////////////////////////
// Draw_Flush
//
// Performs all the queued draw actions.
void Draw_Flush();
//////////////////////////////////////////////// ////////////////////////////////////////////////
// DrawImg // // DrawImg //
///////////// /////////////
@@ -35,6 +42,12 @@ void Draw_Clean(
typedef void *DrawImg; typedef void *DrawImg;
/////////////////////////////
// Draw_CreateImage
//
DrawImg Draw_CreateImage(int w,int h);
///////////////////////////// /////////////////////////////
// Draw_LoadImage // Draw_LoadImage
// //

512
GameLib/Entity.c
View File

@@ -1,4 +1,4 @@
// Copyright (C) 2011 Valeriano Alfonso Rodriguez (Kableado) // Copyright (C) 2011-2014 Valeriano Alfonso Rodriguez (Kableado)
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@@ -17,12 +17,12 @@
// Entity_New // Entity_New
// //
// //
Entity *_free_entity=NULL; Entity _free_entity=NULL;
Entity *Entity_New(){ Entity Entity_New(){
Entity *e; Entity e;
if(!_free_entity){ if(!_free_entity){
e=malloc(sizeof(Entity)); e=malloc(sizeof(TEntity));
}else{ }else{
e=_free_entity; e=_free_entity;
_free_entity=e->next; _free_entity=e->next;
@@ -30,6 +30,7 @@ Entity *Entity_New(){
e->base=NULL; e->base=NULL;
e->type=0; e->type=0;
vec2_set(e->pos0,0.0f,0.0f);
vec2_set(e->pos,0.0f,0.0f); vec2_set(e->pos,0.0f,0.0f);
e->flags=EntityFlag_Collision|EntityFlag_Overlap; e->flags=EntityFlag_Collision|EntityFlag_Overlap;
e->zorder=1; e->zorder=1;
@@ -75,7 +76,7 @@ Entity *Entity_New(){
// Entity_Destroy // Entity_Destroy
// //
// //
void Entity_Destroy(Entity *e){ void Entity_Destroy(Entity e){
if(e->ondelete){ if(e->ondelete){
e->ondelete(e); e->ondelete(e);
} }
@@ -88,8 +89,8 @@ void Entity_Destroy(Entity *e){
// Entity_Copy // Entity_Copy
// //
// //
Entity *Entity_Copy(Entity *e){ Entity Entity_Copy(Entity e){
Entity *n; Entity n;
n=Entity_New(); n=Entity_New();
@@ -133,6 +134,8 @@ Entity *Entity_Copy(Entity *e){
n->D=e->D; n->D=e->D;
n->child=e->child; n->child=e->child;
Entity_CalcBBox(n);
// Call the copy event // Call the copy event
if(n->oncopy){ if(n->oncopy){
n->oncopy(n); n->oncopy(n);
@@ -142,22 +145,67 @@ Entity *Entity_Copy(Entity *e){
} }
/////////////////////////////
// Entity_CalcBBox
//
//
#define BBox_ExtraMargin 10
#define max(a,b) ((a)>(b)?(a):(b))
void Entity_CalcBBox(Entity e){
float hHeight=(max(e->height,e->radius)/2)+BBox_ExtraMargin;
float hWidth=(max(e->width,e->radius)/2)+BBox_ExtraMargin;
if(e->vel[0]>0){
e->maxX=e->pos[0]+e->vel[0]+hWidth;
e->minX=e->pos[0]-hWidth;
}else{
e->minX=(e->pos[0]+e->vel[0])-hWidth;
e->maxX=e->pos[0]+hWidth;
}
if(e->vel[1]>0){
e->maxY=e->pos[1]+e->vel[1]+hHeight;
e->minY=e->pos[1]-hHeight;
}else{
e->minY=(e->pos[1]+e->vel[1])-hHeight;
e->maxY=e->pos[1]+hHeight;
}
}
/////////////////////////////
// Entity_BBoxIntersect
//
//
int Entity_BBoxIntersect(Entity ent1,Entity ent2){
if( ent1->maxX>=ent2->minX && ent1->minX<=ent2->maxX &&
ent1->maxY>=ent2->minY && ent1->minY<=ent2->maxY )
{
return(1);
}
return(0);
}
///////////////////////////// /////////////////////////////
// Entity_Draw // Entity_Draw
// //
// //
void Entity_Draw(Entity *e,int x,int y){ void Entity_Draw(Entity e,int x,int y,float f){
vec2 fPos;
Draw_SetColor(e->color[0],e->color[1],e->color[2],e->color[3]); Draw_SetColor(e->color[0],e->color[1],e->color[2],e->color[3]);
AnimPlay_Draw(&e->anim,e->pos[0]+x,e->pos[1]+y); if(e->flags&EntityFlag_UpdatedPos){
vec2_interpol(fPos,e->pos0,e->pos,f);
AnimPlay_Draw(&e->anim,fPos[0]+x,fPos[1]+y);
}else{
AnimPlay_Draw(&e->anim,e->pos[0]+x,e->pos[1]+y);
}
} }
///////////////////////////// /////////////////////////////
// Entity_IsVisible // Entity_IsVisible
// //
// //
int Entity_IsVisible(Entity *e,int x,int y,int w,int h){ int Entity_IsVisible(Entity e,int x,int y,int w,int h){
int xmax,xmin; int xmax,xmin;
int ymax,ymin; int ymax,ymin;
int ih,iw; int ih,iw;
@@ -185,7 +233,7 @@ int Entity_IsVisible(Entity *e,int x,int y,int w,int h){
// Entity_Process // Entity_Process
// //
// //
void Entity_Process(Entity *b,int ft){ void Entity_Process(Entity b,int ft){
b->flags&=~EntityFlag_UpdatedPos; b->flags&=~EntityFlag_UpdatedPos;
// Launch method // Launch method
@@ -199,9 +247,11 @@ void Entity_Process(Entity *b,int ft){
// Entity_PostProcess // Entity_PostProcess
// //
// //
void Entity_PostProcess(Entity *e,int ft){ void Entity_PostProcess(Entity e,int ft){
float qlen,len; float qlen,len;
vec2_copy(e->pos0,e->pos);
// Determine if there is movement // Determine if there is movement
qlen=vec2_dot(e->vel,e->vel); qlen=vec2_dot(e->vel,e->vel);
if(qlen>0.0f){ if(qlen>0.0f){
@@ -223,6 +273,8 @@ void Entity_PostProcess(Entity *e,int ft){
// Mark the update of the position. // Mark the update of the position.
vec2_copy(e->oldpos,e->pos); vec2_copy(e->oldpos,e->pos);
e->flags|=EntityFlag_UpdatedPos; e->flags|=EntityFlag_UpdatedPos;
Entity_CalcBBox(e);
} }
// Launch method // Launch method
@@ -236,131 +288,123 @@ void Entity_PostProcess(Entity *e,int ft){
///////////////////////////// /////////////////////////////
// Entity_CollisionResponseClircle // CollisionInfo_New
// //
// Normal response to a collision between circles. //
void Entity_CollisionResponseCircle( CollisionInfo _free_collInfo=NULL;
Entity *b1,Entity *b2,float t,vec2 n) CollisionInfo CollisionInfo_New(int responseType,Entity ent1,Entity ent2,float t,vec2 n,int applyFriction){
{ CollisionInfo collInfo;
float moment;
vec2 temp;
float elast;
if(b1->mass>0.0f && b2->mass>0.0f){ if(!_free_collInfo){
// Calculate elasticity collInfo=malloc(sizeof(TCollisionInfo));
elast=(b1->mass*b1->elast+b2->mass*b2->elast)/
(b1->mass+b2->mass);
// Collision between two massed balls
moment=((1.0f+elast)*b1->mass*b2->mass*
(fabs(vec2_dot(b1->vel,n))+fabs(vec2_dot(b2->vel,n))))
/(b1->mass+b2->mass);
vec2_scale(temp,n,moment/b1->mass);
vec2_minus(b1->vel,b1->vel,temp);
vec2_scale(temp,n,moment/b2->mass);
vec2_plus(b2->vel,b2->vel,temp);
}else
if(b1->mass>0.0f && b2->mass<=0.0f){
// Collision between a massed ball and a fixed ball
moment=(1.0f+b1->elast)*
(vec2_dot(b1->vel,n));
vec2_scale(temp,n,moment);
vec2_minus(b1->vel,b1->vel,temp);
}else
if(b1->mass<=0.0f && b2->mass>0.0f){
// Collision between a massed ball and a fixed ball
// (imposible, but better safe)
moment=(1.0f+b2->elast)*
(vec2_dot(b2->vel,n));
vec2_scale(temp,n,moment);
vec2_plus(b2->vel,b2->vel,temp);
}else{ }else{
// Collision between 2 fixed balls collInfo=_free_collInfo;
// (imposible, but better safe) _free_collInfo=collInfo->next;
vec2_set(b1->vel,0,0);
vec2_set(b2->vel,0,0);
} }
collInfo->next=NULL;
collInfo->responseType=responseType;
collInfo->ent1=ent1;
collInfo->ent2=ent2;
collInfo->t=t;
vec2_copy(collInfo->n,n);
collInfo->applyFriction=applyFriction;
return collInfo;
} }
///////////////////////////// /////////////////////////////
// Entity_CollisionResponseLine // CollisionInfo_Destroy
// //
// Normal response to a collision with a line. //
void Entity_CollisionResponseLine( void CollisionInfo_Destroy(CollisionInfo *collInfoRef){
Entity *ent,Entity *ent2,float t,vec2 norm,int applyFriction) if(collInfoRef==NULL || collInfoRef[0]==NULL){return;}
CollisionInfo collInfo=collInfoRef[0];
CollisionInfo nextCollInfo;
while(collInfo!=NULL){
nextCollInfo=collInfo->next;
collInfo->next=_free_collInfo;
_free_collInfo=collInfo;
collInfo=nextCollInfo;
}
collInfoRef[0]=NULL;
}
/////////////////////////////
// CollisionInfo_Add
//
//
void CollisionInfo_Add(CollisionInfo *collInfoRef,
int responseType,Entity ent1,Entity ent2,float t,vec2 n,int applyFriction)
{ {
vec2 pos2,vel2,velFric,intersection; if(collInfoRef==NULL){return;}
float dist,fric_static,fric_dynamic,fricLen; CollisionInfo prevCollInfo=NULL;
CollisionInfo collInfo=collInfoRef[0];
CollisionInfo newCollInfo=CollisionInfo_New(responseType,ent1,ent2,t,n,applyFriction);
// Calculate friction while(collInfo!=NULL && collInfo->t<t){
fric_static=(ent->fric_static+ent2->fric_static)/2; prevCollInfo=collInfo;
fric_dynamic=(ent->fric_dynamic+ent2->fric_dynamic)/2; collInfo=collInfo->next;
// Calculate end position
vec2_scale(vel2,ent->vel,1.0f-t);
dist=-vec2_dot(norm,vel2);
vec2_plus(pos2,ent->pos,ent->vel);
vec2_scaleadd(pos2,pos2,norm,dist);
// Calculate intersection
vec2_scaleadd(intersection,ent->pos,ent->vel,t);
if(applyFriction){
// Apply friction
vec2_minus(velFric,pos2,intersection);
fricLen=sqrtf(vec2_dot(velFric,velFric));
if(fricLen<fric_static){
// Apply static friction
vec2_copy(pos2,intersection);
}else{
// Apply dynamic friction
if(fricLen>0.0f){
vec2_scaleadd(pos2,intersection,velFric,
1.0f-(fric_dynamic+(fric_static/fricLen)));
}else{
vec2_scaleadd(pos2,intersection,velFric,
1.0f-fric_dynamic);
}
}
} }
if(prevCollInfo==NULL){
// Apply to velocity collInfoRef[0]=newCollInfo;
vec2_scaleadd(pos2,pos2,norm,0.1f); }else{
vec2_minus(ent->vel,pos2,ent->pos); prevCollInfo->next=newCollInfo;
}
newCollInfo->next=collInfo;
} }
///////////////////////////// /////////////////////////////
// Entity_Collide // CollisionInfo_CheckRepetition
// //
// //
int Entity_Collide(Entity *b1,Entity *b2){ int CollisionInfo_CheckRepetition(CollisionInfo collInfo,Entity ent1,Entity ent2)
{
while(collInfo!=NULL){
if((collInfo->ent1==ent1 && collInfo->ent2==ent2) ||
(collInfo->ent1==ent2 && collInfo->ent2==ent1))
{
return(1);
}
collInfo=collInfo->next;
}
return(0);
}
/////////////////////////////
// Entity_CheckCollisions
//
//
int Entity_CheckCollision(Entity ent1,Entity ent2,CollisionInfo *collInfoRef){
float t; float t;
vec2 n,p; vec2 n,p;
vec2 vel; vec2 vel;
int flags=b1->flags|b2->flags; int flags=ent1->flags|ent2->flags;
if(flags&EntityFlag_Platform && !(flags&EntityFlag_Block)){ if(flags&EntityFlag_Platform && !(flags&EntityFlag_Block)){
// One of the entities is a platform and none is a block // One of the entities is a platform and none is a block
Entity *ent,*ent_plat; Entity ent,ent_plat;
float plat_width; float plat_width;
vec2 p; vec2 p;
// Decide who is the platform and who is the ent // Decide who is the platform and who is the ent
if(b1->mass<=0.0f && b2->mass>0.0f){ if(ent1->mass<=0.0f && ent2->mass>0.0f){
ent=b2; ent=ent2;
ent_plat=b1; ent_plat=ent1;
}else }else
if(b2->mass<=0.0f && b1->mass>0.0f){ if(ent2->mass<=0.0f && ent1->mass>0.0f){
ent=b1; ent=ent1;
ent_plat=b2; ent_plat=ent2;
}else{ }else{
// Two static or two dinamic entities?!? // Two static or two dinamic entities?!?
return(0); return(0);
} }
// Check Top // Check Top
vec2_set(n,0,-1); vec2_set(n,0,-1);
vec2_scaleadd(p,ent_plat->pos,n,(ent->height+ent_plat->height)/2); vec2_scaleadd(p,ent_plat->pos,n,(ent->height+ent_plat->height)/2);
@@ -368,36 +412,10 @@ int Entity_Collide(Entity *b1,Entity *b2){
if(Intersect_RayEdge(ent->pos,ent->vel, if(Intersect_RayEdge(ent->pos,ent->vel,
n,p,plat_width,&t)) n,p,plat_width,&t))
{ {
int response=1; // Keep colision info
int rc; CollisionInfo_Add(collInfoRef,
CollisionResponse_Line,ent,ent_plat,t,n,1);
// Check the collision methods return(1);
if(ent->collision){
rc=ent->collision(ent,ent_plat,t,n);
if (rc==0)
response=0;
if (rc>1)
response=2;
}
if(ent_plat->collision){
vec2 n2;
vec2_scale(n2,n,-1.0f);
rc=ent_plat->collision(ent_plat,ent,t,n2);
if (rc==0)
response=0;
if (rc>1)
response=2;
}
// Collision response
if(response==1){
Entity_CollisionResponseLine(ent,ent_plat,t,n,1);
return(1);
}
if (response==2) {
return(1);
}
return(0);
} }
return(0); return(0);
@@ -405,19 +423,19 @@ int Entity_Collide(Entity *b1,Entity *b2){
if(flags&EntityFlag_Block && !(flags&EntityFlag_Platform)){ if(flags&EntityFlag_Block && !(flags&EntityFlag_Platform)){
// One of the entities is a block and none is a platform // One of the entities is a block and none is a platform
Entity *ent,*ent_block; Entity ent,ent_block;
float auxT,block_len; float auxT,block_len;
vec2 auxN,p; vec2 auxN,p;
int applyFriction; int applyFriction;
// Decide who is the block and who is the ent // Decide who is the platform and who is the ent
if(b1->mass<=0.0f && b2->mass>0.0f){ if(ent1->mass<=0.0f && ent2->mass>0.0f){
ent=b2; ent=ent2;
ent_block=b1; ent_block=ent1;
}else }else
if(b2->mass<=0.0f && b1->mass>0.0f){ if(ent2->mass<=0.0f && ent1->mass>0.0f){
ent=b1; ent=ent1;
ent_block=b2; ent_block=ent2;
}else{ }else{
// Two static or two dinamic entities?!? // Two static or two dinamic entities?!?
return(0); return(0);
@@ -484,61 +502,153 @@ int Entity_Collide(Entity *b1,Entity *b2){
} }
if(t<1.0f){ if(t<1.0f){
// Handle colision // Keep colision info
int response=1; CollisionInfo_Add(collInfoRef,
int rc; CollisionResponse_Line,ent,ent_block,t,n,applyFriction);
return(1);
// Check the collision methods
if(ent->collision){
rc=ent->collision(ent,ent_block,t,n);
if (rc==0)
response=0;
if (rc>1)
response=2;
}
if(ent_block->collision){
vec2 n2;
vec2_scale(n2,n,-1.0f);
rc=ent_block->collision(ent_block,ent,t,n2);
if (rc==0)
response=0;
if (rc>1)
response=2;
}
// Collision response
if(response==1){
Entity_CollisionResponseLine(ent,ent_block,t,n,applyFriction);
return(1);
}
if (response==2) {
return(1);
}
return(0);
} }
return(0); return(0);
} }
// Test relative to ent1
vec2_minus(vel,ent1->vel,ent2->vel);
if(Colision_CircleCircle(ent1->pos,ent1->radius,vel,ent2->pos,ent2->radius,&t,n)){
// Keep colision info
CollisionInfo_Add(collInfoRef,
CollisionResponse_Circle,ent1,ent2,t,n,0);
return(1);
}
return(0);
}
// Test relative to b1
vec2_minus(vel,b1->vel,b2->vel); /////////////////////////////
if(Colision_CircleCircle(b1->pos,b1->radius,vel,b2->pos,b2->radius,&t,n)){ // Entity_CollisionResponseCircle
//
// Normal response to a collision between circles.
void Entity_CollisionResponseCircle(
Entity b1,Entity b2,float t,vec2 n)
{
float moment;
vec2 temp;
float elast;
if(b1->mass>0.0f && b2->mass>0.0f){
// Calculate elasticity
elast=(b1->mass*b1->elast+b2->mass*b2->elast)/
(b1->mass+b2->mass);
// Collision between two massed balls
moment=((1.0f+elast)*b1->mass*b2->mass*
(fabs(vec2_dot(b1->vel,n))+fabs(vec2_dot(b2->vel,n))))
/(b1->mass+b2->mass);
vec2_scale(temp,n,moment/b1->mass);
vec2_minus(b1->vel,b1->vel,temp);
Entity_CalcBBox(b1);
vec2_scale(temp,n,moment/b2->mass);
vec2_plus(b2->vel,b2->vel,temp);
Entity_CalcBBox(b2);
}else
if(b1->mass>0.0f && b2->mass<=0.0f){
// Collision between a massed ball and a fixed ball
moment=(1.0f+b1->elast)*
(vec2_dot(b1->vel,n));
vec2_scale(temp,n,moment);
vec2_minus(b1->vel,b1->vel,temp);
Entity_CalcBBox(b1);
}else
if(b1->mass<=0.0f && b2->mass>0.0f){
// Collision between a massed ball and a fixed ball
// (imposible, but better safe)
moment=(1.0f+b2->elast)*
(vec2_dot(b2->vel,n));
vec2_scale(temp,n,moment);
vec2_plus(b2->vel,b2->vel,temp);
Entity_CalcBBox(b2);
}else{
// Collision between 2 fixed balls
// (imposible, but better safe)
vec2_set(b1->vel,0,0);
Entity_CalcBBox(b1);
vec2_set(b2->vel,0,0);
Entity_CalcBBox(b2);
}
}
/////////////////////////////
// Entity_CollisionResponseLine
//
// Normal response to a collision with a line.
void Entity_CollisionResponseLine(
Entity ent,Entity ent2,float t,vec2 norm,int applyFriction)
{
vec2 pos2,vel2,velFric,intersection;
float dist,fric_static,fric_dynamic,fricLen;
// Calculate friction
fric_static=(ent->fric_static+ent2->fric_static)/2;
fric_dynamic=(ent->fric_dynamic+ent2->fric_dynamic)/2;
// Calculate end position
vec2_scale(vel2,ent->vel,1.0f-t);
dist=-vec2_dot(norm,vel2);
vec2_plus(pos2,ent->pos,ent->vel);
vec2_scaleadd(pos2,pos2,norm,dist);
// Calculate intersection
vec2_scaleadd(intersection,ent->pos,ent->vel,t);
if(applyFriction){
// Apply friction
vec2_minus(velFric,pos2,intersection);
fricLen=sqrtf(vec2_dot(velFric,velFric));
if(fricLen<fric_static){
// Apply static friction
vec2_copy(pos2,intersection);
}else{
// Apply dynamic friction
if(fricLen>0.0f){
vec2_scaleadd(pos2,intersection,velFric,
1.0f-(fric_dynamic+(fric_static/fricLen)));
}else{
vec2_scaleadd(pos2,intersection,velFric,
1.0f-fric_dynamic);
}
}
}
// Apply to velocity
vec2_scaleadd(pos2,pos2,norm,0.1f);
vec2_minus(ent->vel,pos2,ent->pos);
Entity_CalcBBox(ent);
}
/////////////////////////////
// Entity_CollisionInfoResponse
//
//
int Entity_CollisionInfoResponse(CollisionInfo collInfo){
while(collInfo!=NULL){
// Handle colision
int response=1; int response=1;
int rc; int rc;
vec2 n2; vec2 n2;
vec2_scale(n2,n,-1.0f); vec2_scale(n2,collInfo->n,-1.0f);
// Check the collision methods // Check the collision methods
if(b1->collision){ if(collInfo->ent1->collision){
rc=b1->collision(b1,b2,t,n2); rc=collInfo->ent1->collision(collInfo->ent1,collInfo->ent2,collInfo->t,collInfo->n);
if (rc==0) if (rc==0)
response=0; response=0;
if (rc>1) if (rc>1)
response=2; response=2;
} }
if(b2->collision){ if(collInfo->ent2->collision){
rc=b2->collision(b2,b1,t,n); rc=collInfo->ent2->collision(collInfo->ent2,collInfo->ent1,collInfo->t,n2);
if (rc==0) if (rc==0)
response=0; response=0;
if (rc>1) if (rc>1)
@@ -547,17 +657,26 @@ int Entity_Collide(Entity *b1,Entity *b2){
// Collision response // Collision response
if(response==1){ if(response==1){
if(vec2_dot(b1->vel,b1->vel)>vec2_dot(b2->vel,b2->vel)){ if(collInfo->responseType==CollisionResponse_Line){
Entity_CollisionResponseCircle(b1,b2,t,n); Entity_CollisionResponseLine(
}else{ collInfo->ent1,collInfo->ent2,collInfo->t,collInfo->n,collInfo->applyFriction);
Entity_CollisionResponseCircle(b2,b1,t,n); }else
if(collInfo->responseType==CollisionResponse_Circle){
if(vec2_dot(collInfo->ent1->vel,collInfo->ent1->vel)>
vec2_dot(collInfo->ent2->vel,collInfo->ent2->vel))
{
Entity_CollisionResponseCircle(collInfo->ent1,collInfo->ent2,collInfo->t,n2);
}else{
Entity_CollisionResponseCircle(collInfo->ent2,collInfo->ent1,collInfo->t,collInfo->n);
}
} }
return(1); return(1);
} }
if (response==2) { if (response==2) {
return(1); return(1);
} }
return(0);
collInfo=collInfo->next;
} }
return(0); return(0);
} }
@@ -567,7 +686,7 @@ int Entity_Collide(Entity *b1,Entity *b2){
// Entity_Overlaps // Entity_Overlaps
// //
// //
void Entity_Overlaps(Entity *b1,Entity *b2){ void Entity_Overlaps(Entity b1,Entity b2){
vec2 len; vec2 len;
vec2_minus(len,b1->pos,b2->pos); vec2_minus(len,b1->pos,b2->pos);
@@ -594,7 +713,7 @@ void Entity_Overlaps(Entity *b1,Entity *b2){
// Entity_GetPos // Entity_GetPos
// //
// //
void Entity_GetPos(Entity *e,vec2 pos){ void Entity_GetPos(Entity e,vec2 pos){
vec2_copy(pos,e->pos); vec2_copy(pos,e->pos);
} }
@@ -602,7 +721,7 @@ void Entity_GetPos(Entity *e,vec2 pos){
// Entity_UpdatePos // Entity_UpdatePos
// //
// //
void Entity_UpdatePos(Entity *e,vec2 pos){ void Entity_UpdatePos(Entity e,vec2 pos){
// Mark the update of the position. // Mark the update of the position.
vec2_copy(e->oldpos,e->pos); vec2_copy(e->oldpos,e->pos);
@@ -615,7 +734,7 @@ void Entity_UpdatePos(Entity *e,vec2 pos){
// Entity_AddVelLimit // Entity_AddVelLimit
// //
// //
void Entity_AddVelLimit(Entity *e,vec2 vel,float limit){ void Entity_AddVelLimit(Entity e,vec2 vel,float limit){
float vlen_orig,vlen; float vlen_orig,vlen;
vec2 dir,vel_temp; vec2 dir,vel_temp;
@@ -633,6 +752,7 @@ void Entity_AddVelLimit(Entity *e,vec2 vel,float limit){
vec2_scale(vel_temp,dir,vlen); vec2_scale(vel_temp,dir,vlen);
vec2_plus(e->vel,e->vel,vel_temp); vec2_plus(e->vel,e->vel,vel_temp);
} }
Entity_CalcBBox(e);
} }
@@ -640,7 +760,7 @@ void Entity_AddVelLimit(Entity *e,vec2 vel,float limit){
// Entity_SetColor // Entity_SetColor
// //
// //
void Entity_SetColor(Entity *e,float r,float g,float b,float a){ void Entity_SetColor(Entity e,float r,float g,float b,float a){
e->color[0]=r; e->color[0]=r;
e->color[1]=g; e->color[1]=g;
e->color[2]=b; e->color[2]=b;
@@ -652,7 +772,7 @@ void Entity_SetColor(Entity *e,float r,float g,float b,float a){
// Entity_AddColor // Entity_AddColor
// //
// //
void Entity_AddColor(Entity *e,float r,float g,float b,float a){ void Entity_AddColor(Entity e,float r,float g,float b,float a){
e->color[0]+=r; e->color[0]+=r;
if(e->color[0]>1.0f) if(e->color[0]>1.0f)
e->color[0]=1.0f; e->color[0]=1.0f;
@@ -672,7 +792,7 @@ void Entity_AddColor(Entity *e,float r,float g,float b,float a){
// Entity_SetLight // Entity_SetLight
// //
// //
void Entity_SetLight(Entity *e,float r,float g,float b,float rad){ void Entity_SetLight(Entity e,float r,float g,float b,float rad){
e->light[0]=r; e->light[0]=r;
e->light[1]=g; e->light[1]=g;
e->light[2]=b; e->light[2]=b;
@@ -685,7 +805,7 @@ void Entity_SetLight(Entity *e,float r,float g,float b,float rad){
// Entity_Iluminate // Entity_Iluminate
// //
// //
void Entity_Iluminate(Entity *e,Entity **elist,int n){ void Entity_Iluminate(Entity e,Entity *elist,int n){
int i; int i;
vec2 vdist; vec2 vdist;
float qdist,f; float qdist,f;
@@ -725,7 +845,7 @@ void Entity_Iluminate(Entity *e,Entity **elist,int n){
// Entity_MarkUpdateLight // Entity_MarkUpdateLight
// //
// //
void Entity_MarkUpdateLight(Entity *e,Entity **elist,int n){ void Entity_MarkUpdateLight(Entity e,Entity *elist,int n){
if(e->flags&EntityFlag_Light){ if(e->flags&EntityFlag_Light){
int i; int i;
vec2 max,min; vec2 max,min;

163
GameLib/Entity.h
View File

@@ -1,4 +1,4 @@
// Copyright (C) 2011 Valeriano Alfonso Rodriguez (Kableado) // Copyright (C) 2011-2014 Valeriano Alfonso Rodriguez (Kableado)
#ifndef _ENTITY_H_ #ifndef _ENTITY_H_
#define _ENTITY_H_ #define _ENTITY_H_
@@ -9,8 +9,7 @@
//////////////////////////////////////////////// ////////////////////////////////////////////////
// Entity // // Entity
////////////
// //
#define EntityFlag_Collision 1 #define EntityFlag_Collision 1
#define EntityFlag_Platform 2 #define EntityFlag_Platform 2
@@ -21,11 +20,13 @@
#define EntityFlag_Light 16 #define EntityFlag_Light 16
#define EntityFlag_UpdateLight 32 #define EntityFlag_UpdateLight 32
#define EntityFlag_UpdatedPos 64 #define EntityFlag_UpdatedPos 64
typedef struct Tag_Entity { typedef struct TEntity TEntity, *Entity;
struct Tag_Entity *base; struct TEntity {
Entity base;
int type; int type;
vec2 oldpos; vec2 oldpos;
vec2 pos0;
vec2 pos; vec2 pos;
int flags; int flags;
int zorder; int zorder;
@@ -49,72 +50,134 @@ typedef struct Tag_Entity {
float color[4]; float color[4];
float light[4]; float light[4];
void (*oncopy)(struct Tag_Entity *ent); void (*oncopy)(Entity ent);
void (*ondelete)(struct Tag_Entity *ent); void (*ondelete)(Entity ent);
void (*proc)(struct Tag_Entity *ent,int ft); void (*proc)(Entity ent,int ft);
void (*postproc)(struct Tag_Entity *ent,int ft); void (*postproc)(Entity ent,int ft);
int (*collision)( int (*collision)(Entity ent, Entity ent2, float t,vec2 n);
struct Tag_Entity *ent, void (*overlap)(Entity ent, Entity ent2);
struct Tag_Entity *ent2,
float t,vec2 n);
void (*overlap)(
struct Tag_Entity *ent,
struct Tag_Entity *ent2);
int A; int A;
int B; int B;
int C; int C;
int D; int D;
struct Tag_Entity *child; Entity child;
void *next; float maxX,minX;
} Entity; float maxY,minY;
Entity next;
};
///////////////////////////// /////////////////////////////
// Entity_New // Entity_New
// //
// Entity Entity_New();
Entity *Entity_New();
///////////////////////////// /////////////////////////////
// Entity_Destroy // Entity_Destroy
// //
// void Entity_Destroy(Entity e);
void Entity_Destroy(Entity *e);
///////////////////////////// /////////////////////////////
// Entity_Copy // Entity_Copy
// //
Entity Entity_Copy(Entity e);
/////////////////////////////
// Entity_CalcBBox
// //
Entity *Entity_Copy(Entity *e); //
void Entity_CalcBBox(Entity e);
/////////////////////////////
// Entity_BBoxIntersect
//
//
int Entity_BBoxIntersect(Entity ent1,Entity ent2);
///////////////////////////// /////////////////////////////
// Entity_Draw // Entity_Draw
// //
// void Entity_Draw(Entity e,int x,int y,float f);
void Entity_Draw(Entity *e,int x,int y);
///////////////////////////// /////////////////////////////
// Entity_IsVisible // Entity_IsVisible
// //
// int Entity_IsVisible(Entity e,int x,int y,int w,int h);
int Entity_IsVisible(Entity *e,int x,int y,int w,int h);
///////////////////////////// /////////////////////////////
// Entity_Process // Entity_Process
// //
// void Entity_Process(Entity e,int ft);
void Entity_Process(Entity *e,int ft);
///////////////////////////// /////////////////////////////
// Entity_PostProcess // Entity_PostProcess
// //
void Entity_PostProcess(Entity e,int ft);
////////////////////////////////////////////////
// CollisionInfo
// //
void Entity_PostProcess(Entity *e,int ft); #define CollisionResponse_Circle 1
#define CollisionResponse_Line 2
typedef struct TCollisionInfo TCollisionInfo,*CollisionInfo;
struct TCollisionInfo {
int responseType;
Entity ent1;
Entity ent2;
float t;
vec2 n;
int applyFriction;
CollisionInfo next;
};
/////////////////////////////
// CollisionInfo_New
//
//
CollisionInfo CollisionInfo_New(int responseType,Entity ent1,Entity ent2,float t,vec2 n,int applyFriction);
/////////////////////////////
// CollisionInfo_Destroy
//
//
void CollisionInfo_Destroy(CollisionInfo *collInfoRef);
/////////////////////////////
// CollisionInfo_Add
//
//
void CollisionInfo_Add(CollisionInfo *collInfo,
int responseType,Entity ent1,Entity ent2,float t,vec2 n,int applyFriction);
/////////////////////////////
// CollisionInfo_CheckRepetition
//
//
int CollisionInfo_CheckRepetition(CollisionInfo collInfo,Entity ent1,Entity ent2);
/////////////////////////////
// Entity_CheckCollision
//
//
int Entity_CheckCollision(Entity ent1,Entity ent2,CollisionInfo *collInfoRef);
///////////////////////////// /////////////////////////////
@@ -122,7 +185,7 @@ void Entity_PostProcess(Entity *e,int ft);
// //
// Normal response to a collision of spheres. // Normal response to a collision of spheres.
void Entity_CollisionResponseCircle( void Entity_CollisionResponseCircle(
Entity *b1,Entity *b2,float t,vec2 n); Entity b1,Entity b2,float t,vec2 n);
///////////////////////////// /////////////////////////////
@@ -130,75 +193,69 @@ void Entity_CollisionResponseCircle(
// //
// Normal response to a collision with a line. // Normal response to a collision with a line.
void Entity_CollisionResponseLine( void Entity_CollisionResponseLine(
Entity *ent,Entity *ent2,float t,vec2 n,int applyFriction); Entity ent,Entity ent2,float t,vec2 n,int applyFriction);
///////////////////////////// /////////////////////////////
// Entity_Collide // Entity_CollisionInfoResponse
// //
// //
int Entity_Collide(Entity *b1,Entity *b2); int Entity_CollisionInfoResponse(CollisionInfo collInfo);
///////////////////////////// /////////////////////////////
// Entity_Overlaps // Entity_Overlaps
// //
// void Entity_Overlaps(Entity b1,Entity b2);
void Entity_Overlaps(Entity *b1,Entity *b2);
///////////////////////////// /////////////////////////////
// Entity_GetPos // Entity_GetPos
// //
// void Entity_GetPos(Entity e,vec2 pos);
void Entity_GetPos(Entity *e,vec2 pos);
///////////////////////////// /////////////////////////////
// Entity_UpdatePos // Entity_UpdatePos
// //
// void Entity_UpdatePos(Entity e,vec2 pos);
void Entity_UpdatePos(Entity *e,vec2 pos);
///////////////////////////// /////////////////////////////
// Entity_AddVelLimit // Entity_AddVelLimit
// //
// void Entity_AddVelLimit(Entity e,vec2 vel,float limit);
void Entity_AddVelLimit(Entity *e,vec2 vel,float limit);
///////////////////////////// /////////////////////////////
// Entity_SetColor // Entity_SetColor
// //
// void Entity_SetColor(Entity e,float r,float g,float b,float a);
void Entity_SetColor(Entity *e,float r,float g,float b,float a);
///////////////////////////// /////////////////////////////
// Entity_AddColor // Entity_AddColor
// //
// void Entity_AddColor(Entity e,float r,float g,float b,float a);
void Entity_AddColor(Entity *e,float r,float g,float b,float a);
///////////////////////////// /////////////////////////////
// Entity_AddColor // Entity_AddColor
// //
// void Entity_SetLight(Entity e,float r,float g,float b,float rad);
void Entity_SetLight(Entity *e,float r,float g,float b,float rad);
///////////////////////////// /////////////////////////////
// Entity_AddColor // Entity_AddColor
// //
// void Entity_Iluminate(Entity e,Entity *elist,int n);
void Entity_Iluminate(Entity *e,Entity **elist,int n);
///////////////////////////// /////////////////////////////
// Entity_MarkUpdateLight // Entity_MarkUpdateLight
// //
// void Entity_MarkUpdateLight(Entity e,Entity *elist,int n);
void Entity_MarkUpdateLight(Entity *e,Entity **elist,int n);
#endif #endif

148
GameLib/GameLib.c
View File

@@ -1,6 +1,9 @@
// Copyright (C) 2011 Valeriano Alfonso Rodriguez (Kableado) // Copyright (C) 2011 Valeriano Alfonso Rodriguez (Kableado)
#include <math.h> #include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <SDL/SDL.h> #include <SDL/SDL.h>
#include "Time.h" #include "Time.h"
@@ -15,7 +18,7 @@
// Globals // Globals
int _running; int _running;
Entity **_entity=NULL; Entity *_entity=NULL;
int *_entity_flag=NULL; int *_entity_flag=NULL;
int _n_entities=0; int _n_entities=0;
int _n_entities_res=0; int _n_entities_res=0;
@@ -23,11 +26,12 @@ int _entities_lock=0;
int _entities_compactate=0; int _entities_compactate=0;
void (*_gameproc)()=NULL; void (*_gameproc)()=NULL;
void (*_gamepostproc)()=NULL; void (*_gamepostproc)()=NULL;
void (*_gamepredraw)()=NULL; void (*_gamepredraw)(float f)=NULL;
void (*_gamedraw)()=NULL; void (*_gamedraw)(float f)=NULL;
int _ft; int _ft;
int _game_size[2]; int _game_size[2];
int _game_pos[2]; int _game_pos0[2];
int _game_pos1[2];
long long t_proc; long long t_proc;
long long t_col; long long t_col;
@@ -55,8 +59,10 @@ int GameLib_Init(int w,int h,char *title,int pfps,int fps){
_game_size[0]=w; _game_size[0]=w;
_game_size[1]=h; _game_size[1]=h;
_game_pos[0]=0; _game_pos0[0]=0;
_game_pos[1]=0; _game_pos0[1]=0;
_game_pos1[0]=0;
_game_pos1[1]=0;
_ft=1000/fps; _ft=1000/fps;
@@ -68,9 +74,9 @@ int GameLib_Init(int w,int h,char *title,int pfps,int fps){
// GameLib_AddEntity // GameLib_AddEntity
// //
// Adds an entity to the game. // Adds an entity to the game.
void GameLib_AddEntity(Entity *e){ void GameLib_AddEntity(Entity e){
if(_n_entities>=_n_entities_res){ if(_n_entities>=_n_entities_res){
Entity **entity_aux; Entity *entity_aux;
int *entity_flag_aux; int *entity_flag_aux;
int i; int i;
@@ -79,7 +85,7 @@ void GameLib_AddEntity(Entity *e){
_n_entities_res=32; _n_entities_res=32;
else else
_n_entities_res*=2; _n_entities_res*=2;
entity_aux=malloc(sizeof(Entity *)*_n_entities_res); entity_aux=malloc(sizeof(Entity)*_n_entities_res);
entity_flag_aux=malloc(sizeof(int)*_n_entities_res); entity_flag_aux=malloc(sizeof(int)*_n_entities_res);
for(i=0;i<_n_entities;i++){ for(i=0;i<_n_entities;i++){
entity_aux[i]=_entity[i]; entity_aux[i]=_entity[i];
@@ -107,7 +113,7 @@ void GameLib_AddEntity(Entity *e){
// GameLib_UnrefEntity // GameLib_UnrefEntity
// //
// removes the reference to the entity. // removes the reference to the entity.
int GameLib_UnrefEntity(Entity *e){ int GameLib_UnrefEntity(Entity e){
int i; int i;
for(i=0;i<_n_entities;i++){ for(i=0;i<_n_entities;i++){
if(e==_entity[i]){ if(e==_entity[i]){
@@ -133,7 +139,7 @@ int GameLib_UnrefEntity(Entity *e){
// GameLib_DelEntity // GameLib_DelEntity
// //
// Adds an entity to the game. // Adds an entity to the game.
int GameLib_DelEntity(Entity *e){ int GameLib_DelEntity(Entity e){
int i; int i;
if((i=GameLib_UnrefEntity(e))==-1){ if((i=GameLib_UnrefEntity(e))==-1){
return(0); return(0);
@@ -177,6 +183,7 @@ void GameLib_Compactate(){
_entities_lock=0; _entities_lock=0;
} }
///////////////////////////// /////////////////////////////
// GameLib_ProcLoop // GameLib_ProcLoop
// //
@@ -186,6 +193,9 @@ int GameLib_ProcLoop(){
int repeat,count; int repeat,count;
long long time; long long time;
// Step the gamePosition
_game_pos0[0]=_game_pos1[0];
_game_pos0[0]=_game_pos1[0];
// Process // Process
time=Time_GetTime(); time=Time_GetTime();
@@ -201,26 +211,38 @@ int GameLib_ProcLoop(){
GameLib_Compactate(); GameLib_Compactate();
t_proc+=Time_GetTime()-time; t_proc+=Time_GetTime()-time;
// Colisions between entities // Colisions between entities
time=Time_GetTime(); time=Time_GetTime();
GameLib_Compactate();_entities_lock=1; GameLib_Compactate();_entities_lock=1;
count=0; count=0;
do{ do{
repeat=0; repeat=0;
CollisionInfo collInfo=NULL;
for(i=0;i<_n_entities;i++){ for(i=0;i<_n_entities;i++){
if(!(_entity[i]->flags&EntityFlag_Collision) || _entity[i]->mass<0.0f) if(!(_entity[i]->flags&EntityFlag_Collision) || _entity[i]->mass<0.0f)
continue; continue;
if(_entity[i]->vel[0]<=0.0f && _entity[i]->vel[0]>=-0.0f &&
_entity[i]->vel[1]<=0.0f && _entity[i]->vel[1]>=-0.0f)
{
continue;
}
for(j=0;j<_n_entities;j++){ for(j=0;j<_n_entities;j++){
if(!(_entity[j]->flags&EntityFlag_Collision) || i==j) if(!(_entity[j]->flags&EntityFlag_Collision) ||
!Entity_BBoxIntersect(_entity[i],_entity[j]) ||
CollisionInfo_CheckRepetition(collInfo,_entity[i],_entity[j]))
{
continue; continue;
if(Entity_Collide(_entity[i],_entity[j])){
repeat=1;
} }
Entity_CheckCollision(_entity[i],_entity[j],&collInfo);
} }
} }
if(Entity_CollisionInfoResponse(collInfo)){
repeat=1;
}
CollisionInfo_Destroy(&collInfo);
count++; count++;
}while(repeat && count<10); }while(repeat && count<50);
// Stop remaining collisions // Stop remaining collisions
if(count==10){ if(count==10){
for(i=0;i<_n_entities;i++){ for(i=0;i<_n_entities;i++){
@@ -229,9 +251,11 @@ int GameLib_ProcLoop(){
for(j=0;j<_n_entities;j++){ for(j=0;j<_n_entities;j++){
if(!(_entity[j]->flags&EntityFlag_Collision) || i==j) if(!(_entity[j]->flags&EntityFlag_Collision) || i==j)
continue; continue;
if(Entity_Collide(_entity[i],_entity[j])){ if(Entity_CheckCollision(_entity[i],_entity[j],NULL)){
vec2_set(_entity[i]->vel,0,0); vec2_set(_entity[i]->vel,0,0);
Entity_CalcBBox(_entity[i]);
vec2_set(_entity[j]->vel,0,0); vec2_set(_entity[j]->vel,0,0);
Entity_CalcBBox(_entity[j]);
} }
} }
} }
@@ -274,7 +298,7 @@ int GameLib_ProcLoop(){
} }
} }
if(swap){ if(swap){
Entity *ent; Entity ent;
ent=_entity[i]; ent=_entity[i];
_entity[i]=_entity[i-1]; _entity[i]=_entity[i-1];
_entity[i-1]=ent; _entity[i-1]=ent;
@@ -284,7 +308,6 @@ int GameLib_ProcLoop(){
n=n2; n=n2;
}while(n>0); }while(n>0);
// PostProcess // PostProcess
time=Time_GetTime(); time=Time_GetTime();
GameLib_Compactate();_entities_lock=1; GameLib_Compactate();_entities_lock=1;
@@ -310,20 +333,19 @@ int GameLib_ProcLoop(){
// GameLib_DrawLoop // GameLib_DrawLoop
// //
// //
void GameLib_DrawLoop(){ void GameLib_DrawLoop(float f){
long long time; long long time;
int i; int i;
int game_pos[2];
game_pos[0]=_game_pos0[0]+f*(_game_pos1[0]-_game_pos0[0]);
game_pos[1]=_game_pos0[1]+f*(_game_pos1[1]-_game_pos0[1]);
time=Time_GetTime(); time=Time_GetTime();
// Update Lights
//GameLib_UpdateIlumination();
// Predibujado // Predibujado
if(_gamepredraw){ if(_gamepredraw){
_gamepredraw(); _gamepredraw(f);
}else{ }else{
// Limpiar pantalla // Limpiar pantalla
Draw_Clean(0,0,0); Draw_Clean(0,0,0);
@@ -332,11 +354,11 @@ void GameLib_DrawLoop(){
// Draw entities // Draw entities
GameLib_Compactate();_entities_lock=1; GameLib_Compactate();_entities_lock=1;
for(i=0;i<_n_entities;i++){ for(i=0;i<_n_entities;i++){
Entity *e=_entity[i]; Entity e=_entity[i];
// Check visivility // Check visivility
if(!Entity_IsVisible(e, if(!Entity_IsVisible(e,
_game_pos[0],_game_pos[1], game_pos[0],game_pos[1],
_game_size[0],_game_size[1])) _game_size[0],_game_size[1]))
{ {
continue; continue;
@@ -348,18 +370,37 @@ void GameLib_DrawLoop(){
e->flags&=~EntityFlag_UpdateLight; e->flags&=~EntityFlag_UpdateLight;
} }
Entity_Draw(e,-_game_pos[0],-_game_pos[1]); Entity_Draw(e,-game_pos[0],-game_pos[1],f);
} }
Draw_SetColor(1,1,1,1); Draw_SetColor(1,1,1,1);
if(_gamedraw){ if(_gamedraw){
_gamedraw(); _gamedraw(f);
} }
GameLib_Compactate(); GameLib_Compactate();
t_draw+=Time_GetTime()-time; t_draw+=Time_GetTime()-time;
fdraw_count++; fdraw_count++;
if(Input_GetKey(InputKey_DumpProfiling)==InputKey_Pressed){
printf("Profiling:::::::::\n");
if(fproc_count>0){
printf("t_proc.....:%6lld\n",t_proc/fproc_count);
printf("t_col......:%6lld\n",t_col/fproc_count);
printf("t_over.....:%6lld\n",t_over/fproc_count);
printf("t_postproc.:%6lld\n",t_postproc/fproc_count);
}
if(fdraw_count>0){
printf("t_draw.....:%6lld\n",t_draw/fdraw_count);
}
t_proc=0;
t_col=0;
t_over=0;
t_postproc=0;
t_draw=0;
fproc_count=0;
fdraw_count=0;
}
} }
@@ -370,8 +411,8 @@ void GameLib_DrawLoop(){
void GameLib_Loop( void GameLib_Loop(
void (*gameproc)(), void (*gameproc)(),
void (*gamepostproc)(), void (*gamepostproc)(),
void (*gamepredraw)(), void (*gamepredraw)(float f),
void (*gamedraw)()) void (*gamedraw)(float f))
{ {
_running=1; _running=1;
@@ -387,15 +428,6 @@ void GameLib_Loop(
fproc_count=0; fproc_count=0;
fdraw_count=0; fdraw_count=0;
Draw_Loop(GameLib_ProcLoop,GameLib_DrawLoop); Draw_Loop(GameLib_ProcLoop,GameLib_DrawLoop);
if (gamelib_debug) {
printf("Profiling:::::::::\n");
printf("t_proc.....:%6lld\n",t_proc/fproc_count);
printf("t_col......:%6lld\n",t_col/fproc_count);
printf("t_over.....:%6lld\n",t_over/fproc_count);
printf("t_postproc.:%6lld\n",t_postproc/fproc_count);
printf("t_draw.....:%6lld\n",t_draw/fdraw_count);
}
} }
@@ -411,16 +443,23 @@ void GameLib_BreakLoop(){
///////////////////////////// /////////////////////////////
// GameLib_GetPos // GameLib_GetPos
// GameLib_SetPos // GameLib_SetPos
// GameLib_UpdatePos
// GameLib_SetPos // GameLib_SetPos
// //
// //
void GameLib_GetPos(int pos[2]){ void GameLib_GetPos(int pos[2]){
pos[0]=_game_pos[0]; pos[0]=_game_pos1[0];
pos[1]=_game_pos[1]; pos[1]=_game_pos1[1];
} }
void GameLib_SetPos(int pos[2]){ void GameLib_SetPos(int pos[2]){
_game_pos[0]=pos[0]; _game_pos0[0]=pos[0];
_game_pos[1]=pos[1]; _game_pos0[1]=pos[1];
_game_pos1[0]=pos[0];
_game_pos1[1]=pos[1];
}
void GameLib_UpdatePos(int pos[2]){
_game_pos1[0]=pos[0];
_game_pos1[1]=pos[1];
} }
void GameLib_GetSize(int size[2]){ void GameLib_GetSize(int size[2]){
size[0]=_game_size[0]; size[0]=_game_size[0];
@@ -441,10 +480,10 @@ void GameLib_MoveToPos(vec2 pos,float f){
GameLib_MoveToPosV(pos,f); GameLib_MoveToPosV(pos,f);
} }
void GameLib_MoveToPosH(vec2 pos,float f){ void GameLib_MoveToPosH(vec2 pos,float f){
_game_pos[0]=_game_pos[0]+(pos[0]-(_game_pos[0]+(_game_size[0]/2.0f)))*f; _game_pos1[0]=_game_pos1[0]+(pos[0]-(_game_pos1[0]+(_game_size[0]/2.0f)))*f;
} }
void GameLib_MoveToPosV(vec2 pos,float f){ void GameLib_MoveToPosV(vec2 pos,float f){
_game_pos[1]=_game_pos[1]+(pos[1]-(_game_pos[1]+(_game_size[1]/2.0f)))*f; _game_pos1[1]=_game_pos1[1]+(pos[1]-(_game_pos1[1]+(_game_size[1]/2.0f)))*f;
} }
@@ -470,7 +509,7 @@ void GameLib_DelEnts(){
// GameLib_ForEachEn // GameLib_ForEachEn
// //
// Iterates every entity. // Iterates every entity.
void GameLib_ForEachEnt(int (*func)(Entity *ent)){ void GameLib_ForEachEnt(int (*func)(Entity ent)){
int i; int i;
for(i=0;i<_n_entities;i++){ for(i=0;i<_n_entities;i++){
if(!_entity[i]) if(!_entity[i])
@@ -486,9 +525,9 @@ void GameLib_ForEachEnt(int (*func)(Entity *ent)){
// GameLib_SearchEnt // GameLib_SearchEnt
// //
// Searches throught the entities. // Searches throught the entities.
Entity *GameLib_SearchEnt(int (*func)(Entity *ent,void *d),void *d){ Entity GameLib_SearchEnt(int (*func)(Entity ent,void *d),void *d){
int i; int i;
Entity *ent=NULL; Entity ent=NULL;
for(i=0;i<_n_entities;i++){ for(i=0;i<_n_entities;i++){
if(!_entity[i]) if(!_entity[i])
continue; continue;
@@ -500,6 +539,7 @@ Entity *GameLib_SearchEnt(int (*func)(Entity *ent,void *d),void *d){
return ent; return ent;
} }
///////////////////////////// /////////////////////////////
// GameLib_PlaySound // GameLib_PlaySound
// //
@@ -509,8 +549,8 @@ void GameLib_PlaySound(AudioSnd snd,int x,int y){
int r,cx,cy,off; int r,cx,cy,off;
// Get the screen context // Get the screen context
cx=_game_pos[0]+_game_size[0]/2; cx=_game_pos1[0]+_game_size[0]/2;
cy=_game_pos[1]+_game_size[1]/2; cy=_game_pos1[1]+_game_size[1]/2;
if(_game_size[0]>_game_size[1]){ if(_game_size[0]>_game_size[1]){
r=_game_size[0]/2; r=_game_size[0]/2;
}else{ }else{
@@ -558,7 +598,7 @@ void GameLib_Iluminate(){
// GameLib_EntitySetLight // GameLib_EntitySetLight
// //
// //
void GameLib_EntitySetLight(Entity *e,float r,float g,float b,float rad){ void GameLib_EntitySetLight(Entity e,float r,float g,float b,float rad){
if(e->flags&EntityFlag_Light){ if(e->flags&EntityFlag_Light){
Entity_MarkUpdateLight(e,_entity,_n_entities); Entity_MarkUpdateLight(e,_entity,_n_entities);
Entity_SetLight(e,r,g,b,rad); Entity_SetLight(e,r,g,b,rad);

16
GameLib/GameLib.h
View File

@@ -23,21 +23,21 @@ int GameLib_Init(int w,int h,char *title,int pfps,int fps);
// GameLib_AddEntity // GameLib_AddEntity
// //
// Adds an entity to the game. // Adds an entity to the game.
void GameLib_AddEntity(Entity *e); void GameLib_AddEntity(Entity e);
///////////////////////////// /////////////////////////////
// GameLib_UnrefEntity // GameLib_UnrefEntity
// //
// removes the reference to the entity. // removes the reference to the entity.
int GameLib_UnrefEntity(Entity *e); int GameLib_UnrefEntity(Entity e);
///////////////////////////// /////////////////////////////
// GameLib_DelEntity // GameLib_DelEntity
// //
// Adds an entity to the game. // Adds an entity to the game.
int GameLib_DelEntity(Entity *e); int GameLib_DelEntity(Entity e);
///////////////////////////// /////////////////////////////
@@ -47,8 +47,8 @@ int GameLib_DelEntity(Entity *e);
void GameLib_Loop( void GameLib_Loop(
void (*gameproc)(), void (*gameproc)(),
void (*gamepostproc)(), void (*gamepostproc)(),
void (*gamepredraw)(), void (*gamepredraw)(float f),
void (*gamedraw)()); void (*gamedraw)(float f));
///////////////////////////// /////////////////////////////
@@ -91,14 +91,14 @@ void GameLib_DelEnts();
// GameLib_ForEachEnt // GameLib_ForEachEnt
// //
// Iterates every entity. // Iterates every entity.
void GameLib_ForEachEnt(int (*func)(Entity *ent)); void GameLib_ForEachEnt(int (*func)(Entity ent));
///////////////////////////// /////////////////////////////
// GameLib_SearchEnt // GameLib_SearchEnt
// //
// Searches throught the entities. // Searches throught the entities.
Entity *GameLib_SearchEnt(int (*func)(Entity *ent,void *d),void *d); Entity GameLib_SearchEnt(int (*func)(Entity ent,void *d),void *d);
///////////////////////////// /////////////////////////////
@@ -119,7 +119,7 @@ void GameLib_Iluminate();
// GameLib_EntitySetLight // GameLib_EntitySetLight
// //
// //
void GameLib_EntitySetLight(Entity *e,float r,float g,float b,float rad); void GameLib_EntitySetLight(Entity e,float r,float g,float b,float rad);
///////////////////////////// /////////////////////////////

4
GameLib/Input.c
View File

@@ -57,7 +57,7 @@ void Input_Frame(){
Uint8* keys; Uint8* keys;
// Process Keys // Process Keys
keys=SDL_GetKeyState(NULL); keys=(Uint8 *)SDL_GetKeyState(NULL);
Input_SetKey(InputKey_Action1,keys[SDLK_z]); Input_SetKey(InputKey_Action1,keys[SDLK_z]);
Input_SetKey(InputKey_Action2,keys[SDLK_x]); Input_SetKey(InputKey_Action2,keys[SDLK_x]);
Input_SetKey(InputKey_Up,keys[SDLK_UP]); Input_SetKey(InputKey_Up,keys[SDLK_UP]);
@@ -66,6 +66,8 @@ void Input_Frame(){
Input_SetKey(InputKey_Right,keys[SDLK_RIGHT]); Input_SetKey(InputKey_Right,keys[SDLK_RIGHT]);
Input_SetKey(InputKey_Jump,keys[SDLK_SPACE]); Input_SetKey(InputKey_Jump,keys[SDLK_SPACE]);
Input_SetKey(InputKey_Continue,keys[SDLK_RETURN]|keys[SDLK_KP_ENTER]); Input_SetKey(InputKey_Continue,keys[SDLK_RETURN]|keys[SDLK_KP_ENTER]);
Input_SetKey(InputKey_DumpProfiling,keys[SDLK_p]);
} }

3
GameLib/Input.h
View File

@@ -33,6 +33,9 @@ typedef enum {
InputKey_Right, InputKey_Right,
InputKey_Jump, InputKey_Jump,
InputKey_Continue, InputKey_Continue,
InputKey_DumpProfiling,
InputKey_Max InputKey_Max
} InputKey; } InputKey;

75
GameLib/QuadArray2D.c Normal file
View File

@@ -0,0 +1,75 @@
// Copyright (C) 2013 Valeriano Alfonso Rodriguez (Kableado)
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "QuadArray2D.h"
QuadArray2D QuadArray2D_Create(int resVertex){
QuadArray2D quadArray=NULL;
quadArray=malloc(sizeof(TQuadArray2D));
quadArray->vertexData=malloc(sizeof(float)*Vertex2D_Length*resVertex);
quadArray->nVertex=0;
quadArray->resVertex=resVertex;
return quadArray;
}
void QuadArray2D_Destroy(QuadArray2D *quadArray){
if(!quadArray) return;
if(!quadArray[0]) return;
free(quadArray[0]->vertexData);
free(quadArray[0]);
quadArray[0]=NULL;
}
void QuadArray2D_Clean(QuadArray2D quadArray){
quadArray->nVertex=0;
}
void QuadArray2D_AddVertex(QuadArray2D quadArray,float v[]){
if(quadArray->resVertex<=quadArray->nVertex){
// Grow vertexData
quadArray->resVertex*=2;
float *newVertexData=malloc(sizeof(float)*Vertex2D_Length*
quadArray->resVertex);
memcpy(newVertexData,quadArray->vertexData,
sizeof(float)*Vertex2D_Length*quadArray->nVertex);
free(quadArray->vertexData);
quadArray->vertexData=newVertexData;
}
// Add the vertex
memcpy(
quadArray->vertexData+
(Vertex2D_Length*quadArray->nVertex),
v,sizeof(float)*Vertex2D_Length);
quadArray->nVertex++;
}
void QuadArray2D_AddQuad(QuadArray2D quadArray,
float x0, float y0,float u0, float v0,
float x1, float y1,float u1, float v1,
float color[])
{
float v[Vertex2D_Length];
int firstIndex=quadArray->nVertex;
// Set the color
v[4]=color[0];
v[5]=color[1];
v[6]=color[2];
v[7]=color[3];
// Add the vertexes
v[0]=x0; v[1]=y0; v[2]=u0; v[3]=v0; QuadArray2D_AddVertex(quadArray,v);
v[0]=x1; v[1]=y0; v[2]=u1; v[3]=v0; QuadArray2D_AddVertex(quadArray,v);
v[0]=x1; v[1]=y1; v[2]=u1; v[3]=v1; QuadArray2D_AddVertex(quadArray,v);
v[0]=x0; v[1]=y1; v[2]=u0; v[3]=v1; QuadArray2D_AddVertex(quadArray,v);
}

35
GameLib/QuadArray2D.h Normal file
View File

@@ -0,0 +1,35 @@
// Copyright (C) 2013 Valeriano Alfonso Rodriguez (Kableado)
#ifndef _QUADARRAY2D_H_
#define _QUADARRAY2D_H_
// Vertex2D -> (x,y) (u,v) (r,g,b,a)
#define Vertex2D_Length 8
////////////////////////////////////////////////
// QuadArray2D
//
typedef struct TQuadArray2D TQuadArray2D, *QuadArray2D;
struct TQuadArray2D {
float *vertexData;
int nVertex;
int resVertex;
};
QuadArray2D QuadArray2D_Create(int resVertex);
void QuadArray2D_Destroy(QuadArray2D *quadArray);
void QuadArray2D_Clean(QuadArray2D quadArray);
void QuadArray2D_AddVertex(QuadArray2D quadArray,float v[]);
void QuadArray2D_AddQuad(QuadArray2D quadArray,
float x0, float y0,float u0, float v0,
float x1, float y1,float u1, float v1,
float color[]);
#endif

35
GameLib/Util.c
View File

@@ -1,6 +1,8 @@
// Copyright (C) 2011 Valeriano Alfonso Rodriguez (Kableado) // Copyright (C) 2011 Valeriano Alfonso Rodriguez (Kableado)
#include <math.h> #include <math.h>
#include <stdlib.h>
#include <string.h>
#include "Util.h" #include "Util.h"
@@ -120,10 +122,9 @@ int Colision_CircleCircle(
vec2_scale(cen_a,cir2,invrads); vec2_scale(cen_a,cir2,invrads);
if(Intersec_RayUnitCircle(orig_a,vel_a,cen_a,t)){ if(Intersec_RayUnitCircle(orig_a,vel_a,cen_a,t)){
// Calculate n // Calculate n
vec2_scale(temp,vel,*t); vec2_scaleadd(temp,cir1,vel,*t);
vec2_plus(temp,cir1,temp); vec2_minus(n,temp,cir2);
vec2_minus(temp,cir2,temp); vec2_scale(n,n,invrads);
vec2_scale(n,temp,1.0f/rads);
return(1); return(1);
} }
return(0); return(0);
@@ -188,7 +189,6 @@ int absmod(int v,int d){
return(v%d); return(v%d);
} }
} }
float fabsmod(float v,int d){ float fabsmod(float v,int d){
if(v<0){ if(v<0){
v+=d*((((int)(v/d))*(-1))+1); v+=d*((((int)(v/d))*(-1))+1);
@@ -200,4 +200,29 @@ float fabsmod(float v,int d){
} }
/////////////////////////////
// IsBigEndian
//
int IsBigEndian(){
union{
unsigned int i;
char c[4];
} bint={0x01020304};
return bint.c[0]==1;
}
/////////////////////////////
// EndsWith
//
int EndsWith(char *str, char *suffix){
if (!str || !suffix)
return 0;
int lenStr = strlen(str);
int lenSuffix = strlen(suffix);
if (lenSuffix > lenStr)
return 0;
return strncmp(str+lenStr-lenSuffix, suffix, lenSuffix)==0;
}

18
GameLib/Util.h
View File

@@ -26,6 +26,9 @@ typedef float vec2[2];
#define vec2_perp(v,n) (v)[0]=-(n)[1];(v)[1]=(n)[0]; #define vec2_perp(v,n) (v)[0]=-(n)[1];(v)[1]=(n)[0];
#define vec2_scaleadd(v,v1,v2,s) (v)[0]=(v2)[0]*(s)+(v1)[0];(v)[1]=(v2)[1]*(s)+(v1)[1]; #define vec2_scaleadd(v,v1,v2,s) (v)[0]=(v2)[0]*(s)+(v1)[0];(v)[1]=(v2)[1]*(s)+(v1)[1];
float vec2_norm(vec2 v); float vec2_norm(vec2 v);
#define vec2_interpol(v,v1,v2,f) \
(v)[0]=(v1)[0]-f*((v1)[0]-(v2)[0]);\
(v)[1]=(v1)[1]-f*((v1)[1]-(v2)[1]);
///////////////////////////// /////////////////////////////
@@ -34,6 +37,7 @@ float vec2_norm(vec2 v);
// Intersection between a ray and a Unit Circle. // Intersection between a ray and a Unit Circle.
int Intersec_RayUnitCircle(vec2 orig,vec2 vel,vec2 center,float *t); int Intersec_RayUnitCircle(vec2 orig,vec2 vel,vec2 center,float *t);
///////////////////////////// /////////////////////////////
// Intersect_CircleCircle // Intersect_CircleCircle
// //
@@ -43,6 +47,7 @@ int Colision_CircleCircle(
vec2 cb,float rb, vec2 cb,float rb,
float *t,vec2 n); float *t,vec2 n);
///////////////////////////// /////////////////////////////
// Intersect_RayEdge // Intersect_RayEdge
// //
@@ -53,7 +58,6 @@ int Intersect_RayEdge(
float *t); float *t);
///////////////////////////// /////////////////////////////
// absmod // absmod
// //
@@ -61,4 +65,16 @@ int absmod(int v,int d);
float fabsmod(float v,int d); float fabsmod(float v,int d);
/////////////////////////////
// IsBigEndian
//
int IsBigEndian();
/////////////////////////////
// EndsWith
//
int EndsWith(char *str, char *suffix);
#endif #endif

6285
GameLib/lodepng.c Normal file
View File

File diff suppressed because it is too large Load Diff

1710
GameLib/lodepng.h Normal file
View File

File diff suppressed because it is too large Load Diff

15
GameMap.c
View File

@@ -8,10 +8,11 @@
#include "GameMap.h" #include "GameMap.h"
Entity *GameMapAux_CreateEnt(Entity *ent,int i,int j){ Entity GameMapAux_CreateEnt(Entity ent,int i,int j){
Entity *e; Entity e;
e=Entity_Copy(ent); e=Entity_Copy(ent);
vec2_set(e->pos,16+i*32,16+j*32); vec2_set(e->pos,16+i*32,16+j*32);
Entity_CalcBBox(e);
GameLib_AddEntity(e); GameLib_AddEntity(e);
return(e); return(e);
} }
@@ -39,10 +40,10 @@ void Aux_Linea(FILE *f,char *line){
} }
int _startpoint; int _startpoint;
int GameMapAux_CreatePlayer(Entity *ent){ int GameMapAux_CreatePlayer(Entity ent){
if(ent->type==Ent_SavePoint){ if(ent->type==Ent_SavePoint){
if(ent->A==_startpoint){ if(ent->A==_startpoint){
Entity *e; Entity e;
e=Entity_Copy(ent_player); e=Entity_Copy(ent_player);
vec2_copy(e->pos,ent->pos); vec2_copy(e->pos,ent->pos);
GameLib_AddEntity(e); GameLib_AddEntity(e);
@@ -158,7 +159,7 @@ int GameMap_CreateLevel(int level,int point){
GameMapAux_CreateEnt(ent_hole_lava,i,j); GameMapAux_CreateEnt(ent_hole_lava,i,j);
}else }else
if(line[i2]=='S'){ if(line[i2]=='S'){
Entity *e; Entity e;
// Save point // Save point
e=GameMapAux_CreateEnt(ent_savepoint,i,j); e=GameMapAux_CreateEnt(ent_savepoint,i,j);
e->A=line[i2+1]-'0'; e->A=line[i2+1]-'0';
@@ -189,12 +190,12 @@ int GameMap_CreateLevel(int level,int point){
}else }else
if(line[i2]=='T'){ if(line[i2]=='T'){
// Teleporter // Teleporter
Entity *ent=GameMapAux_CreateEnt(ent_teleporter,i,j); Entity ent=GameMapAux_CreateEnt(ent_teleporter,i,j);
ent->A=line[i2+1]-'0'; ent->A=line[i2+1]-'0';
}else }else
if(line[i2]=='D'){ if(line[i2]=='D'){
// Teleporter Destination // Teleporter Destination
Entity *ent=GameMapAux_CreateEnt(ent_teleporter_dest,i,j); Entity ent=GameMapAux_CreateEnt(ent_teleporter_dest,i,j);
ent->A=line[i2+1]-'0'; ent->A=line[i2+1]-'0';
}else }else

24
Makefile.common
View File

@@ -7,6 +7,7 @@ CFLAGS += -IGameLib
HEADS= \ HEADS= \
GameLib/Time.h \ GameLib/Time.h \
GameLib/Util.h \ GameLib/Util.h \
GameLib/QuadArray2D.h \
GameLib/Draw.h \ GameLib/Draw.h \
GameLib/Input.h \ GameLib/Input.h \
GameLib/Audio.h \ GameLib/Audio.h \
@@ -16,6 +17,7 @@ HEADS= \
OBJS= \ OBJS= \
$(BUILDDIR)/GameLib/Time.o \ $(BUILDDIR)/GameLib/Time.o \
$(BUILDDIR)/GameLib/Util.o \ $(BUILDDIR)/GameLib/Util.o \
$(BUILDDIR)/GameLib/QuadArray2D.o \
$(BUILDDIR)/GameLib/Draw.o \ $(BUILDDIR)/GameLib/Draw.o \
$(BUILDDIR)/GameLib/Input.o \ $(BUILDDIR)/GameLib/Input.o \
$(BUILDDIR)/GameLib/Audio.o \ $(BUILDDIR)/GameLib/Audio.o \
@@ -24,7 +26,6 @@ OBJS= \
$(BUILDDIR)/GameLib/GameLib.o \ $(BUILDDIR)/GameLib/GameLib.o \
##################### #####################
# Game Declarations # # Game Declarations #
##################### #####################
@@ -36,11 +37,6 @@ OBJS+= \
$(BUILDDIR)/main.o $(BUILDDIR)/main.o
################# #################
# General Rules # # General Rules #
################# #################
@@ -54,11 +50,9 @@ clean:
rm -f $(OBJS) $(BUILDDIR)/$(RESULT) rm -f $(OBJS) $(BUILDDIR)/$(RESULT)
run: $(BUILDDIR)/$(RESULT) run: $(BUILDDIR)/$(RESULT)
./$(BUILDDIR)/$(RESULT) debug $(LAUNCHER) ./$(BUILDDIR)/$(RESULT) debug
rebuild: clean all
################# #################
# GameLib Rules # # GameLib Rules #
@@ -67,6 +61,8 @@ $(BUILDDIR)/GameLib/Time.o: GameLib/Time.c $(HEADS)
$(CC) -c GameLib/Time.c -o $(BUILDDIR)/GameLib/Time.o $(CFLAGS) $(CC) -c GameLib/Time.c -o $(BUILDDIR)/GameLib/Time.o $(CFLAGS)
$(BUILDDIR)/GameLib/Util.o: GameLib/Util.c $(HEADS) $(BUILDDIR)/GameLib/Util.o: GameLib/Util.c $(HEADS)
$(CC) -c GameLib/Util.c -o $(BUILDDIR)/GameLib/Util.o $(CFLAGS) $(CC) -c GameLib/Util.c -o $(BUILDDIR)/GameLib/Util.o $(CFLAGS)
$(BUILDDIR)/GameLib/QuadArray2D.o: GameLib/QuadArray2D.c $(HEADS)
$(CC) -c GameLib/QuadArray2D.c -o $(BUILDDIR)/GameLib/QuadArray2D.o $(CFLAGS)
$(BUILDDIR)/GameLib/Draw.o: GameLib/Draw.c $(HEADS) $(BUILDDIR)/GameLib/Draw.o: GameLib/Draw.c $(HEADS)
$(CC) -c GameLib/Draw.c -o $(BUILDDIR)/GameLib/Draw.o $(CFLAGS) $(CC) -c GameLib/Draw.c -o $(BUILDDIR)/GameLib/Draw.o $(CFLAGS)
$(BUILDDIR)/GameLib/Input.o: GameLib/Input.c $(HEADS) $(BUILDDIR)/GameLib/Input.o: GameLib/Input.c $(HEADS)
@@ -81,7 +77,6 @@ $(BUILDDIR)/GameLib/GameLib.o: GameLib/GameLib.c $(HEADS)
$(CC) -c GameLib/GameLib.c -o $(BUILDDIR)/GameLib/GameLib.o $(CFLAGS) $(CC) -c GameLib/GameLib.c -o $(BUILDDIR)/GameLib/GameLib.o $(CFLAGS)
############## ##############
# Game Rules # # Game Rules #
############## ##############
@@ -95,8 +90,13 @@ $(BUILDDIR)/GameMap.o: GameMap.c $(HEADS)
$(BUILDDIR)/main.o: main.c $(HEADS) $(BUILDDIR)/main.o: main.c $(HEADS)
$(CC) -c main.c -o $(BUILDDIR)/main.o $(CFLAGS) $(CC) -c main.c -o $(BUILDDIR)/main.o $(CFLAGS)
################
# Result Rules #
################
$(BUILDDIR)/$(RESULT): $(OBJS) $(BUILDDIR)/$(RESULT): $(OBJS)
$(CC) -o $(BUILDDIR)/$(RESULT) $(OBJS) $(LIBS) $(CFLAGS) $(CC) -o $(BUILDDIR)/$(RESULT) $(OBJS) $(LIBS) $(CFLAGS) $(LDFLAGS)

14
Makefile.emscripten Normal file
View File

@@ -0,0 +1,14 @@
CC= python /c/Program\ Files/Emscripten/emscripten/1.7.8/emcc
LAUNCHER= start
RM=rm -rf
LIBS=
CFLAGS= -s LEGACY_GL_EMULATION=1 -s ASM_JS=1 -O1
LDFLAGS= --preload-file data
RESULT=game.html
BUILDDIR=build-emscripten
include Makefile.common

7
Makefile.linux
View File

@@ -1,7 +1,10 @@
CC=gcc
LAUNCHER=
RM=rm -rf
LIBS= -lSDL -lpthread -L/usr/X11R6/lib -L/usr/lib -lm -lGL -lX11 LIBS= -lSDL -lpthread -L/usr/X11R6/lib -L/usr/lib -lm -lGL -lX11
CFLAGS= -Wall -g -I/usr/include/ -I/usr/include/SDL/ -I/usr/X11R6/include/ CFLAGS= -Wall -g -I/usr/include/ -I/usr/include/SDL/ -I/usr/X11R6/include/
CC=gcc LDFLAGS=
RM=rm -rf
RESULT=game RESULT=game
BUILDDIR=build-linux BUILDDIR=build-linux

7
Makefile.mingw
View File

@@ -1,7 +1,10 @@
CC= i486-mingw32-gcc
LAUNCHER=
RM=rm -rf
LIBS= -L/usr/i486-mingw/lib -D_GNU_SOURCE=1 -Dmain=SDL_main -lopengl32 LIBS= -L/usr/i486-mingw/lib -D_GNU_SOURCE=1 -Dmain=SDL_main -lopengl32
CFLAGS= -I/usr/i486-mingw/include -lmingw32 -lSDLmain -lSDL -mwindows CFLAGS= -I/usr/i486-mingw/include -lmingw32 -lSDLmain -lSDL -mwindows
CC= i486-mingw32-gcc LDFLAGS=
RM=rm -rf
RESULT=game.exe RESULT=game.exe
BUILDDIR=build-mingw BUILDDIR=build-mingw

7
Makefile.win32
View File

@@ -1,7 +1,10 @@
CC=gcc
LAUNCHER=
RM=rm -rf
LIBS=-I/mingw/include/SDL -D_GNU_SOURCE=1 -Dmain=SDL_main -lopengl32 LIBS=-I/mingw/include/SDL -D_GNU_SOURCE=1 -Dmain=SDL_main -lopengl32
CFLAGS= -L/mingw/lib -lmingw32 -lSDLmain -lSDL -mwindows -g CFLAGS= -L/mingw/lib -lmingw32 -lSDLmain -lSDL -mwindows -g
CC=gcc LDFLAGS=
RM=rm -rf
RESULT=game.exe RESULT=game.exe
BUILDDIR=build-mingw BUILDDIR=build-mingw

2
dev-server.bat Normal file
View File

@@ -0,0 +1,2 @@
php -S 0.0.0.0:80 -tbuild-emscripten

3
dist.sh
View File

@@ -1,7 +1,8 @@
#!/bin/sh #!/bin/sh
DATE=$(date +%Y%m%d)
DIRNAME="Lonely_Ruins" DIRNAME="Lonely_Ruins"
DATE=$(date +%Y%m%d)
ZIPNAME="$DIRNAME.$DATE.zip" ZIPNAME="$DIRNAME.$DATE.zip"
make -f Makefile.linux make -f Makefile.linux

BIN
game.save
View File

Binary file not shown.

18
main.c
View File

@@ -85,7 +85,6 @@ void ProcGame(){
} }
void PostProcGame(){ void PostProcGame(){
if(game_level_reset){ if(game_level_reset){
if(Input_AnyKey()){ if(Input_AnyKey()){
if(GameMap_CreateLevel(game_level,game_level_point)){ if(GameMap_CreateLevel(game_level,game_level_point)){
@@ -102,7 +101,7 @@ void PostProcGame(){
} }
} }
void DrawGame(){ void DrawGame(float f){
char string[1024]; char string[1024];
Draw_SetColor(1.0f,1.0f,1.0f,1.0f); Draw_SetColor(1.0f,1.0f,1.0f,1.0f);
@@ -176,15 +175,15 @@ int main(int argc,char *argv[]){
GameLib_Init(640,480,"Game",60,60); GameLib_Init(640,480,"Game",60,60);
img_logo=Draw_LoadImage("data/logo.bmp"); img_logo=Draw_LoadImage("data/logo.png");
img_end=Draw_LoadImage("data/end.bmp"); img_end=Draw_LoadImage("data/end.png");
font=Draw_DefaultFont(255,255,255,255); font=Draw_DefaultFont(255,255,255,255);
GameEnts_Init(); GameEnts_Init();
LoadGame("game.save"); LoadGame("game.save");
#ifndef EMSCRIPTEN
do{ do{
play=0; play=0;
Draw_Loop(ProcTitle,DrawTitle); Draw_Loop(ProcTitle,DrawTitle);
@@ -208,6 +207,15 @@ int main(int argc,char *argv[]){
SaveGame("game.save"); SaveGame("game.save");
#else
int pos[2]={0,0};
GameLib_SetPos(pos);
game_level=0;
game_level_point=1;
game_level_reset=0;
GameMap_CreateLevel(game_level,game_level_point);
GameLib_Loop(ProcGame,PostProcGame,NULL,DrawGame);
#endif
return(0); return(0);
} }