void gr_draw_frame()
{
if ( jump ) return ;
/* Actualiza paleta */
if ( palette_changed ) gr_refresh_palette();
if ( !trans_table_updated ) gr_make_trans_table();
/* Bloquea el bitmap de pantalla */
if ( gr_lock_screen() < 0 ) return ;
/* Dibuja la pantalla */
gr_draw_screen( scrbitmap, GLODWORD( librender, RESTORETYPE ), GLODWORD( librender, DUMPTYPE ) );
/* Fading */
if ( fade_on || fade_set )
{
gr_fade_step() ;
if ( background ) background->modified = 1 ;
}
/* Actualiza la paleta y la pantalla */
gr_unlock_screen() ;
}
void mouse_draw( INSTANCE * i, REGION * clip )
{
int r ;
REGION region;
r = GLOINT32( libmouse, MOUSEREGION ) ;
if ( r < 0 || r > 31 ) r = 0 ;
region = regions[r];
if ( clip ) region_union( ®ion, clip );
if ( GLOINT32( libmouse, MOUSEANGLE ) || GLOINT32( libmouse, MOUSESIZE ) != 100 )
gr_rotated_blit(
0,
®ion,
GLOINT32( libmouse, MOUSEX ),
GLOINT32( libmouse, MOUSEY ),
GLODWORD( libmouse, MOUSEFLAGS ),
GLOINT32( libmouse, MOUSEANGLE ),
GLOINT32( libmouse, MOUSESIZE ),
GLOINT32( libmouse, MOUSESIZE ),
mouse_map ) ;
else
gr_blit(
0,
®ion,
GLOINT32( libmouse, MOUSEX ),
GLOINT32( libmouse, MOUSEY ),
GLODWORD( libmouse, MOUSEFLAGS ),
mouse_map ) ;
mouse_map->modified = 0;
}
void scroll_start( int n, int fileid, int graphid, int backid, int region, int flags, int destfile, int destid )
{
SCROLL_EXTRA_DATA * data;
if ( n >= 0 && n <= 9 )
{
if ( region < 0 || region > 31 ) region = 0 ;
scrolls[n].active = 1 ;
scrolls[n].fileid = fileid ;
scrolls[n].graphid = graphid ;
scrolls[n].backid = backid ;
scrolls[n].region = ®ions[region] ;
scrolls[n].flags = flags ;
scrolls[n].destfile = destfile;
scrolls[n].destid = destid;
data = &(( SCROLL_EXTRA_DATA * ) &GLODWORD( libscroll, SCROLLS ) )[n] ;
data->reserved[0] = ( int32_t ) &scrolls[n]; /* First reserved dword point to internal scrolldata struct */
if ( scrolls_objects[n] ) gr_destroy_object( scrolls_objects[n] );
scrolls_objects[n] = ( int )gr_new_object( 0, info_scroll, draw_scroll, n );
}
}
void scroll_start( int n, int fileid, int graphid, int backid, int region, int flags )
{
SCROLL_EXTRA_DATA * data;
if ( n >= 0 && n <= 9 )
{
if ( region < 0 || region > 31 ) region = 0 ;
scrolls[n].graph = graphid ? bitmap_get( fileid, graphid ) : 0 ;
scrolls[n].back = backid ? bitmap_get( fileid, backid ) : 0 ;
if ( !graphid || !scrolls[n].graph ) return ; // El fondo de scroll no existe
if ( backid && !scrolls[n].back ) return ; // Grafico no existe
scrolls[n].active = 1 ;
scrolls[n].fileid = fileid ;
scrolls[n].graphid = graphid ;
scrolls[n].backid = backid ;
scrolls[n].region = ®ions[region] ;
scrolls[n].flags = flags ;
data = &(( SCROLL_EXTRA_DATA * ) & GLODWORD( libscroll, SCROLLS ) )[n] ;
data->reserved[0] = ( int32_t ) & scrolls[n]; /* First reserved dword point to internal scrolldata struct */
if ( scrolls_objects[n] ) gr_destroy_object( scrolls_objects[n] );
scrolls_objects[n] = ( int )gr_new_object( 0, info_scroll, draw_scroll, n );
}
}
static int modcd_getinfo( INSTANCE * my, int * params )
{
int i, total = 0;
char * trackinfo;
if ( params[0] < 0 || params[0] >= SDL_CDNumDrives() ) return 0;
if ( sdl_cd == NULL || sdl_cdnum != params[0] )
{
if ( sdl_cd ) SDL_CDClose( sdl_cd );
sdl_cd = SDL_CDOpen( params[0] );
if ( sdl_cd == NULL ) return 0;
sdl_cdnum = params[0];
}
GLODWORD( mod_cd, CD_TRACKS ) = sdl_cd->numtracks;
GLODWORD( mod_cd, CD_TRACK ) = sdl_cd->cur_track;
FRAMES_TO_MSF( sdl_cd->cur_frame, &GLODWORD( mod_cd, CD_MINUTE ), &GLODWORD( mod_cd, CD_SECOND ), &GLODWORD( mod_cd, CD_SUBFRAME ) );
trackinfo = ( char * ) & GLODWORD( mod_cd, CD_TRACKINFO );
for ( i = 0; i < sdl_cd->numtracks ; i++, trackinfo += 16 )
{
total += sdl_cd->track[i].length;
*( Uint32 * ) trackinfo = ( sdl_cd->track[i].type == SDL_AUDIO_TRACK );
FRAMES_TO_MSF( sdl_cd->track[i].length, trackinfo + 4, trackinfo + 8, trackinfo + 12 );
}
FRAMES_TO_MSF( total, &GLODWORD( mod_cd, CD_MINUTES ), &GLODWORD( mod_cd, CD_SECONDS ), &GLODWORD( mod_cd, CD_FRAMES ) );
return 1;
}
static int modregex_regex (INSTANCE * my, int * params)
{
const char * reg = string_get(params[0]);
const char * str = string_get(params[1]);
int result = -1;
unsigned n;
struct re_pattern_buffer pb;
struct re_registers re;
int start[16];
int end[16];
int * regex_reg;
/* Alloc the pattern resources */
memset (&pb, 0, sizeof(pb));
memset (&re, 0, sizeof(re));
pb.buffer = malloc(4096);
pb.allocated = 4096;
pb.fastmap = malloc(256);
pb.regs_allocated = 16;
re.num_regs = 16;
re.start = start;
re.end = end;
re_syntax_options = RE_SYNTAX_POSIX_MINIMAL_EXTENDED | REG_ICASE;
/* Match the regex */
if (re_compile_pattern (reg, strlen(reg), &pb) == 0)
{
result = re_search (&pb, str, strlen(str), 0, strlen(str), &re);
if (result != -1)
{
/* Fill the regex_reg global variables */
regex_reg = (int *) &GLODWORD( mod_regex, REGEX_REG);
for (n = 0 ; n < 16 && n <= pb.re_nsub ; n++)
{
string_discard (regex_reg[n]);
regex_reg[n] = string_newa (str + re.start[n], re.end[n] - re.start[n]);
string_use (regex_reg[n]);
}
}
}
/* Free the resources */
free (pb.buffer);
free (pb.fastmap);
string_discard(params[0]);
string_discard(params[1]);
return result;
}
static void _advance_timers( void )
{
int * timer, i ;
int curr_ticktimer = SDL_GetTicks() ;
static int initial_ticktimer[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0} ;
static int ltimer[10] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1} ; // -1 to force initial_ticktimer update
/* TODO: Here add checking for console_mode, don't advance in this mode */
timer = ( int * ) ( &GLODWORD( mod_timers, TIMER ) );
for ( i = 0 ; i < 10 ; i++ )
{
if ( timer[i] != ltimer[i] ) initial_ticktimer[i] = curr_ticktimer - ( timer[i] * 10 ) ;
ltimer[i] = timer[i] = ( curr_ticktimer - initial_ticktimer[i] ) / 10 ;
}
}
int gr_text_put( GRAPH * dest, REGION * clip, int fontid, int x, int y, const unsigned char * text )
{
GRAPH * ch ;
FONT * f ;
uint8_t current_char;
int flags ;
int save8, save16, save32;
if ( !text || !*text ) return -1;
if ( fontid < 0 || fontid >= MAX_FONTS || !fonts[fontid] ) return 0; // Incorrect font type
if ( !dest ) dest = scrbitmap ;
f = fonts[fontid] ;
flags = GLODWORD( libtext, TEXT_FLAGS );
save8 = pixel_color8;
save16 = pixel_color16;
save32 = pixel_color32;
if ( fntcolor8 == -1 )
{
gr_setcolor(( dest->format->depth == 8 ) ? gr_find_nearest_color( 255, 255, 255 ) : gr_rgb_depth( dest->format->depth, 255, 255, 255 ) );
}
else
{
pixel_color8 = fntcolor8;
pixel_color16 = fntcolor16;
pixel_color32 = fntcolor32;
}
while ( *text )
{
switch ( f->charset )
{
case CHARSET_ISO8859:
current_char = dos_to_win[*text];
break;
case CHARSET_CP850:
current_char = *text;
break;
default:
current_char = 0;
break;
}
ch = f->glyph[current_char].bitmap ;
if ( ch )
{
gr_blit( dest, clip, x + f->glyph[current_char].xoffset, y + f->glyph[current_char].yoffset, flags, ch ) ;
}
x += f->glyph[current_char].xadvance ;
text++ ;
}
pixel_color8 = save8;
pixel_color16 = save16;
pixel_color32 = save32;
return 1;
}
void scroll_draw( int n, REGION * clipping )
{
int nproc, x, y, cx, cy ;
static INSTANCE ** proclist = 0;
static int proclist_reserved = 0;
int proclist_count;
REGION r;
int status;
GRAPH * graph, * back, * dest = NULL;
SCROLL_EXTRA_DATA * data;
INSTANCE * i;
if ( n < 0 || n > 9 ) return ;
if ( !scrolls[n].active || !scrolls[n].region || !scrolls[n].graphid ) return ;
graph = scrolls[n].graphid ? bitmap_get( scrolls[n].fileid, scrolls[n].graphid ) : NULL ;
back = scrolls[n].backid ? bitmap_get( scrolls[n].fileid, scrolls[n].backid ) : NULL ;
if ( !graph ) return ; // El fondo de scroll no existe
if ( scrolls[n].backid && !back ) return ; // Grafico no existe
dest = scrolls[n].destid ? bitmap_get( scrolls[n].destfile, scrolls[n].destid ) : NULL ;
data = &(( SCROLL_EXTRA_DATA * ) & GLODWORD( libscroll, SCROLLS ) )[n] ;
/* Dibuja el fondo */
r = *scrolls[n].region;
if ( !dest && clipping ) region_union( &r, clipping );
if ( back )
{
if ( back->ncpoints > 0 && back->cpoints[0].x >= 0 )
{
cx = back->cpoints[0].x ;
cy = back->cpoints[0].y ;
}
else
{
cx = back->width / 2 ;
cy = back->height / 2 ;
}
y = scrolls[n].region->y - scrolls[n].y1 ;
while ( y < scrolls[n].region->y2 )
{
x = scrolls[n].region->x - scrolls[n].x1 ;
while ( x < scrolls[n].region->x2 )
{
gr_blit( dest, &r, x + cx, y + cy, data->flags2, back ) ;
x += back->width ;
}
y += back->height ;
}
}
/* Dibuja el primer plano */
if ( graph->ncpoints > 0 && graph->cpoints[0].x >= 0 )
{
cx = graph->cpoints[0].x ;
cy = graph->cpoints[0].y ;
}
else
{
cx = graph->width / 2 ;
cy = graph->height / 2 ;
}
y = scrolls[n].region->y - scrolls[n].y0 ;
while ( y < scrolls[n].region->y2 )
{
x = scrolls[n].region->x - scrolls[n].x0 ;
while ( x < scrolls[n].region->x2 )
{
gr_blit( dest, &r, x + cx, y + cy, data->flags1, graph ) ;
x += graph->width ;
}
y += graph->height ;
}
/* Crea una lista ordenada de instancias a dibujar */
i = first_instance ;
proclist_count = 0 ;
while ( i )
{
if ( LOCDWORD( libscroll, i, CTYPE ) == C_SCROLL &&
(
(( status = LOCDWORD( libscroll, i, STATUS ) ) & ~STATUS_WAITING_MASK ) == STATUS_RUNNING ||
( status & ~STATUS_WAITING_MASK ) == STATUS_FROZEN
)
)
{
if ( LOCDWORD( libscroll, i, CNUMBER ) && !( LOCDWORD( libscroll, i, CNUMBER ) & ( 1 << n ) ) )
{
i = i->next ;
continue ;
}
if ( proclist_count == proclist_reserved )
{
proclist_reserved += 16 ;
proclist = ( INSTANCE ** ) realloc( proclist, sizeof( INSTANCE * ) * proclist_reserved ) ;
}
proclist[proclist_count++] = i ;
}
i = i->next ;
}
if ( proclist_count )
{
/* Ordena la listilla */
qsort( proclist, proclist_count, sizeof( INSTANCE * ), compare_instances ) ;
/* Visualiza los procesos */
for ( nproc = 0 ; nproc < proclist_count ; nproc++ )
{
x = LOCDWORD( libscroll, proclist[nproc], COORDX ) ;
y = LOCDWORD( libscroll, proclist[nproc], COORDY ) ;
RESOLXY( libscroll, proclist[nproc], x, y );
draw_instance_at( proclist[nproc], &r, x - scrolls[n].posx0 + scrolls[n].region->x, y - scrolls[n].posy0 + scrolls[n].region->y, dest ) ;
}
}
}
void scroll_update( int n )
{
int x0, y0, x1, y1, cx, cy, w, h, speed ;
REGION bbox;
GRAPH * gr, * graph, * back;
SCROLL_EXTRA_DATA * data;
if ( n < 0 || n > 9 ) return ;
if ( !scrolls[n].active || !scrolls[n].region || !scrolls[n].graphid ) return ;
graph = scrolls[n].graphid ? bitmap_get( scrolls[n].fileid, scrolls[n].graphid ) : 0 ;
back = scrolls[n].backid ? bitmap_get( scrolls[n].fileid, scrolls[n].backid ) : 0 ;
if ( !graph ) return ; // El fondo de scroll no existe
if ( scrolls[n].backid && !back ) return ; // Grafico no existe
data = &(( SCROLL_EXTRA_DATA * ) &GLODWORD( libscroll, SCROLLS ) )[n] ;
w = scrolls[n].region->x2 - scrolls[n].region->x + 1 ;
h = scrolls[n].region->y2 - scrolls[n].region->y + 1 ;
scrolls[n].z = data->z ;
scrolls[n].ratio = data->ratio ;
scrolls[n].camera = instance_get( data->camera ) ;
scrolls[n].speed = data->speed ;
if ( data->follows < 0 || data->follows > 9 )
scrolls[n].follows = 0 ;
else
scrolls[n].follows = &scrolls[data->follows] ;
if ( data->region1 < 0 || data->region1 > 31 )
scrolls[n].region1 = 0 ;
else
scrolls[n].region1 = ®ions[data->region1] ;
if ( data->region2 < 0 || data->region2 > 31 )
scrolls[n].region2 = 0 ;
else
scrolls[n].region2 = ®ions[data->region2] ;
/* Actualiza las variables globales (perseguir la camara, etc) */
if ( scrolls[n].follows )
{
if ( scrolls[n].ratio )
{
data->x0 = scrolls[n].follows->x0 * 100 / scrolls[n].ratio ;
data->y0 = scrolls[n].follows->y0 * 100 / scrolls[n].ratio ;
}
else
{
data->x0 = scrolls[n].follows->x0 ;
data->y0 = scrolls[n].follows->y0 ;
}
}
if ( scrolls[n].camera )
{
/* Mira a ver si entra dentro de la region 1 o 2 */
speed = scrolls[n].speed ;
if ( scrolls[n].speed == 0 ) speed = 9999999 ;
/* Update speed */
if (( gr = instance_graph( scrolls[n].camera ) ) )
{
instance_get_bbox( scrolls[n].camera, gr, &bbox );
x0 = bbox.x - data->x0 ;
y0 = bbox.y - data->y0 ;
x1 = bbox.x2 - data->x0 ;
y1 = bbox.y2 - data->y0 ;
if ( scrolls[n].region1 &&
(
x0 < scrolls[n].region1->x2 && y0 < scrolls[n].region1->y2 &&
x1 > scrolls[n].region1->x && y1 > scrolls[n].region1->y
)
)
{
speed = 0 ;
}
else
if ( scrolls[n].region2 )
{
if ( x0 > scrolls[n].region2->x2 ) speed = ( x0 - scrolls[n].region2->x2 );
if ( y0 > scrolls[n].region2->y2 ) speed = ( y0 - scrolls[n].region2->y2 );
if ( x1 < scrolls[n].region2->x ) speed = ( scrolls[n].region2->x - x1 );
if ( y1 < scrolls[n].region2->y ) speed = ( scrolls[n].region2->y - y1 );
}
}
/* Forzar a que esté en el centro de la ventana */
cx = LOCDWORD( libscroll, scrolls[n].camera, COORDX ) ;
cy = LOCDWORD( libscroll, scrolls[n].camera, COORDY ) ;
RESOLXY( libscroll, scrolls[n].camera, cx, cy );
cx -= w / 2 ;
cy -= h / 2 ;
if ( data->x0 < cx ) data->x0 = MIN( data->x0 + speed, cx ) ;
if ( data->y0 < cy ) data->y0 = MIN( data->y0 + speed, cy ) ;
if ( data->x0 > cx ) data->x0 = MAX( data->x0 - speed, cx ) ;
if ( data->y0 > cy ) data->y0 = MAX( data->y0 - speed, cy ) ;
}
/* Scrolls no cíclicos y posición del background */
if ( graph )
{
if ( !( scrolls[n].flags & GRAPH_HWRAP ) ) data->x0 = MAX( 0, MIN( data->x0, ( int )graph->width - w ) ) ;
if ( !( scrolls[n].flags & GRAPH_VWRAP ) ) data->y0 = MAX( 0, MIN( data->y0, ( int )graph->height - h ) ) ;
}
if ( scrolls[n].ratio )
{
data->x1 = data->x0 * 100 / scrolls[n].ratio ;
data->y1 = data->y0 * 100 / scrolls[n].ratio ;
}
if ( back )
{
if ( !( scrolls[n].flags & BACK_HWRAP ) ) data->x1 = MAX( 0, MIN( data->x1, ( int )back->width - w ) ) ;
if ( !( scrolls[n].flags & BACK_VWRAP ) ) data->y1 = MAX( 0, MIN( data->y1, ( int )back->height - h ) ) ;
}
/* Actualiza la posición del scroll según las variables globales */
scrolls[n].posx0 = data->x0 ;
scrolls[n].posy0 = data->y0 ;
scrolls[n].x0 = data->x0 % ( int32_t ) graph->width ;
scrolls[n].y0 = data->y0 % ( int32_t ) graph->height ;
if ( scrolls[n].x0 < 0 ) scrolls[n].x0 += graph->width ;
if ( scrolls[n].y0 < 0 ) scrolls[n].y0 += graph->height ;
if ( back )
{
scrolls[n].x1 = data->x1 % ( int32_t ) back->width ;
scrolls[n].y1 = data->y1 % ( int32_t ) back->height ;
if ( scrolls[n].x1 < 0 ) scrolls[n].x1 += back->width ;
if ( scrolls[n].y1 < 0 ) scrolls[n].y1 += back->height ;
}
}
static int check_collision_with_mouse( INSTANCE * proc1, int colltype )
{
REGION bbox1, bbox2 ;
int x, y, mx, my ;
static GRAPH * bmp = NULL;
switch ( colltype )
{
case COLLISION_BOX:
case COLLISION_CIRCLE:
if ( !get_bbox( &bbox2, proc1 ) ) return 0 ;
case COLLISION_NORMAL:
break;
default:
return 0;
}
mx = GLOINT32( mod_grproc, MOUSEX ) ;
my = GLOINT32( mod_grproc, MOUSEY ) ;
/* Checks the process's bounding box to optimize checking
(only for screen-type objects) */
if ( LOCDWORD( mod_grproc, proc1, CTYPE ) == C_SCREEN )
{
switch ( colltype )
{
case COLLISION_NORMAL:
if ( !get_bbox( &bbox2, proc1 ) ) return 0 ;
if ( bbox2.x > mx || bbox2.x2 < mx || bbox2.y > my || bbox2.y2 < my ) return 0 ;
break;
case COLLISION_BOX:
if ( bbox2.x <= mx && bbox2.x2 >= mx && bbox2.y <= my && bbox2.y2 >= my ) return 1;
return 0;
break;
case COLLISION_CIRCLE:
{
int cx1, cy1, dx1, dy1;
cx1 = bbox2.x + ( dx1 = ( bbox2.x2 - bbox2.x + 1 ) ) / 2 ;
cy1 = bbox2.y + ( dy1 = ( bbox2.y2 - bbox2.y + 1 ) ) / 2 ;
if ( get_distance( cx1, cy1, 0, mx, my, 0 ) < ( dx1 + dy1 ) / 4 ) return 1;
return 0;
break;
}
}
}
/* Creates a temporary bitmap (only once) */
if ( colltype == COLLISION_NORMAL )
{
/* maybe must force this to 32 bits */
if ( bmp && bmp->format->depth != sys_pixel_format->depth ) { bitmap_destroy( bmp ); bmp = NULL; }
if ( !bmp ) bmp = bitmap_new( 0, 2, 1, sys_pixel_format->depth ) ;
if ( !bmp ) return 0 ;
memset( bmp->data, 0, bmp->pitch * bmp->height ) ;
}
/* Retrieves process information */
bbox1.x = 0 ; bbox1.x2 = 1 ;
bbox1.y = 0 ; bbox1.y2 = 0 ;
x = LOCINT32( mod_grproc, proc1, COORDX ) ;
y = LOCINT32( mod_grproc, proc1, COORDY ) ;
RESOLXY( mod_grproc, proc1, x, y );
/* Scroll-type process: check for each region */
if ( LOCDWORD( mod_grproc, proc1, CTYPE ) == C_SCROLL )
{
SCROLL_EXTRA_DATA * data;
scrolldata * scroll;
int i;
if ( GLOEXISTS( mod_grproc, SCROLLS ) )
{
int cnumber = LOCDWORD( mod_grproc, proc1, CNUMBER );
if ( !cnumber ) cnumber = 0xffffffff ;
for ( i = 0 ; i < 10 ; i++ )
{
data = &(( SCROLL_EXTRA_DATA * ) & GLODWORD( mod_grproc, SCROLLS ) )[i] ;
scroll = ( scrolldata * ) data->reserved[0];
if ( scroll && scroll->active && ( cnumber & ( 1 << i ) ) )
{
REGION * r = scroll->region;
switch ( colltype )
{
case COLLISION_NORMAL:
if ( r->x > mx || r->x2 < mx || r->y > my || r->y2 < my ) continue;
draw_at( bmp, x + r->x - mx - scroll->posx0, y + r->y - my - scroll->posy0, &bbox1, proc1 );
switch ( sys_pixel_format->depth )
{
case 8:
if ( *( uint8_t * )bmp->data ) return 1;
break;
case 16:
if ( *( uint16_t * )bmp->data ) return 1;
break;
case 32:
if ( *( uint32_t * )bmp->data ) return 1;
break;
}
break;
case COLLISION_BOX:
if ( bbox2.x <= scroll->posx0 + r->x + mx && bbox2.x2 >= scroll->posx0 + r->x + mx &&
bbox2.y <= scroll->posy0 + r->y + my && bbox2.y2 >= scroll->posy0 + r->y + my ) return 1;
break;
case COLLISION_CIRCLE:
{
int cx1, cy1, dx1, dy1;
cx1 = bbox2.x + ( dx1 = ( bbox2.x2 - bbox2.x + 1 ) ) / 2 ;
cy1 = bbox2.y + ( dy1 = ( bbox2.y2 - bbox2.y + 1 ) ) / 2 ;
if ( get_distance( cx1, cy1, 0, r->x + mx + scroll->posx0, r->y + my + scroll->posy0, 0 ) < ( dx1 + dy1 ) / 4 ) return 1;
break;
}
}
}
}
}
return 0;
}
switch ( colltype )
{
case COLLISION_NORMAL:
/* Collision check (blits into temporary space and checks the resulting pixel) */
draw_at( bmp, x - mx, y - my, &bbox1, proc1 ) ;
switch ( sys_pixel_format->depth )
{
case 8:
if ( *( uint8_t * )bmp->data ) return 1;
break;
case 16:
if ( *( uint16_t * )bmp->data ) return 1;
break;
case 32:
if ( *( uint32_t * )bmp->data ) return 1;
break;
}
break;
case COLLISION_BOX:
if ( bbox2.x <= mx && bbox2.x2 >= mx &&
bbox2.y <= my && bbox2.y2 >= my ) return 1;
break;
case COLLISION_CIRCLE:
{
int cx1, cy1, dx1, dy1;
cx1 = bbox2.x + ( dx1 = ( bbox2.x2 - bbox2.x + 1 ) ) / 2 ;
cy1 = bbox2.y + ( dy1 = ( bbox2.y2 - bbox2.y + 1 ) ) / 2 ;
if ( get_distance( cx1, cy1, 0, mx, my, 0 ) < ( dx1 + dy1 ) / 4 ) return 1;
break;
}
}
return 0 ;
}
static int __moddir_read(__DIR_ST * dh )
{
__DIR_FILEINFO_ST * dif;
char buffer[ 20 ];
int result;
dif = dir_read( dh );
if ( !dif )
{
result = string_new( "" );
string_use( result );
return ( result );
}
/* discard previous strings values */
string_discard( GLODWORD( mod_dir, FILE_NAME ) );
string_discard( GLODWORD( mod_dir, FILE_PATH ) );
string_discard( GLODWORD( mod_dir, FILE_CREATED ) );
string_discard( GLODWORD( mod_dir, FILE_MODIFIED ) );
string_discard( GLODWORD( mod_dir, FILE_ACCESSED ) );
string_discard( GLODWORD( mod_dir, FILE_STATECHG ) );
GLODWORD( mod_dir, FILE_NAME ) = string_new( dif->filename ); string_use( GLODWORD( mod_dir, FILE_NAME ) );
GLODWORD( mod_dir, FILE_PATH ) = string_new( dif->fullpath ); string_use( GLODWORD( mod_dir, FILE_PATH ) );
GLODWORD( mod_dir, FILE_DIRECTORY ) = dif->attributes & DIR_FI_ATTR_DIRECTORY ? 1 : 0;
GLODWORD( mod_dir, FILE_HIDDEN ) = dif->attributes & DIR_FI_ATTR_HIDDEN ? 1 : 0;
GLODWORD( mod_dir, FILE_READONLY ) = dif->attributes & DIR_FI_ATTR_READONLY ? 1 : 0;
GLODWORD( mod_dir, FILE_SIZE ) = dif->size;
/* Store file times */
#ifdef _WIN32
strftime( buffer, 20, "%d/%m/%Y %H:%M:S", &dif->mtime );
GLODWORD( mod_dir, FILE_CREATED ) = string_new( buffer ); string_use( GLODWORD( mod_dir, FILE_CREATED ) );
#else
GLODWORD( mod_dir, FILE_CREATED ) = string_new( "" ); string_use( GLODWORD( mod_dir, FILE_CREATED ) );
#endif
strftime( buffer, 20, "%d/%m/%Y %H:%M:S", &dif->crtime );
GLODWORD( mod_dir, FILE_MODIFIED ) = string_new( buffer ); string_use( GLODWORD( mod_dir, FILE_MODIFIED ) );
strftime( buffer, 20, "%d/%m/%Y %H:%M:S", &dif->atime );
GLODWORD( mod_dir, FILE_ACCESSED ) = string_new( buffer ); string_use( GLODWORD( mod_dir, FILE_ACCESSED ) );
#ifndef _WIN32
strftime( buffer, 20, "%d/%m/%Y %H:%M:S", &dif->ctime );
GLODWORD( mod_dir, FILE_STATECHG ) = string_new( buffer ); string_use( GLODWORD( mod_dir, FILE_STATECHG ) );
#else
GLODWORD( mod_dir, FILE_STATECHG ) = string_new( "" ); string_use( GLODWORD( mod_dir, FILE_STATECHG ) );
#endif
/* Return */
result = GLODWORD( mod_dir, FILE_NAME );
string_use( result );
return result;
}
static int modregex_regex_replace (INSTANCE * my, int * params)
{
const char * reg = string_get(params[0]);
const char * rep = string_get(params[1]);
const char * str = string_get(params[2]);
unsigned reg_len = strlen(reg);
unsigned str_len = strlen(str);
unsigned rep_len = strlen(rep);
char * replacement;
unsigned replacement_len;
int fixed_replacement = strchr(rep, '\\') ? 0:1;
struct re_pattern_buffer pb;
struct re_registers re;
int start[16];
int end[16];
unsigned startpos = 0;
unsigned nextpos;
int regex_filled = 0;
char * result = 0;
unsigned result_allocated = 0;
int result_string = 0;
unsigned n;
int * regex_reg;
/* Alloc a buffer for the resulting string */
result = malloc(128);
result_allocated = 128;
*result = 0;
/* Alloc the pattern resources */
memset (&pb, 0, sizeof(pb));
memset (&re, 0, sizeof(re));
pb.buffer = malloc(4096);
pb.allocated = 4096;
pb.used = 0;
pb.fastmap = malloc(256);
pb.translate = NULL;
pb.fastmap_accurate = 0;
pb.regs_allocated = 16;
re.start = start;
re.end = end;
re_syntax_options = RE_SYNTAX_POSIX_MINIMAL_EXTENDED;
/* Run the regex */
if (re_compile_pattern (reg, reg_len, &pb) == 0)
{
startpos = 0;
while (startpos < str_len)
{
nextpos = re_search (&pb, str, str_len, startpos,
str_len - startpos, &re);
if ((int)nextpos < 0) break;
/* Fill the REGEX_REG global variables */
if (regex_filled == 0)
{
regex_filled = 1;
regex_reg = (int *)&GLODWORD( mod_regex, REGEX_REG);
for (n = 0 ; n < 16 && n <= pb.re_nsub ; n++)
{
string_discard (regex_reg[n]);
regex_reg[n] = string_newa (str + re.start[n], re.end[n] - re.start[n]);
string_use (regex_reg[n]);
}
}
/* Prepare the replacement string */
if (fixed_replacement == 0)
{
int total_length = rep_len;
const char * bptr;
char * ptr;
/* Count the size */
ptr = strchr(rep, '\\');
while (ptr)
{
if (ptr[1] >= '0' && ptr[1] <= '9')
total_length += re.end[ptr[1]-'0'] - re.start[ptr[1]-'0'] - 2;
ptr = strchr(ptr+1, '\\');
}
/* Fill the replacement string */
replacement = calloc (total_length+1, 1);
bptr = rep;
ptr = strchr(rep, '\\');
while (ptr)
{
if (ptr[1] >= '0' && ptr[1] <= '9')
{
strncpy (replacement+strlen(replacement), bptr, ptr-bptr);
strncpy (replacement+strlen(replacement), str + re.start[ptr[1]-'0'], re.end[ptr[1]-'0'] - re.start[ptr[1]-'0']);
bptr = ptr+2;
}
ptr = strchr (ptr+1, '\\');
}
strcat (replacement, bptr);
replacement_len = strlen(replacement);
}
else
{
replacement = (char *)rep;
replacement_len = rep_len;
}
/* Fill the resulting string */
if (result_allocated < strlen(result)+(nextpos-startpos)+1+replacement_len)
{
result_allocated += ((nextpos-startpos+1+replacement_len) & ~127) + 128;
result = realloc(result, result_allocated);
}
result[strlen(result)+(nextpos-startpos)] = 0;
memcpy (result + strlen(result), str+startpos, nextpos-startpos);
strcat (result, replacement);
if (fixed_replacement == 0) free (replacement);
/* Continue the search */
startpos = nextpos+re_match(&pb, str, str_len, nextpos, 0);
if (startpos < nextpos) break;
if (startpos == nextpos) startpos++;
}
}
/* Copy remaining characters */
nextpos = str_len;
if (result_allocated < strlen(result)+(nextpos-startpos)+1)
{
result_allocated += ((nextpos-startpos+1) & ~127) + 128;
result = realloc(result, result_allocated);
}
result[strlen(result)+(nextpos-startpos)] = 0;
memcpy (result + strlen(result), str+startpos, nextpos-startpos);
/* Free resources */
free (pb.buffer);
free (pb.fastmap);
string_discard(params[0]);
string_discard(params[1]);
string_discard(params[2]);
/* Return the new string */
result_string = string_new(result);
string_use(result_string);
free(result);
return result_string;
}
void gr_wait_frame()
{
int frame_ticks ;
frame_count++ ;
/* -------------- */
/* Tomo Tick actual */
frame_ticks = SDL_GetTicks() ;
if ( !FPS_init_sync )
{
FPS_init_sync = FPS_init = SDL_GetTicks() ;
FPS_count_sync = FPS_count = 0 ;
jump = 0;
/* Tiempo inicial del nuevo frame */
last_frame_ticks = frame_ticks ;
return;
}
/* Tiempo transcurrido total del ejecucion del ultimo frame (Frame time en ms) */
* ( float * ) &GLODWORD( librender, FRAME_TIME ) = ( frame_ticks - last_frame_ticks ) / 1000.0f ;
/* -------------- */
FPS_count++ ;
/* -------------- */
if ( fps_value )
{
FPS_count_sync++ ;
ticks_per_frame = ( ( float ) ( frame_ticks - FPS_init_sync ) ) / ( float ) FPS_count_sync ;
fps_partial = 1000.0 / ticks_per_frame ;
if ( fps_partial == fps_value )
{
FPS_init_sync = frame_ticks ;
FPS_count_sync = 0 ;
jump = 0;
}
else if ( fps_partial > fps_value )
{
int delay = FPS_count_sync * frame_ms - ( frame_ticks - FPS_init_sync ) ;
if ( delay > 0 )
{
SDL_Delay( delay ) ;
/* Reajust after delay */
frame_ticks = SDL_GetTicks() ;
ticks_per_frame = ( ( float ) ( frame_ticks - FPS_init_sync ) ) / ( float ) FPS_count_sync ;
fps_partial = 1000.0 / ticks_per_frame ;
}
jump = 0 ;
}
else
{
if ( jump < max_jump ) /* Como no me alcanza el tiempo, voy a hacer skip */
jump++ ; /* No dibujar el frame */
else
{
FPS_init_sync = frame_ticks ;
FPS_count_sync = 0 ;
jump = 0 ;
}
}
}
/* Si paso 1 segundo o mas desde la ultima lectura */
if ( frame_ticks - FPS_init >= 1000 )
{
if ( fps_value )
{
GLODWORD( librender, SPEED_GAUGE ) = FPS_count /*fps_partial*/ * 100.0 / fps_value ;
}
else
{
GLODWORD( librender, SPEED_GAUGE ) = 100 ;
}
GLODWORD( librender, FPS ) = FPS_count ;
FPS_init = frame_ticks ;
FPS_count = 0 ;
}
/* Tiempo inicial del nuevo frame */
last_frame_ticks = frame_ticks ;
}
int mouse_info( INSTANCE * i, REGION * clip, int * z, int * drawme )
{
int mousex ;
int mousey ;
int mousez ;
int mousefile ;
int mousegraph ;
int mouseangle;
int mousesize;
int mouseflags;
int mouseregion;
int changed;
* z = mousez = GLOINT32( libmouse, MOUSEZ );
mousefile = GLODWORD( libmouse, MOUSEFILE );
mousegraph = GLODWORD( libmouse, MOUSEGRAPH );
mouse_map = ( mousegraph > 0 ) ? bitmap_get( mousefile, mousegraph ) : NULL ;
if ( !mouse_map )
{
* drawme = 0;
/*
clip->x = clip->x2 = -2;
clip->y = clip->y2 = -2;
*/
return 0;
}
mousex = GLOINT32( libmouse, MOUSEX );
mousey = GLOINT32( libmouse, MOUSEY );
// mousez = GLODWORD( libmouse, MOUSEZ );
mouseangle = GLOINT32( libmouse, MOUSEANGLE );
mousesize = GLOINT32( libmouse, MOUSESIZE );
mouseflags = GLODWORD( libmouse, MOUSEFLAGS );
mouseregion = GLOINT32( libmouse, MOUSEREGION );
* drawme = 1;
changed =
( mouse_map && mouse_map->modified ) ||
last_mousex != mousex ||
last_mousey != mousey ||
last_mousez != mousez ||
last_mousefile != mousefile ||
last_mousegraph != mousegraph ||
last_mouseangle != mouseangle ||
last_mousesize != mousesize ||
last_mouseflags != mouseflags ||
last_mouseregion != mouseregion ||
(
mouse_map->ncpoints &&
(
last_mousecenterx != mouse_map->cpoints[0].x ||
last_mousecentery != mouse_map->cpoints[0].y
)
)
;
if ( changed )
{
last_mousex = mousex ;
last_mousey = mousey ;
last_mousez = mousez ;
last_mousefile = mousefile ;
last_mousegraph = mousegraph ;
last_mouseangle = mouseangle ;
last_mousesize = mousesize ;
last_mouseflags = mouseflags ;
last_mouseregion = mouseregion ;
if ( mouse_map->ncpoints )
{
last_mousecenterx = mouse_map->cpoints[0].x;
last_mousecentery = mouse_map->cpoints[0].y;
}
else
{
last_mousecenterx = CPOINT_UNDEFINED;
last_mousecentery = CPOINT_UNDEFINED;
}
gr_get_bbox(
clip,
0,
mousex,
mousey,
mouseflags,
mouseangle ,
mousesize ,
mousesize ,
mouse_map ) ;
}
return changed;
}
void do_mouse_events()
{
SDL_Event e ;
static int last_mouse_x = -1, last_mouse_y = -1 ;
/* Update events */
/* Mouse.x/y change affects the cursor directly */
if (
( last_mouse_x != -1 && GLOINT32( libmouse, MOUSEX ) != last_mouse_x ) ||
( last_mouse_y != -1 && GLOINT32( libmouse, MOUSEY ) != last_mouse_y ) )
{
if ( scale_resolution != 0 )
{
SDL_WarpMouse( GLOINT32( libmouse, MOUSEX ) / ( (double)screen->w / (double)scale_screen->w ), GLOINT32( libmouse, MOUSEY ) / ( (double)screen->h / (double)scale_screen->h ) ) ;
}
else if ( enable_scale || scale_mode != SCALE_NONE )
{
SDL_WarpMouse( GLOINT32( libmouse, MOUSEX ) * 2 , GLOINT32( libmouse, MOUSEY ) * 2 ) ;
}
else
{
SDL_WarpMouse( GLOINT32( libmouse, MOUSEX ), GLOINT32( libmouse, MOUSEY ) ) ;
}
}
/* Process the independant mouse events */
GLODWORD( libmouse, MOUSEWHEELUP ) = 0 ;
GLODWORD( libmouse, MOUSEWHEELDOWN ) = 0 ;
while ( SDL_PeepEvents( &e, 1, SDL_GETEVENT, SDL_MOUSEEVENTMASK ) > 0 )
{
switch ( e.type )
{
case SDL_MOUSEMOTION:
if ( scale_resolution != 0 )
{
GLOINT32( libmouse, MOUSEX ) = e.motion.x * ( (double)screen->w / (double)scale_screen->w );
GLOINT32( libmouse, MOUSEY ) = e.motion.y * ( (double)screen->h / (double)scale_screen->h );
}
else if ( enable_scale || scale_mode != SCALE_NONE )
{
GLOINT32( libmouse, MOUSEX ) = e.motion.x / 2 ;
GLOINT32( libmouse, MOUSEY ) = e.motion.y / 2 ;
}
else
{
GLOINT32( libmouse, MOUSEX ) = e.motion.x ;
GLOINT32( libmouse, MOUSEY ) = e.motion.y ;
}
break ;
case SDL_MOUSEBUTTONDOWN:
if ( e.button.button == SDL_BUTTON_LEFT ) GLODWORD( libmouse, MOUSELEFT ) = 1 ;
if ( e.button.button == SDL_BUTTON_MIDDLE ) GLODWORD( libmouse, MOUSEMIDDLE ) = 1 ;
if ( e.button.button == SDL_BUTTON_RIGHT ) GLODWORD( libmouse, MOUSERIGHT ) = 1 ;
if ( e.button.button == SDL_BUTTON_WHEELUP ) GLODWORD( libmouse, MOUSEWHEELUP )++ ;
if ( e.button.button == SDL_BUTTON_WHEELDOWN ) GLODWORD( libmouse, MOUSEWHEELDOWN )++ ;
break ;
case SDL_MOUSEBUTTONUP:
if ( e.button.button == SDL_BUTTON_LEFT ) GLODWORD( libmouse, MOUSELEFT ) = 0 ;
if ( e.button.button == SDL_BUTTON_MIDDLE ) GLODWORD( libmouse, MOUSEMIDDLE ) = 0 ;
if ( e.button.button == SDL_BUTTON_RIGHT ) GLODWORD( libmouse, MOUSERIGHT ) = 0 ;
break ;
}
}
last_mouse_x = GLOINT32( libmouse, MOUSEX ) ;
last_mouse_y = GLOINT32( libmouse, MOUSEY ) ;
}
