void init_endlevel()
{
//##satellite_bitmap = bm_load("earth.bbm");
//##terrain_bitmap = bm_load("moon.bbm");
//##
//##load_terrain("matt5b.bbm"); //load bitmap as height array
//##//load_terrain("ttest2.bbm"); //load bitmap as height array
#ifdef STATION_ENABLED
station_bitmap = bm_load("steel3.bbm");
station_bitmap_list[0] = &station_bitmap;
station_modelnum = load_polygon_model("station.pof",1,station_bitmap_list,NULL);
#endif
//!! exit_bitmap = bm_load("steel1.bbm");
//!! exit_bitmap_list[0] = &exit_bitmap;
//!! exit_modelnum = load_polygon_model("exit01.pof",1,exit_bitmap_list,NULL);
//!! destroyed_exit_modelnum = load_polygon_model("exit01d.pof",1,exit_bitmap_list,NULL);
generate_starfield();
gr_init_bitmap_data (&terrain_bm_instance);
gr_init_bitmap_data (&satellite_bm_instance);
}
int show_title_screen( char * filename, int allow_keys )
{
fix timer;
int pcx_error;
grs_bitmap title_bm;
gr_init_bitmap_data (&title_bm);
if ((pcx_error=pcx_read_bitmap( filename, &title_bm, BM_LINEAR, New_pal ))!=PCX_ERROR_NONE) {
printf( "File '%s', PCX load error: %s (%i)\n (No big deal, just no title screen.)\n",filename, pcx_errormsg(pcx_error), pcx_error);
mprintf((0, "File '%s', PCX load error: %s (%i)\n (No big deal, just no title screen.)\n",filename, pcx_errormsg(pcx_error), pcx_error));
Int3();
gr_free_bitmap_data (&title_bm);
return 0;
}
// vfx_set_palette_sub( New_pal );
#ifdef OGL
gr_palette_load(New_pal);
#else
gr_palette_clear();
#endif
gr_set_current_canvas( NULL );
show_fullscr(&title_bm);
//added on 9/13/98 by adb to make update-needing arch's work
gr_update();
//end addition - adb
gr_free_bitmap_data (&title_bm);
if (allow_keys > 2 || gr_palette_fade_in( New_pal, 32, allow_keys ) || allow_keys > 1) {
return 1;
}
gr_palette_load( New_pal );
timer = timer_get_fixed_seconds() + i2f(3);
while (1) {
if ( local_key_inkey() && allow_keys ) break;
if ( timer_get_fixed_seconds() > timer ) break;
}
if (gr_palette_fade_out( New_pal, 32, allow_keys ))
return 1;
return 0;
}
void kmatrix_view(int network)
{
kmatrix_screen *km;
window *wind;
int i = 0;
MALLOC(km, kmatrix_screen, 1);
if (!km)
return;
gr_init_bitmap_data(&km->background);
if (pcx_read_bitmap(STARS_BACKGROUND, &km->background, BM_LINEAR, gr_palette) != PCX_ERROR_NONE)
{
d_free(km);
return;
}
gr_palette_load(gr_palette);
km->network = network;
km->end_time = -1;
km->playing = 0;
set_screen_mode( SCREEN_MENU );
game_flush_inputs();
for (i=0;i<MAX_PLAYERS;i++)
digi_kill_sound_linked_to_object (Players[i].objnum);
wind = window_create(&grd_curscreen->sc_canvas, 0, 0, SWIDTH, SHEIGHT, (int (*)(window *, d_event *, void *))kmatrix_handler, km);
if (!wind)
{
d_free(km);
return;
}
while (window_exists(wind))
event_process();
gr_free_bitmap_data(&km->background);
d_free(km);
}
void do_screen_message(char *fmt, ...)
{
va_list arglist;
grs_bitmap background;
char msg[1024];
if (Game_mode & GM_MULTI)
return;
gr_init_bitmap_data(&background);
if (pcx_read_bitmap(Menu_pcx_name, &background, BM_LINEAR, gr_palette) != PCX_ERROR_NONE)
return;
gr_palette_load(gr_palette);
va_start(arglist, fmt);
vsprintf(msg, fmt, arglist);
va_end(arglist);
nm_messagebox1(NULL, (int (*)(newmenu *, d_event *, void *))draw_rock, &background, 1, TXT_OK, msg);
gr_free_bitmap_data(&background);
}
void do_automap( int key_code )
{
int pcx_error;
ubyte pal[256*3];
window *automap_wind = NULL;
automap *am;
CALLOC(am, automap, 1);
if (am)
{
automap_wind = window_create(&grd_curscreen->sc_canvas, 0, 0, SWIDTH, SHEIGHT, (int (*)(window *, d_event *, void *)) automap_handler, am);
}
if (automap_wind == NULL)
{
Warning("Out of memory");
return;
}
am->leave_mode = 0;
am->pause_game = 1; // Set to 1 if everything is paused during automap...No pause during net.
am->max_segments_away = 0;
am->segment_limit = 1;
am->num_edges = 0;
am->highest_edge_index = -1;
am->max_edges = Num_segments*12;
MALLOC(am->edges, Edge_info, am->max_edges);
MALLOC(am->drawingListBright, int, am->max_edges);
if (!am->edges || !am->drawingListBright)
{
if (am->edges)
d_free(am->edges);
if (am->drawingListBright)
d_free(am->drawingListBright);
Warning("Out of memory");
return;
}
am->zoom = 0x9000;
am->farthest_dist = (F1_0 * 20 * 50); // 50 segments away
am->viewDist = 0;
init_automap_colors(am);
key_code = key_code; // disable warning...
if ((Game_mode & GM_MULTI) && (!Endlevel_sequence))
am->pause_game = 0;
if (am->pause_game) {
window_set_visible(Game_wind, 0);
}
if (!am->pause_game) {
am->old_wiggle = ConsoleObject->mtype.phys_info.flags & PF_WIGGLE; // Save old wiggle
ConsoleObject->mtype.phys_info.flags &= ~PF_WIGGLE; // Turn off wiggle
}
//Max_edges = min(MAX_EDGES_FROM_VERTS(Num_vertices),MAX_EDGES); //make maybe smaller than max
gr_set_current_canvas(NULL);
automap_build_edge_list(am);
if ( am->viewDist==0 )
am->viewDist = ZOOM_DEFAULT;
am->viewMatrix = Objects[Players[Player_num].objnum].orient;
am->tangles.p = PITCH_DEFAULT;
am->tangles.h = 0;
am->tangles.b = 0;
am->view_target = Objects[Players[Player_num].objnum].pos;
if (PlayerCfg.AutomapFreeFlight)
vm_vec_scale_add(&am->view_position, &Objects[Players[Player_num].objnum].pos, &am->viewMatrix.fvec, -ZOOM_DEFAULT );
am->t1 = am->entry_time = timer_query();
am->t2 = am->t1;
//Fill in Automap_visited from Objects[Players[Player_num].objnum].segnum
am->max_segments_away = set_segment_depths(Objects[Players[Player_num].objnum].segnum, Automap_visited);
am->segment_limit = am->max_segments_away;
adjust_segment_limit(am, am->segment_limit);
// ZICO - code from above to show frame in OGL correctly. Redundant, but better readable.
// KREATOR - Now applies to all platforms so double buffering is supported
gr_init_bitmap_data (&am->automap_background);
pcx_error = pcx_read_bitmap(MAP_BACKGROUND_FILENAME, &am->automap_background, BM_LINEAR, pal);
if (pcx_error != PCX_ERROR_NONE)
Error("File %s - PCX error: %s", MAP_BACKGROUND_FILENAME, pcx_errormsg(pcx_error));
gr_remap_bitmap_good(&am->automap_background, pal, -1, -1);
gr_init_sub_canvas(&am->automap_view, &grd_curscreen->sc_canvas, (SWIDTH/23), (SHEIGHT/6), (SWIDTH/1.1), (SHEIGHT/1.45));
gr_palette_load( gr_palette );
Automap_active = 1;
}
void modex_print_message(int x, int y, char *str)
{
#ifndef AUTOMAP_DIRECT_RENDER
#ifndef AUTOMAP_NO_PAGING
int i;
for (i=0; i<2; i++ ) {
gr_set_current_canvas(&Pages[i]);
#else
{
gr_set_current_canvas(OffscreenPage);
#endif
#endif
modex_printf(x, y, str, GFONT_MEDIUM_1);
#ifndef AUTOMAP_DIRECT_RENDER
}
gr_set_current_canvas(&DrawingPages[current_page]);
#endif
}
extern void GameLoop(int, int );
extern int set_segment_depths(int start_seg, ubyte *segbuf);
u_int32_t automap_mode = SM(640,480);
int automap_width = 640;
int automap_height = 480;
int automap_use_game_res=0;
int nice_automap=0;
void do_automap( int key_code ) {
int done=0;
vms_matrix tempm;
vms_angvec tangles;
int leave_mode=0;
int first_time=1;
// int pcx_error;
int c;
// char filename[] = "MAP.PCX";
fix entry_time;
int pause_game=1; // Set to 1 if everything is paused during automap...No pause during net.
fix t1, t2;
control_info saved_control_info;
grs_bitmap Automap_background;
int Max_segments_away = 0;
int SegmentLimit = 1;
//added on 10/28/98 by adb to fix compile versions
#if !defined (NDEBUG) || (!defined(AUTOMAP_NO_PAGING) && !defined(AUTOMAP_DIRECT_RENDER))
int i;
#endif
key_code = key_code; // disable warning...
if ((Game_mode & GM_MULTI) && (Function_mode == FMODE_GAME) && (!Endlevel_sequence))
pause_game = 0;
if (pause_game)
stop_time();
create_name_canv();
Max_edges = min(MAX_EDGES_FROM_VERTS(Num_vertices),MAX_EDGES); //make maybe smaller than max
//Edges = malloc( sizeof(Edge_info)*Max_edges);
//if ( Edges == NULL ) {
// mprintf((0, "Couldn't get %dK for automap!", sizeof(Edge_info)*Max_edges/1024));
// return;
//}
//DrawingListBright = malloc( sizeof(short)*Max_edges);
//if ( DrawingListBright == NULL ) {
// mprintf((0, "Couldn't get %dK for automap!", sizeof(short)*Max_edges/1024));
// return;
//}
mprintf( (0, "Num_vertices=%d, Max_edges=%d, (MAX:%d)\n", Num_vertices, Max_edges, MAX_EDGES ));
mprintf( (0, "Allocated %d K for automap edge list\n", (sizeof(Edge_info)+sizeof(short))*Max_edges/1024 ));
//edit 4/23/99 Matt Mueller - don't switch res unless we need to
if (grd_curscreen->sc_mode != AUTOMAP_MODE)
gr_set_mode( AUTOMAP_MODE );
else
gr_set_current_canvas(NULL);
//end edit -MM
automap_width=grd_curscreen->sc_canvas.cv_bitmap.bm_w;
automap_height=grd_curscreen->sc_canvas.cv_bitmap.bm_h;
gr_palette_clear();
#ifndef AUTOMAP_DIRECT_RENDER
gr_init_sub_canvas(&Pages[0],grd_curcanv,0,0,automap_width,automap_height);
#ifndef AUTOMAP_NO_PAGING
// NOTICE: should be 0,401! FIXME!
gr_init_sub_canvas(&Pages[1],grd_curcanv,0,0,automap_width,automap_height);
gr_init_sub_canvas(&DrawingPages[0],&Pages[0],0,0,automap_width,automap_height);
gr_init_sub_canvas(&DrawingPages[1],&Pages[1],0,0,automap_width,automap_height);
#else
OffscreenPage = gr_create_canvas( automap_width,automap_height );
if (!OffscreenPage) {
nm_messagebox("No memory for automap", 1, "Ok");
return;
}
gr_init_sub_canvas(&DrawingPages[0],OffscreenPage,0,0,automap_width,automap_height);
#endif
#endif
gr_init_bitmap_data (&Automap_background);
// pcx_error = pcx_read_bitmap(filename,&Automap_background,BM_LINEAR,NULL);
// if ( pcx_error != PCX_ERROR_NONE ) {
// printf("File %s - PCX error: %s",filename,pcx_errormsg(pcx_error));
// Error("File %s - PCX error: %s",filename,pcx_errormsg(pcx_error));
// return;
// }
#ifndef AUTOMAP_DIRECT_RENDER
#ifndef AUTOMAP_NO_PAGING
for (i=0; i<2; i++ ) {
gr_set_current_canvas(&Pages[i]);
#else
{
gr_set_current_canvas(OffscreenPage);
#endif
// gr_bitmap( 0, 0, &Automap_background );
// modex_printf( 40, 22,TXT_AUTOMAP,GFONT_BIG_1);
// modex_printf( 70,353,TXT_TURN_SHIP,GFONT_SMALL);
// modex_printf( 70,369,TXT_SLIDE_UPDOWN,GFONT_SMALL);
// modex_printf( 70,385,TXT_VIEWING_DISTANCE,GFONT_SMALL);
}
#ifdef AUTOMAP_NO_PAGING
//killed 05/17/99 Matt Mueller - this seems to merely copy undefined bytes around.. not needed
//--killed-- gr_bm_ubitblt(automap_width,automap_height, 0, 0, 0, 0, &OffscreenPage->cv_bitmap,&Pages[0].cv_bitmap);
//end kill -MM
#endif
gr_free_bitmap_data (&Automap_background);
gr_set_current_canvas(&DrawingPages[current_page]);
#endif
automap_build_edge_list();
if ( ViewDist==0 )
ViewDist = ZOOM_DEFAULT;
ViewMatrix = Objects[Players[Player_num].objnum].orient;
tangles.p = PITCH_DEFAULT;
tangles.h = 0;
tangles.b = 0;
done = 0;
view_target = Objects[Players[Player_num].objnum].pos;
t1 = entry_time = timer_get_fixed_seconds();
t2 = t1;
//Fill in Automap_visited from Objects[Players[Player_num].objnum].segnum
Max_segments_away = set_segment_depths(Objects[Players[Player_num].objnum].segnum, Automap_visited);
SegmentLimit = Max_segments_away;
adjust_segment_limit(SegmentLimit);
while(!done) {
if ( leave_mode==0 && Controls.automap_state && (timer_get_fixed_seconds()-entry_time)>LEAVE_TIME)
leave_mode = 1;
if ( !Controls.automap_state && (leave_mode==1) )
done=1;
if (!pause_game) {
ushort old_wiggle;
saved_control_info = Controls; // Save controls so we can zero them
memset(&Controls,0,sizeof(control_info)); // Clear everything...
old_wiggle = ConsoleObject->mtype.phys_info.flags & PF_WIGGLE; // Save old wiggle
ConsoleObject->mtype.phys_info.flags &= ~PF_WIGGLE; // Turn off wiggle
#ifdef NETWORK
if (multi_menu_poll())
done = 1;
#endif
// GameLoop( 0, 0 ); // Do game loop with no rendering and no reading controls.
ConsoleObject->mtype.phys_info.flags |= old_wiggle; // Restore wiggle
Controls = saved_control_info;
}
controls_read_all();
if ( Controls.automap_down_count ) {
if (leave_mode==0)
done = 1;
c = 0;
}
while( (c=key_inkey()) ) {
switch( c ) {
#ifndef NDEBUG
case KEY_BACKSP: Int3(); break;
#endif
case KEY_PRINT_SCREEN: save_screen_shot(1); break;
case KEY_ESC:
if (leave_mode==0)
done = 1;
break;
case KEY_ALTED+KEY_F: // Alt+F shows full map, if cheats enabled
if (Cheats_enabled)
{
uint t;
t = Players[Player_num].flags;
Players[Player_num].flags |= PLAYER_FLAGS_MAP_ALL_CHEAT;
automap_build_edge_list();
Players[Player_num].flags=t;
}
break;
#ifndef NDEBUG
case KEY_DEBUGGED+KEY_F: {
for (i=0; i<=Highest_segment_index; i++ )
Automap_visited[i] = 1;
automap_build_edge_list();
Max_segments_away = set_segment_depths(Objects[Players[Player_num].objnum].segnum, Automap_visited);
SegmentLimit = Max_segments_away;
adjust_segment_limit(SegmentLimit);
}
break;
#endif
case KEY_MINUS:
if (SegmentLimit > 1) {
SegmentLimit--;
adjust_segment_limit(SegmentLimit);
}
break;
case KEY_EQUAL:
if (SegmentLimit < Max_segments_away) {
SegmentLimit++;
adjust_segment_limit(SegmentLimit);
}
break;
}
}
if ( Controls.fire_primary_down_count ) {
// Reset orientation
ViewDist = ZOOM_DEFAULT;
tangles.p = PITCH_DEFAULT;
tangles.h = 0;
tangles.b = 0;
view_target = Objects[Players[Player_num].objnum].pos;
}
ViewDist -= Controls.forward_thrust_time*ZOOM_SPEED_FACTOR;
tangles.p += fixdiv( Controls.pitch_time, ROT_SPEED_DIVISOR );
tangles.h += fixdiv( Controls.heading_time, ROT_SPEED_DIVISOR );
tangles.b += fixdiv( Controls.bank_time, ROT_SPEED_DIVISOR*2 );
if ( Controls.vertical_thrust_time || Controls.sideways_thrust_time ) {
vms_angvec tangles1;
vms_vector old_vt;
old_vt = view_target;
tangles1 = tangles;
vm_angles_2_matrix(&tempm,&tangles1);
vm_matrix_x_matrix(&ViewMatrix,&Objects[Players[Player_num].objnum].orient,&tempm);
vm_vec_scale_add2( &view_target, &ViewMatrix.uvec, Controls.vertical_thrust_time*SLIDE_SPEED );
vm_vec_scale_add2( &view_target, &ViewMatrix.rvec, Controls.sideways_thrust_time*SLIDE_SPEED );
if ( vm_vec_dist_quick( &view_target, &Objects[Players[Player_num].objnum].pos) > i2f(1000) ) {
view_target = old_vt;
}
}
vm_angles_2_matrix(&tempm,&tangles);
vm_matrix_x_matrix(&ViewMatrix,&Objects[Players[Player_num].objnum].orient,&tempm);
if ( ViewDist < ZOOM_MIN_VALUE ) ViewDist = ZOOM_MIN_VALUE;
if ( ViewDist > ZOOM_MAX_VALUE ) ViewDist = ZOOM_MAX_VALUE;
draw_automap();
if ( first_time ) {
first_time = 0;
gr_palette_load( gr_palette );
}
t2 = timer_get_fixed_seconds();
while (t2-t1<F1_0/100){//ogl is fast enough that the automap can read the input too fast and you start to turn really slow. So delay a bit (and free up some cpu :)
if (nice_automap)
d_delay(1);
t2 = timer_get_fixed_seconds();
}
if (pause_game)
FrameTime=t2-t1;
t1 = t2;
}
//free(Edges);
//free(DrawingListBright);
gr_free_canvas(name_canv); name_canv=NULL;
#ifdef AUTOMAP_NO_PAGING
gr_free_canvas(OffscreenPage);
OffscreenPage = NULL;
#endif
mprintf( (0, "Automap memory freed\n" ));
game_flush_inputs();
if (pause_game)
start_time();
}
void adjust_segment_limit(int SegmentLimit)
{
int i,e1;
Edge_info * e;
mprintf(( 0, "Seglimit: %d\n", SegmentLimit ));
for (i=0; i<=Highest_edge_index; i++ ) {
e = &Edges[i];
e->flags |= EF_TOO_FAR;
for (e1=0; e1<e->num_faces; e1++ ) {
if ( Automap_visited[e->segnum[e1]] <= SegmentLimit ) {
e->flags &= (~EF_TOO_FAR);
break;
}
}
}
}
// -----------------------------------------------------------------------------
// Return true if message got aborted by user (pressed ESC), else return false.
int show_briefing_message(int screen_num, char *message)
{
int prev_ch=-1;
int ch, done=0;
briefing_screen *bsp = &Briefing_screens[screen_num];
int delay_count = KEY_DELAY_DEFAULT;
int key_check;
int robot_num=-1;
int rval=0;
int tab_stop=0;
int flashing_cursor=0;
int new_page=0;
int text_ulx = rescale_x(bsp->text_ulx);
int text_uly = rescale_y(bsp->text_uly);
Bitmap_name[0] = 0;
Current_color = 0;
// mprintf((0, "Going to print message [%s] at x=%i, y=%i\n", message, x, y));
gr_set_curfont( GAME_FONT );
init_char_pos(text_ulx, text_uly);
while (!done) {
ch = *message++;
if (ch == '$') {
ch = *message++;
if (ch == 'C') {
Current_color = get_message_num(&message)-1;
Assert((Current_color >= 0) && (Current_color < MAX_BRIEFING_COLORS));
prev_ch = 10;
} else if (ch == 'F') { // toggle flashing cursor
flashing_cursor = !flashing_cursor;
prev_ch = 10;
while (*message++ != 10)
;
} else if (ch == 'T') {
tab_stop = get_message_num(&message);
prev_ch = 10; // read to eoln
} else if (ch == 'R') {
if (Robot_canv != NULL)
{free(Robot_canv); Robot_canv=NULL;}
init_spinning_robot();
robot_num = get_message_num(&message);
prev_ch = 10; // read to eoln
} else if (ch == 'N') {
//--grs_bitmap *bitmap_ptr;
if (Robot_canv != NULL)
{free(Robot_canv); Robot_canv=NULL;}
get_message_name(&message, Bitmap_name);
strcat(Bitmap_name, "#0");
Animating_bitmap_type = 0;
prev_ch = 10;
} else if (ch == 'O') {
if (Robot_canv != NULL)
{free(Robot_canv); Robot_canv=NULL;}
get_message_name(&message, Bitmap_name);
strcat(Bitmap_name, "#0");
Animating_bitmap_type = 1;
prev_ch = 10;
} else if (ch == 'B') {
char bitmap_name[32];
grs_bitmap guy_bitmap;
ubyte temp_palette[768];
int iff_error;
if (Robot_canv != NULL)
{free(Robot_canv); Robot_canv=NULL;}
get_message_name(&message, bitmap_name);
strcat(bitmap_name, ".bbm");
gr_init_bitmap_data (&guy_bitmap);
iff_error = iff_read_bitmap(bitmap_name, &guy_bitmap, BM_LINEAR, temp_palette);
Assert(iff_error == IFF_NO_ERROR);
show_briefing_bitmap(&guy_bitmap);
gr_free_bitmap_data (&guy_bitmap);
prev_ch = 10;
// } else if (ch == 'B') {
// if (Robot_canv != NULL)
// {free(Robot_canv); Robot_canv=NULL;}
//
// bitmap_num = get_message_num(&message);
// if (bitmap_num != -1)
// show_briefing_bitmap(Textures[bitmap_num]);
// prev_ch = 10; // read to eoln
} else if (ch == 'S') {
int keypress;
fix start_time;
fix time_out_value;
start_time = timer_get_fixed_seconds();
start_time = timer_get_approx_seconds();
time_out_value = start_time + i2f(60*5); // Wait 1 minute...
//added on 9/13/98 by adb to make arch's requiring updates work
gr_update();
//end changes by adb
while ( (keypress = local_key_inkey()) == 0 ) { // Wait for a key
if ( timer_get_approx_seconds() > time_out_value ) {
keypress = 0;
break; // Time out after 1 minute..
}
while (timer_get_fixed_seconds() < start_time + KEY_DELAY_DEFAULT/2)
;
flash_cursor(flashing_cursor);
show_spinning_robot_frame(robot_num);
show_bitmap_frame();
//added on 9/13/98 by adb to make arch's requiring updates work
gr_update();
//end changes by adb
start_time += KEY_DELAY_DEFAULT/2;
}
#ifndef NDEBUG
if (keypress == KEY_BACKSP)
Int3();
#endif
if (keypress == KEY_ESC)
rval = 1;
flashing_cursor = 0;
done = 1;
} else if (ch == 'P') { // New page.
new_page = 1;
while (*message != 10) {
message++; // drop carriage return after special escape sequence
}
message++;
prev_ch = 10;
//Begin D1X addition
} else if (ch == '$' || ch == ';') { // Print a $/;
prev_ch = ch;
Briefing_text_x += show_char_delay((char) ch, delay_count, robot_num, flashing_cursor);
//End D1X addition
}
} else if (ch == '\t') { // Tab
if (Briefing_text_x - text_ulx < tab_stop)
Briefing_text_x = text_ulx + tab_stop;
} else if ((ch == ';') && (prev_ch == 10)) {
while (*message++ != 10)
;
prev_ch = 10;
} else if (ch == '\\') {
prev_ch = ch;
} else if (ch == 10) {
if (prev_ch != '\\') {
prev_ch = ch;
Briefing_text_y += GAME_FONT->ft_h+GAME_FONT->ft_h*3/5;
Briefing_text_x = text_ulx;
if (Briefing_text_y > text_uly + rescale_y(bsp->text_height)) {
load_briefing_screen(screen_num);
Briefing_text_x = text_ulx;
Briefing_text_y = text_uly;
}
} else {
if (ch == 13)
Int3();
prev_ch = ch;
}
} else {
prev_ch = ch;
Briefing_text_x += show_char_delay((char) ch, delay_count, robot_num, flashing_cursor);
}
//added/changed on 9/13/98 by adb to speed up briefings after pressing a key with SDL
// Check for Esc -> abort.
if(delay_count)
key_check=local_key_inkey();
else
key_check=0;
//end change - adb
if ( key_check == KEY_ESC ) {
rval = 1;
done = 1;
}
if ( key_check == KEY_ALTED+KEY_F2 )
title_save_game();
if ((key_check == KEY_SPACEBAR) || (key_check == KEY_ENTER))
delay_count = 0;
if (Briefing_text_x > text_ulx + rescale_x(bsp->text_width)) {
Briefing_text_x = text_ulx;
Briefing_text_y += GAME_FONT->ft_h+GAME_FONT->ft_h*3/5;
}
if ((new_page) || (Briefing_text_y > text_uly + rescale_y(bsp->text_height))) {
fix start_time = 0;
fix time_out_value = 0;
int keypress;
new_page = 0;
start_time = timer_get_approx_seconds();
time_out_value = start_time + i2f(60*5); // Wait 1 minute...
//added on 9/13/98 by adb to make arch's requiring updates work
gr_update();
//end changes by adb
while ( (keypress = local_key_inkey()) == 0 ) { // Wait for a key
if ( timer_get_approx_seconds() > time_out_value ) {
keypress = 0;
break; // Time out after 1 minute..
}
while (timer_get_approx_seconds() < start_time + KEY_DELAY_DEFAULT/2)
;
flash_cursor(flashing_cursor);
show_spinning_robot_frame(robot_num);
show_bitmap_frame();
//added on 9/13/98 by adb to make arch's requiring updates work
gr_update();
//end changes by adb
start_time += KEY_DELAY_DEFAULT/2;
}
robot_num = -1;
#ifndef NDEBUG
if (keypress == KEY_BACKSP)
Int3();
#endif
if (keypress == KEY_ESC) {
rval = 1;
done = 1;
}
load_briefing_screen(screen_num);
Briefing_text_x = text_ulx;
Briefing_text_y = text_uly;
delay_count = KEY_DELAY_DEFAULT;
}
}
if (Robot_canv != NULL)
{free(Robot_canv); Robot_canv=NULL;}
return rval;
}
