#include "sdljump.h"
#include "game.h"
#include "tools.h"
#include "records.h"
extern L_gblOptions gblOps;
extern SDL_Surface * screen;
int drawBg(JPB_surface* surf, int x, int y, int w, int h)
{
SDL_Rect rect;
rect.x = x;
rect.h = h;
rect.w = w;
rect.y = y;
JPB_PrintSurface(surf, &rect, &rect);
return TRUE;
}
int drawFloor(graphics_t* gfx, int x, int y, int bw)
{
SDL_Rect rect;
int j;
rect.x = x*BLOCKSIZE + gfx->gameX;
rect.y = y + gfx->gameY;
JPB_PrintSurface(gfx->floorL, NULL, &rect);
for (j = 1; j < bw-1; j++) {
rect.x = j*BLOCKSIZE + x*BLOCKSIZE + gfx->gameX;
JPB_PrintSurface(gfx->floorC, NULL, &rect);
}
rect.x = j*BLOCKSIZE + x*BLOCKSIZE + gfx->gameX;
JPB_PrintSurface(gfx->floorR, NULL, &rect);
return TRUE;
}
void makeFloor(game_t* game, graphics_t* gfx, int y)
{
int f,x1,x2,fvec;
static int fpos = GRIDWIDTH/2;
f = game->floorTop - y;
if( f % 250 == 0 ) {
game->floor_l[ ( y+game->mapIndex) % GRIDHEIGHT ] = 1;
game->floor_r[ ( y+game->mapIndex) % GRIDHEIGHT ] = GRIDWIDTH -2;
drawFloor(gfx, 1, y*BLOCKSIZE+game->scrollCount, GRIDWIDTH-2);
return;
}
if( f % 5 == 0 ) {
fvec = (rnd(2)*2-1) * ( rnd( (GRIDWIDTH-11)/4 ) + (GRIDWIDTH-11)/4 );
fpos = ( fpos + fvec + GRIDWIDTH-11 ) % (GRIDWIDTH-11);
x1 = ( fpos+5 - rnd( 3 ) - 2);
x2 = ( fpos+5 + rnd( 3 ) + 2);
game->floor_l[ ( y+game->mapIndex) % GRIDHEIGHT ] = x1;
game->floor_r[ ( y+game->mapIndex) % GRIDHEIGHT ] = x2;
drawFloor(gfx, x1, y*BLOCKSIZE+game->scrollCount, x2-x1+1);
} else {
game->floor_l[ ( y+game->mapIndex) % GRIDHEIGHT ] = GRIDWIDTH;
game->floor_r[ ( y+game->mapIndex) % GRIDHEIGHT ] = -1;
}
}
void scrollUp(game_t* game, graphics_t* gfx)
{
int x,width,y;
for( y = game->floorTop % 5 ; y < GRIDHEIGHT ; y += 5 ){
x = game->floor_l[ ( y+game->mapIndex) % GRIDHEIGHT ];
width = game->floor_r[ ( y+game->mapIndex) % GRIDHEIGHT ] -x+1;
drawBg(gfx->gameBg, x*BLOCKSIZE + gfx->gameX,
y*BLOCKSIZE + gfx->gameY ,
width*BLOCKSIZE, BLOCKSIZE);
if( y < GRIDHEIGHT-1 )
drawFloor(gfx, x,(y+1)*BLOCKSIZE,width);
}
game->floorTop++;
if( --game->mapIndex < 0 )
game->mapIndex = GRIDHEIGHT - 1;
makeFloor(game,gfx,0);
scrollHeros(game, BLOCKSIZE);
}
void scrollHeros(game_t* game, float scroll)
{
int i;
for (i=0; i<game->numHeros; i++) {
game->heros[i].y += scroll;
}
}
void initGame(game_t* game, graphics_t* gfx, int numHeros)
{
int i,j;
game->floorTop = GRIDHEIGHT - 4;
game->mapIndex = 0;
game->scrollCount = 0;
for (i=0; i<GRIDHEIGHT; i++) {
makeFloor(game,gfx,i);
}
game->numHeros = numHeros;
game->heros = malloc(sizeof(hero_t)*numHeros);
game->T_count = 0;
game->T_speed = 200;
game->deadHeros = 0;
for (i = 0; i<numHeros; i++) {
for (j=0; j<HEROANIMS; j++) {
initializeSpriteCtlRot(&game->heros[i].sprite[j], gfx->heroSprite[i][j]);
}
initHeroKeys(&game->heros[i],i);
game->heros[i].x = GRIDWIDTH*BLOCKSIZE/2 - BLOCKSIZE + isPar(i)*i*rnd(i*5);
game->heros[i].y = (GRIDHEIGHT - 4)*BLOCKSIZE
-getFrameRot(&game->heros[i].sprite[H_STAND],0)->h;
game->heros[i].vx = game->heros[i].vy = 0;
game->heros[i].dir = 0;
game->heros[i].jump = 0;
game->heros[i].floor = 0;
game->heros[i].id = game->heros[i].previd = H_STAND;
game->heros[i].dead = FALSE;
game->heros[i].prevLives = -1;
if (numHeros > 1) game->heros[i].lives = gblOps.mpLives-1;
else game->heros[i].lives = 0;
game->heros[i].angle = game->heros[i].rotateto = 0;
}
}
void freeGame(game_t* game)
{
free(game->heros);
}
void updateScore(graphics_t* gfx, game_t* game)
{
int i,j;
int x,y;
SDL_Rect rect;
char score[MAX_CHAR];
char prevscore[MAX_CHAR];
for (i=0; i < game->numHeros; i++) {
if (game->heros[i].floor != game->heros[i].prevFloor) {
sprintf(score,"%d",game->heros[i].floor);
sprintf(prevscore,"%d",game->heros[i].prevFloor);
x = gfx->scoreX[i];
y = gfx->scoreY[i];
drawBg(gfx->gameBg, x-1, y-1,
SFont_TextWidth(gfx->scorefont,prevscore)+2,
SFont_TextHeight(gfx->scorefont)+2);
SFont_Write(gfx->scorefont, x,y, score);
}
if (game->heros[i].prevLives != game->heros[i].lives) {
rect.x = x = gfx->livesX[i];
rect.y = y = gfx->livesY[i];
rect.w = gfx->livePic->w;
rect.h = gfx->livePic->h;
if (gfx->liveAlign) {
drawBg(gfx->gameBg, x, y,
gfx->livePic->w,
gfx->livePic->h * (game->heros[i].lives+2));
} else {
drawBg(gfx->gameBg, x, y,
gfx->livePic->w * (game->heros[i].lives+2),
gfx->livePic->h);
}
for (j=0; j <= game->heros[i].lives;j++) {
JPB_PrintSurface(gfx->livePic, NULL, &rect);
if (gfx->liveAlign) {
y += gfx->livePic->h;
rect.y = y;
} else {
x += gfx->livePic->w;
rect.x = x;
}
}
game->heros[i].prevLives = game->heros[i].lives;
}
}
}
int playGame(graphics_t* gfx, int numHeros)
{
L_timer timer;
time_t start,end;
game_t game;
int done = FALSE;
int r;
drawBg(gfx->gameBg,0,0,gblOps.w,gblOps.h);
initGame(&game, gfx, numHeros);
initTimer(&timer, gblOps.fps);
FlipScreen();
start = time(NULL);
updateTimer(&timer);
while(!done) {
if ((r = updateInput(&game))) {
if (r == PAUSED) {
done = pauseGame(gfx, &game, gfx->txt[txt_pause]);
} else {
done = yesNoQuestion(gfx, &game, gfx->txt[txt_askquit]);
}
continueTimer(&timer);
}
updateTimer(&timer);
if (updateGame(&game,gfx, timer.ms))
done = ENDMATCH;
updateScore(gfx, &game);
FlipScreen();
}
if (done == ENDMATCH) {
end = time(NULL);
r = endMatch(gfx, &game, difftime(end,start));
} else {
r = FALSE;
}
freeGame(&game);
return r;
}
int drawAnimatedSquare(Uint32 color, Uint8 alpha, int x, int y, int w, int h, int time)
{
fader_t fader;
L_timer timer;
int xc = 0;
int ret = 0;
x += w/2;
initTimer(&timer, gblOps.fps);
updateTimer(&timer);
setFader(&fader, 1, w/2+1, time);
do {
updateTimer(&timer);
ret = updateFader(&fader, timer.ms);
JPB_drawSquare(color, alpha, x+xc, y, fader.value-xc, h);
JPB_drawSquare(color, alpha, x-xc, y, xc-fader.value, h);
xc = fader.value;
FlipScreen();
} while(!ret);
}
int pauseGame(graphics_t* gfx, game_t* game, char* text)
{
int w = (GRIDWIDTH-2) *BLOCKSIZE;
int h = BLOCKSIZE + SFont_AlignedHeight(gfx->textfont, w-2*BLOCKSIZE, 0, text);
int x = gfx->gameX + BLOCKSIZE;
int y = gfx->gameY + (GRIDHEIGHT*BLOCKSIZE-h)/2;
int ret = FALSE;
int done = FALSE;
SDL_Event event;
drawAnimatedSquare(gfx->gcolor, gfx->galpha, x, y, w, h, MSGTIME);
SFont_WriteAligned(gfx->textfont, x + BLOCKSIZE, y + BLOCKSIZE/2, w - 2*BLOCKSIZE, 0, ACENTER, text);
FlipScreen();
while(!done) {
while (SDL_PollEvent(&event)) {
if (event.type == SDL_KEYDOWN) {
if( event.key.keysym.sym == SDLK_p ||
event.key.keysym.sym == SDLK_PAUSE ) {
ret = FALSE;
done = TRUE;
} else if (event.key.keysym.sym == KEY_QUIT) {
ret = TRUE;
done = TRUE;
}
}
}
}
recoverScr( gfx, game, x -gfx->gameX, y -gfx->gameY, w, h);
if (ret) {
return yesNoQuestion(gfx, game, gfx->txt[txt_askquit]);
}
return ret;
}
int endMatch(graphics_t* gfx, game_t* game, int time)
{
int i;
int r, fact, newrec = FALSE;
records_t rec;
if (game->numHeros > 1) fact = gblOps.mpLives; else fact = 1;
for (i = 0; i < game->numHeros; i++) {
if ((r = checkRecord(gblOps.records, game->heros[i].floor/fact))) {
makeRecord(&rec, gblOps.pname[i], game->heros[i].floor/fact, time);
addRecord(gblOps.records, &rec, r);
newrec = TRUE;
}
}
if (newrec) {
if (yesNoQuestion(gfx, game, gfx->txt[txt_newhsc])) {
return TRUE;
}
drawRecords(gfx,gblOps.records);
pressAnyKey();
return FALSE;
} else {
return yesNoQuestion(gfx, game, gfx->txt[txt_gameover]);
}
}
int yesNoQuestion(graphics_t* gfx, game_t* game, char* text)
{
int w = (GRIDWIDTH-2) *BLOCKSIZE;
int h = BLOCKSIZE + SFont_AlignedHeight(gfx->textfont, w-2*BLOCKSIZE, 0, text);
int x = gfx->gameX + BLOCKSIZE;
int y = gfx->gameY + (GRIDHEIGHT*BLOCKSIZE-h)/2;
int ret = FALSE;
int done = FALSE;
SDL_Event event;
drawAnimatedSquare(gfx->gcolor, gfx->galpha, x, y, w, h, MSGTIME);
x += BLOCKSIZE;
y += BLOCKSIZE/2;
w -= 2*BLOCKSIZE;
SFont_WriteAligned(gfx->textfont, x, y, w, 0, ACENTER, text);
FlipScreen();
while(!done) {
while (SDL_PollEvent(&event)) {
if (event.type == SDL_KEYDOWN) {
if( event.key.keysym.sym == KEY_QUIT ||
event.key.keysym.sym == SDLK_n){
ret = FALSE;
done = TRUE;
} else if ( event.key.keysym.sym == SDLK_y ) {
ret = TRUE;
done = TRUE;
}
}
}
}
recoverScr( gfx, game, x-BLOCKSIZE-gfx->gameX, y-BLOCKSIZE/2-gfx->gameY,
w+2*BLOCKSIZE, h);
return ret;
}
void updateTimer(L_timer* time)
{
Uint32 current_ticks;
Uint32 target_ticks;
Uint32 the_delay;
Uint32 currms;
if (time->rate > 0) {
time->framecount++;
currms = current_ticks = SDL_GetTicks();
time->ms = currms - time->mscount;
time->mscount = currms;
target_ticks = time->lastticks +
(Uint32) ((float) time->framecount * time->rateticks);
if (current_ticks <= target_ticks) {
the_delay = target_ticks - current_ticks;
SDL_Delay(the_delay);
} else {
time->framecount = 0;
time->lastticks = SDL_GetTicks();
}
} else {
currms = SDL_GetTicks();
time->ms = currms - time->mscount;
time->mscount = currms;
}
}
void continueTimer(L_timer* time)
{
time->mscount = SDL_GetTicks();
}
void initTimer(L_timer* time, int rate)
{
time->framecount = 0;
time->rate = rate;
time->rateticks = (1000.0 / (float) rate);
time->mscount = time->lastticks = SDL_GetTicks();
time->ms = 0;
}
int updateGame(game_t* game, graphics_t* gfx, float ms)
{
int i;
int done = TRUE;
float fact = ms/DELAY;
for (i=0; i<game->numHeros; i++) {
undrawHero(i, gfx, game);
}
if( game->T_speed < 5000 )
game->T_speed += fact;
game->T_count += game->T_speed * fact;
if (gblOps.scrollMode == HARDSCROLL) {
if( game->T_count > 20000 ){
game->T_count -= 20000;
scrollUp(game,gfx);
}
} else {
softScrollUp(game,gfx,1 / (20000 / game->T_speed / BLOCKSIZE) * fact);
}
for (i=0; i<game->numHeros; i++) {
if (game->heros[i].dead == FALSE) {
if (updateHero(game, gfx, i, ms) == DEAD) {
if (game->heros[i].lives < 1) {
game->heros[i].dead = TRUE;
game->deadHeros++;
} else {
reliveHero(game, i);
}
if (game->deadHeros == game->numHeros) {
done = TRUE;
}
game->heros[i].lives--;
}
done= FALSE;
}
}
return done;
}
void reliveHero(game_t* game, int num)
{
hero_t* hero = &game->heros[num];
hero->y = MINSKY;
hero->x = (GRIDWIDTH * BLOCKSIZE - getFrameRot(&hero->sprite[H_STAND], 0)->w) / 2;
hero->id = H_STAND;
hero->vx = 0;
hero->vy = -2;
hero->prevLives = hero->lives;
}
void softScrollUp(game_t* game, graphics_t* gfx, float scroll)
{
int y,x,width;
game->scrollCount += scroll;
for( y = game->floorTop % 5 ; y < GRIDHEIGHT ; y += 5 ){
x = game->floor_l[ ( y+game->mapIndex) % GRIDHEIGHT ];
width = game->floor_r[ ( y+game->mapIndex) % GRIDHEIGHT ] -x+1;
drawBg(gfx->gameBg, x*BLOCKSIZE + gfx->gameX,
y*BLOCKSIZE + gfx->gameY ,
width*BLOCKSIZE, BLOCKSIZE);
if( y*BLOCKSIZE+game->scrollCount < (GRIDHEIGHT-1)*BLOCKSIZE)
drawFloor(gfx,x, y*BLOCKSIZE+game->scrollCount, width);
}
if (game->scrollCount >= BLOCKSIZE) {
game->scrollCount -= BLOCKSIZE;
game->floorTop++;
if( --game->mapIndex < 0 )
game->mapIndex = GRIDHEIGHT - 1;
makeFloor(game,gfx,0);
}
scrollHeros(game, scroll);
}
int updateHero(game_t* game, graphics_t* gfx, int num, float ms)
{
int acc = 0;
int st = 0;
int y;
int floor;
hero_t* hero = &game->heros[num];
float fact = ms/DELAY;
st = updateHeroPosition(game, num, fact);
if( hero->y < MINSKY ){
if (gblOps.scrollMode == HARDSCROLL) {
scrollUp(game,gfx);
} else {
softScrollUp(game,gfx,MINSKY - hero->y);
}
game->T_count = 0;
} else if( hero->y >= GRIDHEIGHT*BLOCKSIZE ) {
return DEAD;
}
if( st > 0 ){
acc = 3;
floor = (game->floorTop - hero->y / BLOCKSIZE) / FLOORGAP + 1;
hero->rotateto = 0;
if (gblOps.scrollMode == HARDSCROLL)
hero->y = st*BLOCKSIZE;
else
hero->y = st*BLOCKSIZE + game->scrollCount+1;
hero->vy = 0;
if (hero->left.pressed || hero->right.pressed)
hero->id = H_WALK;
else
hero->id = H_STAND;
if( hero->up.pressed ){
hero->jump = abs(hero->vx)/4 +7;
hero->vy = -hero->jump/2 -12;
hero->rotateto = 90+ 180*hero->dir;
st = 0;
}
}else{
acc = 2;
floor = 0;
hero->id = H_JUMP;
}
if( hero->left.pressed){
hero->vx -= acc *fact;
if( hero->vx < -32 )
hero->vx = -32;
hero->dir = LEFT;
}else if( hero->right.pressed){
hero->vx += acc*fact;
if( hero->vx > 32 )
hero->vx = 32;
hero->dir = RIGHT;
}else if( st > 0 ){
if( hero->vx < -2 )
hero->vx += 3*fact;
else if( hero->vx > 2 )
hero->vx -= 3*fact;
else
hero->vx = 0;
}
if( st == 0 ){
if( hero->jump > 0 ){
hero->vy = -hero->jump/2 -12;
if( hero->up.pressed )
hero->jump -= fact;
else
hero->jump = 0;
} else {
hero->vy += 2 *fact;
if( hero->vy > 0 )
hero->rotateto = 180;
if( hero->vy > BLOCKSIZE )
hero->vy = BLOCKSIZE;
}
}
rotateHero(hero,ms);
if (hero->id != hero->previd) {
hero->previd = hero->id;
hero->sprite[hero->id].elpTime = hero->sprite[hero->id].frame = 0;
}
animateSpriteRot(&hero->sprite[hero->id],ms);
drawHero(gfx,hero);
if (floor != 0) {
hero->prevFloor = hero->floor;
hero->floor = floor;
}
return TRUE;
}
int updateHeroPosition ( game_t* game, int num , float fact)
{
float Dy, diff, Dycount;
int st, i;
hero_t* hero = &game->heros[num];
hero->x += hero->vx / 2 *fact;
if( hero->x < BLOCKSIZE ) {
hero->x = BLOCKSIZE ;
hero->vx = -hero->vx/2;
}else if( hero->x > GRIDWIDTH*BLOCKSIZE - 3*BLOCKSIZE ) {
hero->x = GRIDWIDTH*BLOCKSIZE - 3*BLOCKSIZE ;
hero->vx = -hero->vx/2;
}
Dy = Dycount = hero->vy *fact;
if (Dy > BLOCKSIZE) {
for (i = 0; i <= Dy/BLOCKSIZE; i++) {
if ((st = isStand(game, hero->x, hero->y))) {
return st;
}
if (Dycount > BLOCKSIZE) diff = BLOCKSIZE;
else diff = Dycount;
Dycount -= diff;
hero->y += diff;
}
return st;
} else {
hero->y += Dy;
if (hero->vy < 0) return FALSE;
else return isStand( game, hero->x, hero->y );
}
}
int isStand( game_t* game, int ix, int iy)
{
int y;
if (iy + 2*BLOCKSIZE > (GRIDHEIGHT-1)*BLOCKSIZE)
return FALSE;
y = ( ( iy + 2*BLOCKSIZE - game->scrollCount) / BLOCKSIZE );
if( y >= GRIDHEIGHT )
return FALSE;
if( game->floor_l[ ( y+game->mapIndex) % GRIDHEIGHT ] *BLOCKSIZE < (ix+24)
&& (ix-8) < game->floor_r[ ( y+game->mapIndex) % GRIDHEIGHT ] *BLOCKSIZE )
return y-2;
else
return FALSE;
}
void rotateHero(hero_t* hero, float ms)
{
float fact = ms/DELAY;
if (gblOps.rotMode == ROTORIG) {
hero->angle = hero->rotateto;
} else if (gblOps.rotMode == ROTFULL) {
if (hero->rotateto == 0) hero->angle = 0;
else {
hero->angspeed = abs(hero->vx)*bool2sign(hero->dir)
+ abs(hero->vy)*bool2sign(hero->dir);
hero->angle += hero->angspeed*fact;
}
}
}
void drawHero(graphics_t* gfx,hero_t* hero)
{
SDL_Rect dest;
dest.x = hero->x+ gfx->gameX +BLOCKSIZE -(getFrameRot(&hero->sprite[hero->id],0)->w -32)/2 ;
dest.y = hero->y+ gfx->gameY +BLOCKSIZE -(getFrameRot(&hero->sprite[hero->id],0)->h -32)/2;
printSpriteRot(&hero->sprite[hero->id],NULL,&dest,hero->dir,hero->angle);
}
void undrawHero(int heronum, graphics_t* gfx, game_t* game)
{
int w = getFrameRot(&game->heros[heronum].sprite[game->heros[heronum].id],0)->w;
int h = getFrameRot(&game->heros[heronum].sprite[game->heros[heronum].id],0)->h;
int diag;
if (gblOps.rotMode == ROTFULL) {
diag = sqrt(w*w+h*h);
recoverScr( gfx, game,
game->heros[heronum].x - (diag-w)/2,
game->heros[heronum].y - (diag-h)/2,
diag, diag);
} else {
recoverScr( gfx, game,
game->heros[heronum].x -(w-32)/2, game->heros[heronum].y -(h-31)/2,
w, h);
}
}
void recoverScr( graphics_t* gfx, game_t* game, int x, int y, int w, int h )
{
SDL_Rect dest;
int x0 = x;
int y2,x2;
y2 = (y+h-1) / BLOCKSIZE;
y = y/BLOCKSIZE -2;
for( ; y <= y2 ; y++ ){
x2 = (x0+w-1) /BLOCKSIZE;
x = x0/BLOCKSIZE -1;
for (; x <= x2; x++) {
dest.x = x*BLOCKSIZE + gfx->gameX;
dest.y = y*BLOCKSIZE + gfx->gameY;
drawBg(gfx->gameBg,dest.x,dest.y,BLOCKSIZE, BLOCKSIZE);
if (y > GRIDHEIGHT-1 || x < 1 || x > GRIDWIDTH-1)
continue;
if (game->floor_l[(y+game->mapIndex)%GRIDHEIGHT] == x) {
JPB_PrintSurface(gfx->floorL,NULL,&dest);
} else if (x == game->floor_r[(y+game->mapIndex)%GRIDHEIGHT]) {
JPB_PrintSurface(gfx->floorR,NULL,&dest);
} else if (game->floor_l[(y+game->mapIndex)%GRIDHEIGHT] < x &&
x < game->floor_r[(y+game->mapIndex)%GRIDHEIGHT])
{
JPB_PrintSurface(gfx->floorC,NULL,&dest);
}
}
}
}
int isFloor(game_t* game, int x, int y)
{
y -= game->scrollCount;
if ( ( game->floor_r[(y+game->mapIndex)%GRIDHEIGHT] > x ) &&
( game->floor_l[(y+game->mapIndex)%GRIDHEIGHT] < x ) ) {
return TRUE;
} else {
return FALSE;
}
}
int updateInput(game_t* game)
{
int done = 0;
int i;
SDL_Event event;
while( SDL_PollEvent( &event ) ){
switch( event.type ){
case SDL_KEYDOWN:
if( event.key.keysym.sym == KEY_QUIT){
done = TRUE;
}
if( event.key.keysym.sym == SDLK_p || event.key.keysym.sym == SDLK_PAUSE) {
done = PAUSED;
}
for (i=0; i < game->numHeros; i++) {
markHeroKeys(&event,&game->heros[i]);
}
break;
case SDL_KEYUP:
for (i=0; i < game->numHeros; i++) {
unmarkHeroKeys(&event,&game->heros[i]);
}
break;
case SDL_QUIT:
done = TRUE;
break;
default:
break;
}
}
return done;
}
void initHeroKeys(hero_t* hero, int num)
{
hero->left.def = gblOps.keys[num][LEFTK];
hero->left.pressed = FALSE;
hero->right.def = gblOps.keys[num][RIGHTK];
hero->right.pressed = FALSE;
hero->up.def = gblOps.keys[num][JUMPK];
hero->up.pressed = FALSE;
}
void markHeroKeys(SDL_Event* event, hero_t* hero)
{
if( event->key.keysym.sym == hero->left.def){
hero->left.pressed = 1;
} else
if( event->key.keysym.sym == hero->right.def){
hero->right.pressed = 1;
} else
if( event->key.keysym.sym == hero->up.def){
hero->up.pressed = 1;
}
}
void unmarkHeroKeys(SDL_Event* event, hero_t* hero)
{
if( event->key.keysym.sym == hero->left.def){
hero->left.pressed = 0;
} else
if( event->key.keysym.sym == hero->right.def){
hero->right.pressed = 0;
} else
if( event->key.keysym.sym == hero->up.def){
hero->up.pressed = 0;
}
}
void drawRecords(graphics_t* gfx, records_t* rtab)
{
int x, x1, x2, x3, x4, x5, y, w, h, i;
char buf[128];
x = gfx->gameX + 2*BLOCKSIZE;
w = GRIDWIDTH*BLOCKSIZE - 4*BLOCKSIZE;
h = BLOCKSIZE + 12*gfx->textfont->Surface->h
+ SFont_AlignedHeight(gfx->textfont, w-2*BLOCKSIZE,0,gfx->txt[txt_hscnote]);
y = gfx->gameY + (GRIDHEIGHT*BLOCKSIZE - h)/2;
JPB_PrintSurface(gfx->gameBg, NULL, NULL);
drawAnimatedSquare(gfx->gcolor, gfx->galpha, x, y, w, h, MSGTIME);
y += BLOCKSIZE;
x1 = x + BLOCKSIZE;
x2 = x1 + SFont_TextWidth(gfx->textfont, "# ");
sprintf(buf, "%s %s %s", gfx->txt[txt_floor], gfx->txt[txt_mode], gfx->txt[txt_time]);
x3 = x1 + w - 2*BLOCKSIZE - SFont_TextWidth(gfx->textfont, buf);
SFont_Write(gfx->textfont, x3, y, buf);
sprintf(buf,"%s ", gfx->txt[txt_floor]);
x4 = x3 + SFont_TextWidth(gfx->textfont, buf);
sprintf(buf,"%s ", gfx->txt[txt_mode]);
x5 = x4 + SFont_TextWidth(gfx->textfont, buf);
sprintf(buf,"# %s ", gfx->txt[txt_name]);
SFont_Write(gfx->textfont, x1, y, buf);
for (i = 0; i < MAX_RECORDS; i++) {
y += gfx->textfont->Surface->h-1;
sprintf(buf,"%d", i+1);
SFont_Write(gfx->textfont, x1, y, buf);
SFont_Write(gfx->textfont, x2, y, rtab[i].pname);
SFont_FillWith(gfx->textfont,
x2 + SFont_TextWidth(gfx->textfont, rtab[i].pname) + 3,
y, x3 -6 -(x2 + SFont_TextWidth(gfx->textfont, rtab[i].pname)),'.');
sprintf(buf,"%d", rtab[i].floor);
SFont_Write(gfx->textfont, x3, y, buf);
SFont_Write(gfx->textfont, x4, y, rtab[i].mode);
sprintf(buf,"%d", rtab[i].time);
SFont_Write(gfx->textfont, x5, y, buf);
}
y += gfx->textfont->Surface->h*2;
SFont_WriteAligned(gfx->textfont, x1, y, w-2*BLOCKSIZE,
0, ALEFT, gfx->txt[txt_hscnote]);
FlipScreen();
}