void title_save_game()
{
grs_canvas * save_canv;
grs_canvas * save_canv_data;
grs_font * save_font;
ubyte palette[768];
if ( Next_level_num == 0 ) return;
save_canv = grd_curcanv;
save_font = grd_curcanv->cv_font;
save_canv_data = gr_create_canvas( grd_curcanv->cv_bitmap.bm_w, grd_curcanv->cv_bitmap.bm_h );
gr_set_current_canvas(save_canv_data);
gr_ubitmap(0,0,&save_canv->cv_bitmap);
gr_set_current_canvas(save_canv);
gr_clear_canvas(gr_find_closest_color_current( 0, 0, 0));
gr_palette_read( palette );
gr_palette_load( gr_palette );
#ifndef SHAREWARE
state_save_all(1);
#endif
gr_palette_clear();
gr_set_current_canvas(save_canv);
gr_ubitmap(0,0,&save_canv_data->cv_bitmap);
gr_palette_load( palette );
gr_set_curfont(save_font);
}
//shows the current texture, updating the window and printing the name, base
//on CurrentTexture
texpage_show_current()
{
gr_set_current_canvas(TmapCurrent->canvas);
PIGGY_PAGE_IN(Textures[CurrentTexture]);
gr_ubitmap(0,0, Textures[CurrentTexture]);
texpage_display_name( TmapInfo[CurrentTexture].filename );
}
//Redraw the list of textures, based on TexturePage
texpage_redraw()
{
int i;
for (i=0; i<TMAPS_PER_PAGE; i++ )
{
gr_set_current_canvas(TmapBox[i]->canvas);
if (i+TexturePage*TMAPS_PER_PAGE < Num_tmaps )
gr_ubitmap(0,0, Textures[TmapList[i+TexturePage*TMAPS_PER_PAGE]]);
else
gr_clear_canvas( CGREY );
}
}
//Redraw the list of textures, based on TexturePage
void texpage_redraw()
{
int i;
for (i = 0; i < TMAPS_PER_PAGE; i++)
{
gr_set_current_canvas(TmapBox[i]->canvas);
if (i + TexturePage*TMAPS_PER_PAGE < NumTextures)
{
PIGGY_PAGE_IN(Textures[i + TexturePage*TMAPS_PER_PAGE]);
gr_ubitmap(0, 0, &GameBitmaps[Textures[i + TexturePage*TMAPS_PER_PAGE].index]);
} else
gr_clear_canvas( CGREY );
}
}
int trigger_dialog_handler(UI_DIALOG *dlg, d_event *event, trigger_dialog *t)
{
int i;
short Markedwall, trigger_num;
int keypress = 0;
int rval = 0;
Assert(MainWindow != NULL);
if (!Markedsegp) {
close_trigger_window();
return 0;
}
//------------------------------------------------------------
// Call the ui code..
//------------------------------------------------------------
ui_button_any_drawn = 0;
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
//------------------------------------------------------------
// If we change walls, we need to reset the ui code for all
// of the checkboxes that control the wall flags.
//------------------------------------------------------------
Markedwall = Markedsegp->sides[Markedside].wall_num;
if (Markedwall != -1)
trigger_num = Walls[Markedwall].trigger;
else trigger_num = -1;
if (t->old_trigger_num != trigger_num)
{
if (trigger_num != -1)
{
trigger *trig = &Triggers[trigger_num];
ui_checkbox_check(t->triggerFlag[0], trig->flags & TRIGGER_CONTROL_DOORS);
ui_checkbox_check(t->triggerFlag[1], trig->flags & TRIGGER_SHIELD_DAMAGE);
ui_checkbox_check(t->triggerFlag[2], trig->flags & TRIGGER_ENERGY_DRAIN);
ui_checkbox_check(t->triggerFlag[3], trig->flags & TRIGGER_EXIT);
ui_checkbox_check(t->triggerFlag[4], trig->flags & TRIGGER_ONE_SHOT);
ui_checkbox_check(t->triggerFlag[5], trig->flags & TRIGGER_ILLUSION_ON);
ui_checkbox_check(t->triggerFlag[6], trig->flags & TRIGGER_ILLUSION_OFF);
ui_checkbox_check(t->triggerFlag[7], trig->flags & TRIGGER_ON);
ui_checkbox_check(t->triggerFlag[8], trig->flags & TRIGGER_MATCEN);
ui_checkbox_check(t->triggerFlag[9], trig->flags & TRIGGER_SECRET_EXIT);
}
}
//------------------------------------------------------------
// If any of the checkboxes that control the wallflags are set, then
// update the cooresponding wall flag.
//------------------------------------------------------------
if (IS_CHILD(Markedsegp->children[Markedside]))
{
rval = 1;
if (GADGET_PRESSED(t->triggerFlag[0]))
trigger_flag_Markedside(TRIGGER_CONTROL_DOORS, t->triggerFlag[0]->flag);
else if (GADGET_PRESSED(t->triggerFlag[1]))
trigger_flag_Markedside(TRIGGER_SHIELD_DAMAGE, t->triggerFlag[1]->flag);
else if (GADGET_PRESSED(t->triggerFlag[2]))
trigger_flag_Markedside(TRIGGER_ENERGY_DRAIN, t->triggerFlag[2]->flag);
else if (GADGET_PRESSED(t->triggerFlag[3]))
trigger_flag_Markedside(TRIGGER_EXIT, t->triggerFlag[3]->flag);
else if (GADGET_PRESSED(t->triggerFlag[4]))
trigger_flag_Markedside(TRIGGER_ONE_SHOT, t->triggerFlag[4]->flag);
else if (GADGET_PRESSED(t->triggerFlag[5]))
trigger_flag_Markedside(TRIGGER_ILLUSION_ON, t->triggerFlag[5]->flag);
else if (GADGET_PRESSED(t->triggerFlag[6]))
trigger_flag_Markedside(TRIGGER_ILLUSION_OFF, t->triggerFlag[6]->flag);
else if (GADGET_PRESSED(t->triggerFlag[7]))
trigger_flag_Markedside(TRIGGER_ON, t->triggerFlag[7]->flag);
else if (GADGET_PRESSED(t->triggerFlag[8]))
trigger_flag_Markedside(TRIGGER_MATCEN, t->triggerFlag[8]->flag);
else if (GADGET_PRESSED(t->triggerFlag[9]))
trigger_flag_Markedside(TRIGGER_SECRET_EXIT, t->triggerFlag[9]->flag);
else
rval = 0;
} else
for (i = 0; i < NUM_TRIGGER_FLAGS; i++ )
ui_checkbox_check(t->triggerFlag[i], 0);
//------------------------------------------------------------
// Draw the wall in the little 64x64 box
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
gr_set_current_canvas( t->wallViewBox->canvas );
if ((Markedsegp->sides[Markedside].wall_num == -1) || (Walls[Markedsegp->sides[Markedside].wall_num].trigger) == -1)
gr_clear_canvas( CBLACK );
else {
if (Markedsegp->sides[Markedside].tmap_num2 > 0) {
gr_ubitmap(0,0, texmerge_get_cached_bitmap( Markedsegp->sides[Markedside].tmap_num, Markedsegp->sides[Markedside].tmap_num2));
} else {
if (Markedsegp->sides[Markedside].tmap_num > 0) {
PIGGY_PAGE_IN(Textures[Markedsegp->sides[Markedside].tmap_num]);
gr_ubitmap(0,0, &GameBitmaps[Textures[Markedsegp->sides[Markedside].tmap_num].index]);
} else
gr_clear_canvas( CGREY );
}
}
}
//------------------------------------------------------------
// If anything changes in the ui system, redraw all the text that
// identifies this robot.
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
if ( Markedsegp->sides[Markedside].wall_num > -1 ) {
ui_dprintf_at( MainWindow, 12, 6, "Trigger: %d ", trigger_num);
} else {
ui_dprintf_at( MainWindow, 12, 6, "Trigger: none ");
}
}
if (ui_button_any_drawn || (t->old_trigger_num != trigger_num) )
Update_flags |= UF_WORLD_CHANGED;
if (event->type == EVENT_WINDOW_CLOSE)
{
d_free(t);
MainWindow = NULL;
return 0;
}
if ( GADGET_PRESSED(t->quitButton) || (keypress==KEY_ESC))
{
close_trigger_window();
return 1;
}
t->old_trigger_num = trigger_num;
return rval;
}
main(int argc,char **argv)
{
int ret;
grs_bitmap my_bitmap;
ubyte my_palette[256*3];
grs_bitmap *bm_list[100];
int n_bitmaps;
char key;
#if 0
{
int new_len,i;
new_len=rle_span(new_span,test_span,sizeof(test_span));
printf("old span (%d): ",sizeof(test_span));
for (i=0;i<sizeof(test_span);i++) printf("%d ",test_span[i]);
printf("\nnew span (%d): ",new_len);
for (i=0;i<new_len;i++) printf("%d ",new_span[i]);
exit(0);
}
#endif
#ifdef ANIM_TEST
ret = iff_read_animbrush(argv[1],bm_list,100,&n_bitmaps,&my_palette);
#else
ret = iff_read_bitmap(argv[1],&my_bitmap,BM_LINEAR,&my_palette);
bm_list[0] = &my_bitmap;
n_bitmaps = 1;
#endif
printf("ret = %d\n",ret);
printf("error message = <%s>",iff_errormsg(ret));
if (ret == IFF_NO_ERROR) {
int i;
vga_init();
gr_init();
vga_set_mode(SM_320x200C);
for (i=0;i<n_bitmaps;) {
if (argc>2) {
ret = iff_write_bitmap(argv[2],bm_list[i],&my_palette);
printf("ret = %d\n",ret);
}
//gr_pal_setblock(0,256,&my_palette);
gr_palette_load(&my_palette);
//gr_pal_fade_in(grd_curscreen->pal); //in case palette is blacked
gr_ubitmap(0,0,bm_list[i]);
key = getch();
if (key=='-') {if (i) i--;}
else i++;
}
gr_close();
for (i=0;i<n_bitmaps;i++) {
free(bm_list[i]->bm_data);
#ifdef ANIM_TEST
free(bm_list[i]);
#endif
}
}
}
int wall_dialog_handler(UI_DIALOG *dlg, d_event *event, wall_dialog *wd)
{
int i;
sbyte type;
fix DeltaTime;
fix64 Temp;
int keypress = 0;
int rval = 0;
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
Assert(MainWindow != NULL);
//------------------------------------------------------------
// Call the ui code..
//------------------------------------------------------------
ui_button_any_drawn = 0;
//------------------------------------------------------------
// If we change walls, we need to reset the ui code for all
// of the checkboxes that control the wall flags.
//------------------------------------------------------------
if (wd->old_wall_num != Cursegp->sides[Curside].wall_num)
{
if ( Cursegp->sides[Curside].wall_num != -1)
{
wall *w = &Walls[Cursegp->sides[Curside].wall_num];
ui_checkbox_check(wd->doorFlag[0], w->flags & WALL_DOOR_LOCKED);
ui_checkbox_check(wd->doorFlag[1], w->flags & WALL_DOOR_AUTO);
ui_checkbox_check(wd->doorFlag[2], w->flags & WALL_ILLUSION_OFF);
ui_radio_set_value(wd->keyFlag[0], w->keys & KEY_NONE);
ui_radio_set_value(wd->keyFlag[1], w->keys & KEY_BLUE);
ui_radio_set_value(wd->keyFlag[2], w->keys & KEY_RED);
ui_radio_set_value(wd->keyFlag[3], w->keys & KEY_GOLD);
}
}
//------------------------------------------------------------
// If any of the checkboxes that control the wallflags are set, then
// update the corresponding wall flag.
//------------------------------------------------------------
if (Walls[Cursegp->sides[Curside].wall_num].type == WALL_DOOR) {
if (GADGET_PRESSED(wd->doorFlag[0]))
{
if ( wd->doorFlag[0]->flag == 1 )
Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_DOOR_LOCKED;
else
Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_DOOR_LOCKED;
rval = 1;
}
else if (GADGET_PRESSED(wd->doorFlag[1]))
{
if ( wd->doorFlag[1]->flag == 1 )
Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_DOOR_AUTO;
else
Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_DOOR_AUTO;
rval = 1;
}
//------------------------------------------------------------
// If any of the radio buttons that control the mode are set, then
// update the corresponding key.
//------------------------------------------------------------
for ( i=0; i < 4; i++ ) {
if (GADGET_PRESSED(wd->keyFlag[i]))
{
Walls[Cursegp->sides[Curside].wall_num].keys = 1<<i; // Set the ai_state to the cooresponding radio button
rval = 1;
}
}
} else {
for (i = 0; i < 2; i++)
ui_checkbox_check(wd->doorFlag[i], 0);
for ( i=0; i < 4; i++ )
ui_radio_set_value(wd->keyFlag[i], 0);
}
if (Walls[Cursegp->sides[Curside].wall_num].type == WALL_ILLUSION) {
if (GADGET_PRESSED(wd->doorFlag[2]))
{
if ( wd->doorFlag[2]->flag == 1 )
Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_ILLUSION_OFF;
else
Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_ILLUSION_OFF;
rval = 1;
}
} else
for ( i=2; i < 3; i++ )
if (wd->doorFlag[i]->flag == 1) {
wd->doorFlag[i]->flag = 0; // Tells ui that this button isn't checked
wd->doorFlag[i]->status = 1; // Tells ui to redraw button
}
//------------------------------------------------------------
// Draw the wall in the little 64x64 box
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
// A simple frame time counter for animating the walls...
Temp = timer_query();
DeltaTime = Temp - wd->time;
gr_set_current_canvas( wd->wallViewBox->canvas );
if (Cursegp->sides[Curside].wall_num != -1) {
type = Walls[Cursegp->sides[Curside].wall_num].type;
if ((type == WALL_DOOR) || (type == WALL_BLASTABLE)) {
if (DeltaTime > ((F1_0*200)/1000)) {
wd->framenum++;
wd->time = Temp;
}
if (wd->framenum >= WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].num_frames)
wd->framenum=0;
PIGGY_PAGE_IN(Textures[WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].frames[wd->framenum]]);
gr_ubitmap(0,0, &GameBitmaps[Textures[WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].frames[wd->framenum]].index]);
} else {
if (type == WALL_OPEN)
gr_clear_canvas( CBLACK );
else {
if (Cursegp->sides[Curside].tmap_num2 > 0)
gr_ubitmap(0,0, texmerge_get_cached_bitmap( Cursegp->sides[Curside].tmap_num, Cursegp->sides[Curside].tmap_num2));
else {
PIGGY_PAGE_IN(Textures[Cursegp->sides[Curside].tmap_num]);
gr_ubitmap(0,0, &GameBitmaps[Textures[Cursegp->sides[Curside].tmap_num].index]);
}
}
}
} else
gr_clear_canvas( CGREY );
}
//------------------------------------------------------------
// If anything changes in the ui system, redraw all the text that
// identifies this wall.
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
if ( Cursegp->sides[Curside].wall_num > -1 ) {
ui_dprintf_at( MainWindow, 12, 6, "Wall: %d ", Cursegp->sides[Curside].wall_num);
switch (Walls[Cursegp->sides[Curside].wall_num].type) {
case WALL_NORMAL:
ui_dprintf_at( MainWindow, 12, 23, " Type: Normal " );
break;
case WALL_BLASTABLE:
ui_dprintf_at( MainWindow, 12, 23, " Type: Blastable" );
break;
case WALL_DOOR:
ui_dprintf_at( MainWindow, 12, 23, " Type: Door " );
ui_dprintf_at( MainWindow, 223, 6, "%s", WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].filename);
break;
case WALL_ILLUSION:
ui_dprintf_at( MainWindow, 12, 23, " Type: Illusion " );
break;
case WALL_OPEN:
ui_dprintf_at( MainWindow, 12, 23, " Type: Open " );
break;
case WALL_CLOSED:
ui_dprintf_at( MainWindow, 12, 23, " Type: Closed " );
break;
default:
ui_dprintf_at( MainWindow, 12, 23, " Type: Unknown " );
break;
}
if (Walls[Cursegp->sides[Curside].wall_num].type != WALL_DOOR)
ui_dprintf_at( MainWindow, 223, 6, " " );
ui_dprintf_at( MainWindow, 12, 40, " Clip: %d ", Walls[Cursegp->sides[Curside].wall_num].clip_num );
ui_dprintf_at( MainWindow, 12, 57, " Trigger: %d ", Walls[Cursegp->sides[Curside].wall_num].trigger );
} else {
ui_dprintf_at( MainWindow, 12, 6, "Wall: none ");
ui_dprintf_at( MainWindow, 12, 23, " Type: none ");
ui_dprintf_at( MainWindow, 12, 40, " Clip: none ");
ui_dprintf_at( MainWindow, 12, 57, " Trigger: none ");
}
}
if (ui_button_any_drawn || (wd->old_wall_num != Cursegp->sides[Curside].wall_num) )
Update_flags |= UF_WORLD_CHANGED;
if (event->type == EVENT_WINDOW_CLOSE)
{
d_free(wd);
MainWindow = NULL;
return 0;
}
if ( GADGET_PRESSED(wd->quitButton) || (keypress==KEY_ESC) )
{
close_wall_window();
return 1;
}
wd->old_wall_num = Cursegp->sides[Curside].wall_num;
return rval;
}
void do_wall_window()
{
int i;
sbyte type;
fix DeltaTime, Temp;
if ( MainWindow == NULL ) return;
//------------------------------------------------------------
// Call the ui code..
//------------------------------------------------------------
ui_button_any_drawn = 0;
ui_window_do_gadgets(MainWindow);
//------------------------------------------------------------
// If we change walls, we need to reset the ui code for all
// of the checkboxes that control the wall flags.
//------------------------------------------------------------
if (old_wall_num != Cursegp->sides[Curside].wall_num) {
for ( i=0; i < 3; i++ ) {
DoorFlag[i]->flag = 0; // Tells ui that this button isn't checked
DoorFlag[i]->status = 1; // Tells ui to redraw button
}
for ( i=0; i < 4; i++ ) {
KeyFlag[i]->flag = 0; // Tells ui that this button isn't checked
KeyFlag[i]->status = 1; // Tells ui to redraw button
}
if ( Cursegp->sides[Curside].wall_num != -1) {
if (Walls[Cursegp->sides[Curside].wall_num].flags & WALL_DOOR_LOCKED)
DoorFlag[0]->flag = 1; // Mark this button as checked
if (Walls[Cursegp->sides[Curside].wall_num].flags & WALL_DOOR_AUTO)
DoorFlag[1]->flag = 1; // Mark this button as checked
if (Walls[Cursegp->sides[Curside].wall_num].flags & WALL_ILLUSION_OFF)
DoorFlag[2]->flag = 1; // Mark this button as checked
if (Walls[Cursegp->sides[Curside].wall_num].keys & KEY_NONE)
KeyFlag[0]->flag = 1;
if (Walls[Cursegp->sides[Curside].wall_num].keys & KEY_BLUE)
KeyFlag[1]->flag = 1;
if (Walls[Cursegp->sides[Curside].wall_num].keys & KEY_RED)
KeyFlag[2]->flag = 1;
if (Walls[Cursegp->sides[Curside].wall_num].keys & KEY_GOLD)
KeyFlag[3]->flag = 1;
}
}
//------------------------------------------------------------
// If any of the checkboxes that control the wallflags are set, then
// update the corresponding wall flag.
//------------------------------------------------------------
if (Walls[Cursegp->sides[Curside].wall_num].type == WALL_DOOR) {
if ( DoorFlag[0]->flag == 1 )
Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_DOOR_LOCKED;
else
Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_DOOR_LOCKED;
if ( DoorFlag[1]->flag == 1 )
Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_DOOR_AUTO;
else
Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_DOOR_AUTO;
//------------------------------------------------------------
// If any of the radio buttons that control the mode are set, then
// update the corresponding key.
//------------------------------------------------------------
for ( i=0; i < 4; i++ ) {
if ( KeyFlag[i]->flag == 1 ) {
Walls[Cursegp->sides[Curside].wall_num].keys = 1<<i; // Set the ai_state to the cooresponding radio button
}
}
} else {
for ( i=0; i < 2; i++ )
if (DoorFlag[i]->flag == 1) {
DoorFlag[i]->flag = 0; // Tells ui that this button isn't checked
DoorFlag[i]->status = 1; // Tells ui to redraw button
}
for ( i=0; i < 4; i++ ) {
if ( KeyFlag[i]->flag == 1 ) {
KeyFlag[i]->flag = 0;
KeyFlag[i]->status = 1;
}
}
}
if (Walls[Cursegp->sides[Curside].wall_num].type == WALL_ILLUSION) {
if ( DoorFlag[2]->flag == 1 )
Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_ILLUSION_OFF;
else
Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_ILLUSION_OFF;
} else
for ( i=2; i < 3; i++ )
if (DoorFlag[i]->flag == 1) {
DoorFlag[i]->flag = 0; // Tells ui that this button isn't checked
DoorFlag[i]->status = 1; // Tells ui to redraw button
}
//------------------------------------------------------------
// A simple frame time counter for animating the walls...
//------------------------------------------------------------
Temp = timer_get_fixed_seconds();
DeltaTime = Temp - Time;
//------------------------------------------------------------
// Draw the wall in the little 64x64 box
//------------------------------------------------------------
gr_set_current_canvas( WallViewBox->canvas );
if (Cursegp->sides[Curside].wall_num != -1) {
type = Walls[Cursegp->sides[Curside].wall_num].type;
if ((type == WALL_DOOR) || (type == WALL_BLASTABLE)) {
if (DeltaTime > ((F1_0*200)/1000)) {
framenum++;
Time = Temp;
}
if (framenum >= WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].num_frames)
framenum=0;
PIGGY_PAGE_IN(Textures[WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].frames[framenum]]);
gr_ubitmap(0,0, &GameBitmaps[Textures[WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].frames[framenum]].index]);
} else {
if (type == WALL_OPEN)
gr_clear_canvas( CBLACK );
else {
if (Cursegp->sides[Curside].tmap_num2 > 0)
gr_ubitmap(0,0, texmerge_get_cached_bitmap( Cursegp->sides[Curside].tmap_num, Cursegp->sides[Curside].tmap_num2));
else {
PIGGY_PAGE_IN(Textures[Cursegp->sides[Curside].tmap_num]);
gr_ubitmap(0,0, &GameBitmaps[Textures[Cursegp->sides[Curside].tmap_num].index]);
}
}
}
} else
gr_clear_canvas( CGREY );
//------------------------------------------------------------
// If anything changes in the ui system, redraw all the text that
// identifies this wall.
//------------------------------------------------------------
if (ui_button_any_drawn || (old_wall_num != Cursegp->sides[Curside].wall_num) ) {
if ( Cursegp->sides[Curside].wall_num > -1 ) {
ui_wprintf_at( MainWindow, 12, 6, "Wall: %d ", Cursegp->sides[Curside].wall_num);
switch (Walls[Cursegp->sides[Curside].wall_num].type) {
case WALL_NORMAL:
ui_wprintf_at( MainWindow, 12, 23, " Type: Normal " );
break;
case WALL_BLASTABLE:
ui_wprintf_at( MainWindow, 12, 23, " Type: Blastable" );
break;
case WALL_DOOR:
ui_wprintf_at( MainWindow, 12, 23, " Type: Door " );
ui_wprintf_at( MainWindow, 223, 6, "%s", WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].filename);
break;
case WALL_ILLUSION:
ui_wprintf_at( MainWindow, 12, 23, " Type: Illusion " );
break;
case WALL_OPEN:
ui_wprintf_at( MainWindow, 12, 23, " Type: Open " );
break;
case WALL_CLOSED:
ui_wprintf_at( MainWindow, 12, 23, " Type: Closed " );
break;
default:
ui_wprintf_at( MainWindow, 12, 23, " Type: Unknown " );
break;
}
if (Walls[Cursegp->sides[Curside].wall_num].type != WALL_DOOR)
ui_wprintf_at( MainWindow, 223, 6, " " );
ui_wprintf_at( MainWindow, 12, 40, " Clip: %d ", Walls[Cursegp->sides[Curside].wall_num].clip_num );
ui_wprintf_at( MainWindow, 12, 57, " Trigger: %d ", Walls[Cursegp->sides[Curside].wall_num].trigger );
} else {
ui_wprintf_at( MainWindow, 12, 6, "Wall: none ");
ui_wprintf_at( MainWindow, 12, 23, " Type: none ");
ui_wprintf_at( MainWindow, 12, 40, " Clip: none ");
ui_wprintf_at( MainWindow, 12, 57, " Trigger: none ");
}
Update_flags |= UF_WORLD_CHANGED;
}
if ( QuitButton->pressed || (last_keypress==KEY_ESC) ) {
close_wall_window();
return;
}
old_wall_num = Cursegp->sides[Curside].wall_num;
}
void do_trigger_window()
{
int i;
short Markedwall, trigger_num;
if ( MainWindow == NULL ) return;
if (!Markedsegp) {
close_trigger_window();
return;
}
//------------------------------------------------------------
// Call the ui code..
//------------------------------------------------------------
ui_button_any_drawn = 0;
ui_window_do_gadgets(MainWindow);
//------------------------------------------------------------
// If we change walls, we need to reset the ui code for all
// of the checkboxes that control the wall flags.
//------------------------------------------------------------
Markedwall = Markedsegp->sides[Markedside].wall_num;
if (Markedwall != -1)
trigger_num = Walls[Markedwall].trigger;
else trigger_num = -1;
if (old_trigger_num != trigger_num ) {
for ( i=0; i < NUM_TRIGGER_FLAGS; i++ ) {
TriggerFlag[i]->flag = 0; // Tells ui that this button isn't checked
TriggerFlag[i]->status = 1; // Tells ui to redraw button
}
if (trigger_num != -1) {
if (Triggers[trigger_num].flags & TRIGGER_CONTROL_DOORS)
TriggerFlag[0]->flag = 1;
if (Triggers[trigger_num].flags & TRIGGER_SHIELD_DAMAGE)
TriggerFlag[1]->flag = 1;
if (Triggers[trigger_num].flags & TRIGGER_ENERGY_DRAIN)
TriggerFlag[2]->flag = 1;
if (Triggers[trigger_num].flags & TRIGGER_EXIT)
TriggerFlag[3]->flag = 1;
if (Triggers[trigger_num].flags & TRIGGER_ONE_SHOT)
TriggerFlag[4]->flag = 1;
if (Triggers[trigger_num].flags & TRIGGER_ILLUSION_ON)
TriggerFlag[5]->flag = 1;
if (Triggers[trigger_num].flags & TRIGGER_ILLUSION_OFF)
TriggerFlag[6]->flag = 1;
if (Triggers[trigger_num].flags & TRIGGER_ON)
TriggerFlag[7]->flag = 1;
if (Triggers[trigger_num].flags & TRIGGER_MATCEN)
TriggerFlag[8]->flag = 1;
if (Triggers[trigger_num].flags & TRIGGER_SECRET_EXIT)
TriggerFlag[9]->flag = 1;
}
}
//------------------------------------------------------------
// If any of the checkboxes that control the wallflags are set, then
// update the cooresponding wall flag.
//------------------------------------------------------------
if (IS_CHILD(Markedsegp->children[Markedside])) {
if (TriggerFlag[0]->flag == 1)
trigger_add_to_Markedside(TRIGGER_CONTROL_DOORS);
else
trigger_remove_flag_from_Markedside(TRIGGER_CONTROL_DOORS);
if (TriggerFlag[1]->flag == 1)
trigger_add_to_Markedside(TRIGGER_SHIELD_DAMAGE);
else
trigger_remove_flag_from_Markedside(TRIGGER_SHIELD_DAMAGE);
if (TriggerFlag[2]->flag == 1)
trigger_add_to_Markedside(TRIGGER_ENERGY_DRAIN);
else
trigger_remove_flag_from_Markedside(TRIGGER_ENERGY_DRAIN);
if (TriggerFlag[3]->flag == 1)
trigger_add_to_Markedside(TRIGGER_EXIT);
else
trigger_remove_flag_from_Markedside(TRIGGER_EXIT);
if (TriggerFlag[4]->flag == 1)
trigger_add_to_Markedside(TRIGGER_ONE_SHOT);
else
trigger_remove_flag_from_Markedside(TRIGGER_ONE_SHOT);
if (TriggerFlag[5]->flag == 1)
trigger_add_to_Markedside(TRIGGER_ILLUSION_ON);
else
trigger_remove_flag_from_Markedside(TRIGGER_ILLUSION_ON);
if (TriggerFlag[6]->flag == 1)
trigger_add_to_Markedside(TRIGGER_ILLUSION_OFF);
else
trigger_remove_flag_from_Markedside(TRIGGER_ILLUSION_OFF);
if (TriggerFlag[7]->flag == 1)
trigger_add_to_Markedside(TRIGGER_ON);
else
trigger_remove_flag_from_Markedside(TRIGGER_ON);
if (TriggerFlag[8]->flag == 1)
trigger_add_to_Markedside(TRIGGER_MATCEN);
else
trigger_remove_flag_from_Markedside(TRIGGER_MATCEN);
if (TriggerFlag[9]->flag == 1)
trigger_add_to_Markedside(TRIGGER_SECRET_EXIT);
else
trigger_remove_flag_from_Markedside(TRIGGER_SECRET_EXIT);
} else
for ( i=0; i < NUM_TRIGGER_FLAGS; i++ )
if (TriggerFlag[i]->flag == 1) {
TriggerFlag[i]->flag = 0; // Tells ui that this button isn't checked
TriggerFlag[i]->status = 1; // Tells ui to redraw button
}
//------------------------------------------------------------
// Draw the wall in the little 64x64 box
//------------------------------------------------------------
gr_set_current_canvas( WallViewBox->canvas );
if ((Markedsegp->sides[Markedside].wall_num == -1) || (Walls[Markedsegp->sides[Markedside].wall_num].trigger) == -1)
gr_clear_canvas( CBLACK );
else {
if (Markedsegp->sides[Markedside].tmap_num2 > 0) {
gr_ubitmap(0,0, texmerge_get_cached_bitmap( Markedsegp->sides[Markedside].tmap_num, Markedsegp->sides[Markedside].tmap_num2));
} else {
if (Markedsegp->sides[Markedside].tmap_num > 0) {
PIGGY_PAGE_IN(Textures[Markedsegp->sides[Markedside].tmap_num]);
gr_ubitmap(0,0, &GameBitmaps[Textures[Markedsegp->sides[Markedside].tmap_num].index]);
} else
gr_clear_canvas( CGREY );
}
}
//------------------------------------------------------------
// If anything changes in the ui system, redraw all the text that
// identifies this robot.
//------------------------------------------------------------
if (ui_button_any_drawn || (old_trigger_num != trigger_num) ) {
if ( Markedsegp->sides[Markedside].wall_num > -1 ) {
ui_wprintf_at( MainWindow, 12, 6, "Trigger: %d ", trigger_num);
} else {
ui_wprintf_at( MainWindow, 12, 6, "Trigger: none ");
}
Update_flags |= UF_WORLD_CHANGED;
}
if ( QuitButton->pressed || (last_keypress==KEY_ESC)) {
close_trigger_window();
return;
}
old_trigger_num = trigger_num;
}
//make a series of photographs
do_photos()
{
FILE *vfile,*upvfile;
int photo_num=0;
char savename[13];
grs_canvas *photo_canvas;
vms_vector viewer_pos;
vms_matrix viewer_orient;
vfile=fopen("vectors.lst","rt");
upvfile=fopen("upvecs.c","wt");
Assert(vfile!=NULL && upvfile!=NULL);
fprintf(upvfile,"\n\n#include \"vecmat.h\"\n\nvms_vector up_vecs[] = {\n");
photo_canvas = gr_create_canvas(64,64);
gr_set_current_canvas(photo_canvas);
while (!feof(vfile)) {
vms_vector v;
vms_matrix m;
float x,y,z;
int nf;
nf = fscanf(vfile,"%f %f %f",&x,&y,&z);
if (nf!=3) break;
vm_vec_make(&v,fl2f(x),fl2f(y),fl2f(z));
vm_vector_2_matrix(&m,&v,NULL,NULL);
fprintf(upvfile,"\t\t\t{%#x,%#x,%#x},\n",m.uvec.x,m.uvec.y,m.uvec.z);
vm_vec_scale(&v,PHOTO_DIST);
vm_vec_add(&viewer_pos,&cube_position,&v);
viewer_orient = m;
vm_vec_negate(&viewer_orient.fvec);
vm_vec_negate(&viewer_orient.rvec);
gr_clear_canvas(129);
g3_start_frame();
g3_set_view_matrix(&viewer_pos,&viewer_orient,0x9000);
draw_cube();
g3_end_frame();
gr_set_current_canvas(Canv_game);
gr_ubitmap(0,0,&photo_canvas->cv_bitmap);
gr_set_current_canvas(photo_canvas);
sprintf(savename,"cube_%02d.bbm",photo_num);
iff_write_bitmap(savename,&photo_canvas->cv_bitmap,gr_palette);
photo_num++;
}
gr_free_canvas(photo_canvas);
fprintf(upvfile,"\t\t};\n");
fclose(vfile);
fclose(upvfile);
}
