main/editor/med.c

   1 /* $Id: med.c,v 1.5 2004-12-24 05:17:09 btb Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15 /*
  16  *
  17  * Editor loop for Inferno
  18  *
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <conf.h>
  23 #endif
  24
  25 //#define DEMO 1
  26
  27 #define DIAGNOSTIC_MESSAGE_MAX                          90
  28 #define EDITOR_STATUS_MESSAGE_DURATION  4               //      Shows for 3+..4 seconds
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <stdarg.h>
  33 #include <string.h>
  34 #include <time.h>
  35
  36 #ifdef __MSDOS__
  37 #include <process.h>
  38 #endif
  39
  40
  41 //#define INCLUDE_XLISP
  42
  43 #include "inferno.h"
  44 #include "segment.h"
  45 #include "gr.h"
  46 #include "ui.h"
  47 #include "editor.h"
  48 //#include "gamemine.h"
  49 #include "gamesave.h"
  50 #include "gameseg.h"
  51
  52 #include "key.h"
  53 #include "mono.h"
  54 #include "error.h"
  55 #include "kfuncs.h"
  56 #include "macro.h"
  57
  58 #ifdef INCLUDE_XLISP
  59 #include "medlisp.h"
  60 #endif
  61 #include "u_mem.h"
  62 #include "render.h"
  63 #include "game.h"
  64 #include "slew.h"
  65 #include "kdefs.h"
  66 #include "func.h"
  67 #include "textures.h"
  68 #include "screens.h"
  69 #include "texmap.h"
  70 #include "object.h"
  71 #include "effects.h"
  72 #include "wall.h"
  73 #include "info.h"
  74 #include "ai.h"
  75
  76 #include "texpage.h"            // Textue selection paging stuff
  77 #include "objpage.h"            // Object selection paging stuff
  78
  79 #include "medmisc.h"
  80 #include "meddraw.h"
  81 #include "medsel.h"
  82 #include "medrobot.h"
  83 #include "medwall.h"
  84 #include "eswitch.h"
  85 #include "ehostage.h"
  86 #include "centers.h"
  87
  88 #include "fuelcen.h"
  89 #include "gameseq.h"
  90 #include "newmenu.h"
  91
  92 //#define _MARK_ON 1
  93 //#include <wsample.h>          //should come after inferno.h to get mark setting //Not included here.
  94
  95 #define COMPRESS_INTERVAL       5                       // seconds
  96
  97 //char *undo_status[128];
  98
  99 int initializing;
 100
 101 //these are instances of canvases, pointed to by variables below
 102 grs_canvas _canv_editor_game;           //the game on the editor screen
 103
 104 //these are pointers to our canvases
 105 grs_canvas *Canv_editor;                        //the editor screen
 106 grs_canvas *Canv_editor_game=&_canv_editor_game; //the game on the editor screen
 107
 108 grs_canvas *canv_offscreen;             //for off-screen rendering
 109 grs_canvas *Pad_text_canvas;            // Keypad text
 110
 111 grs_font *editor_font=NULL;
 112
 113 //where the editor is looking
 114 vms_vector Ed_view_target={0,0,0};
 115
 116 int gamestate_not_restored = 0;
 117
 118 UI_WINDOW * EditorWindow;
 119
 120 int     Large_view_index = -1;
 121
 122 UI_GADGET_USERBOX * GameViewBox;
 123 UI_GADGET_USERBOX * LargeViewBox;
 124 UI_GADGET_USERBOX * GroupViewBox;
 125
 126 #if ORTHO_VIEWS
 127 UI_GADGET_USERBOX * TopViewBox;
 128 UI_GADGET_USERBOX * FrontViewBox;
 129 UI_GADGET_USERBOX * RightViewBox;
 130 #endif
 131
 132 UI_GADGET_ICON * ViewIcon;
 133 UI_GADGET_ICON * AllIcon;
 134 UI_GADGET_ICON * AxesIcon;
 135 UI_GADGET_ICON * ChaseIcon;
 136 UI_GADGET_ICON * OutlineIcon;
 137 UI_GADGET_ICON * LockIcon;
 138 //-NOLIGHTICON- UI_GADGET_ICON * LightIcon;
 139
 140 UI_EVENT * DemoBuffer = NULL;
 141
 142 //grs_canvas * BigCanvas[2];
 143 //int CurrentBigCanvas = 0;
 144 //int BigCanvasFirstTime = 1;
 145
 146 int     Found_seg_index=0;                              // Index in Found_segs corresponding to Cursegp
 147
 148
 149 void print_status_bar( char message[DIAGNOSTIC_MESSAGE_MAX] ) {
 150         int w,h,aw;
 151
 152         gr_set_current_canvas( NULL );
 153         gr_set_curfont(editor_font);
 154         gr_set_fontcolor( CBLACK, CGREY );
 155         gr_get_string_size( message, &w, &h, &aw );
 156         gr_string( 4, 583, message );
 157         gr_set_fontcolor( CBLACK, CWHITE );
 158         gr_setcolor( CGREY );
 159         gr_rect( 4+w, 583, 799, 599 );
 160 }
 161
 162 void print_diagnostic( char message[DIAGNOSTIC_MESSAGE_MAX] ) {
 163         int w,h,aw;
 164
 165         gr_set_current_canvas( NULL );
 166         gr_set_curfont(editor_font);
 167         gr_set_fontcolor( CBLACK, CGREY );
 168         gr_get_string_size( message, &w, &h, &aw );
 169         gr_string( 4, 583, message );
 170         gr_set_fontcolor( CBLACK, CWHITE );
 171         gr_setcolor( CGREY );
 172         gr_rect( 4+w, 583, 799, 599 );
 173 }
 174
 175 static char status_line[DIAGNOSTIC_MESSAGE_MAX];
 176
 177 struct tm       Editor_status_last_time;
 178
 179 void editor_status( const char *format, ... )
 180 {
 181         va_list ap;
 182
 183         va_start(ap, format);
 184         vsprintf(status_line, format, ap);
 185         va_end(ap);
 186
 187         print_status_bar(status_line);
 188
 189         Editor_status_last_time = Editor_time_of_day;
 190
 191 }
 192
 193 //      int  tm_sec;    /* seconds after the minute -- [0,61] */
 194 //      int  tm_min;    /* minutes after the hour       -- [0,59] */
 195 //      int  tm_hour;   /* hours after midnight -- [0,23] */
 196 //      int  tm_mday;   /* day of the month             -- [1,31] */
 197 //      int  tm_mon;    /* months since January -- [0,11] */
 198 //      int  tm_year;   /* years since 1900                             */
 199 //      int  tm_wday;   /* days since Sunday            -- [0,6]  */
 200 //      int  tm_yday;   /* days since January 1 -- [0,365]*/
 201 //      int  tm_isdst;  /* Daylight Savings Time flag */
 202
 203 void clear_editor_status(void)
 204 {
 205         int cur_time = Editor_time_of_day.tm_hour * 3600 + Editor_time_of_day.tm_min*60 + Editor_time_of_day.tm_sec;
 206         int erase_time = Editor_status_last_time.tm_hour * 3600 + Editor_status_last_time.tm_min*60 + Editor_status_last_time.tm_sec + EDITOR_STATUS_MESSAGE_DURATION;
 207
 208         if (cur_time > erase_time) {
 209                 int     i;
 210                 char    message[DIAGNOSTIC_MESSAGE_MAX];
 211
 212                 for (i=0; i<DIAGNOSTIC_MESSAGE_MAX-1; i++)
 213                         message[i] = ' ';
 214
 215                 message[i] = 0;
 216                 print_status_bar(message);
 217                 Editor_status_last_time.tm_hour = 99;
 218         }
 219 }
 220
 221
 222 void diagnostic_message( const char *format, ... )
 223 {
 224         char diag_line[DIAGNOSTIC_MESSAGE_MAX];
 225
 226         va_list ap;
 227
 228         va_start(ap, format);
 229         vsprintf(diag_line, format, ap);
 230         va_end(ap);
 231
 232         editor_status(diag_line);
 233 }
 234
 235
 236 static char sub_status_line[DIAGNOSTIC_MESSAGE_MAX];
 237
 238 void editor_sub_status( const char *format, ... )
 239 {
 240         int w,h,aw;
 241         va_list ap;
 242
 243         va_start(ap, format);
 244         vsprintf(sub_status_line, format, ap);
 245         va_end(ap);
 246
 247         gr_set_current_canvas( NULL );
 248         gr_set_curfont(editor_font);
 249         gr_set_fontcolor( BM_XRGB(0,0,31), CGREY );
 250         gr_get_string_size( sub_status_line, &w, &h, &aw );
 251         gr_string( 500, 583, sub_status_line );
 252         gr_set_fontcolor( CBLACK, CWHITE );
 253         gr_setcolor( CGREY );
 254         gr_rect( 500+w, 583, 799, 599 );
 255 }
 256
 257 int DropIntoDebugger()
 258 {
 259         Int3();
 260         return 1;
 261 }
 262
 263
 264 #ifdef INCLUDE_XLISP
 265 int CallLisp()
 266 {
 267         medlisp_go();
 268         return 1;
 269 }
 270 #endif
 271
 272
 273 int ExitEditor()
 274 {
 275         if (SafetyCheck())  {
 276                 ModeFlag = 1;
 277         }
 278         return 1;
 279 }
 280
 281 int     GotoGameCommon(int mode) {
 282         stop_time();
 283
 284 //@@    init_player_stats();
 285 //@@
 286 //@@    Player_init.pos = Player->pos;
 287 //@@    Player_init.orient = Player->orient;
 288 //@@    Player_init.segnum = Player->segnum;
 289
 290 // -- must always save gamesave.sav because the restore-objects code relies on it
 291 // -- that code could be made smarter and use the original file, if appropriate.
 292 //      if (mine_changed)
 293         if (gamestate_not_restored == 0) {
 294                 gamestate_not_restored = 1;
 295                 save_level("GAMESAVE.LVL");
 296                 editor_status("Gamestate saved.\n");
 297                 mprintf((0, "Gamestate saved.\n"));
 298         }
 299
 300         ai_reset_all_paths();
 301
 302         start_time();
 303
 304         ModeFlag = mode;
 305         return 1;
 306 }
 307
 308 int GotoGameScreen()
 309 {
 310         return GotoGameCommon(3);
 311 }
 312
 313 int GotoGame()
 314 {
 315         return GotoGameCommon(2);
 316 }
 317
 318
 319 void ReadLispMacro( FILE * file, char * buffer )
 320 {
 321 //      char c;
 322 //      int size=0;
 323 //      int pcount = 0;
 324 //      char text[100];
 325 //      int i=0;
 326
 327         fscanf( file, " { %s } ", buffer );
 328
 329 /*
 330         while (1)
 331         {
 332                 c = text[i++];
 333                 if (pcount > 0 )
 334                         buffer[size++] = c;
 335                 if ( c == '(' ) pcount++;
 336                 if ( c == ')' ) break;
 337         }
 338         buffer[size++] = 0;
 339 */
 340
 341         return;
 342 }
 343
 344 static int (*KeyFunction[2048])();
 345
 346 void medkey_init()
 347 {
 348         FILE * keyfile;
 349         char keypress[100];
 350         int key;
 351         int i;  //, size;
 352         int np;
 353         char * LispCommand;
 354
 355         MALLOC( LispCommand, char, DIAGNOSTIC_MESSAGE_MAX );
 356
 357         for (i=0; i<2048; i++ )
 358                 KeyFunction[i] = NULL;
 359
 360         keyfile = fopen( "GLOBAL.KEY", "rt" );
 361         if (keyfile)
 362         {
 363                 while (fscanf( keyfile, " %s %s ", keypress, LispCommand ) != EOF )
 364                 {
 365                         //ReadLispMacro( keyfile, LispCommand );
 366
 367                         if ( (key=DecodeKeyText( keypress ))!= -1 )
 368                         {
 369                                 Assert( key < 2048);
 370                                 KeyFunction[key] = func_get( LispCommand, &np );
 371                         } else {
 372                                 Error( "Bad key %s in GLOBAL.KEY!", keypress );
 373                         }
 374                 }
 375                 fclose(keyfile);
 376         }
 377         free( LispCommand );
 378 }
 379
 380 void init_editor()
 381 {
 382         minit();
 383
 384         ui_init();
 385
 386         init_med_functions();   // Must be called before medlisp_init
 387
 388         ui_pad_read( 0, "segmove.pad" );
 389         ui_pad_read( 1, "segsize.pad" );
 390         ui_pad_read( 2, "curve.pad" );
 391         ui_pad_read( 3, "texture.pad" );
 392         ui_pad_read( 4, "object.pad" );
 393         ui_pad_read( 5, "objmov.pad" );
 394         ui_pad_read( 6, "group.pad" );
 395         ui_pad_read( 7, "lighting.pad" );
 396         ui_pad_read( 8, "test.pad" );
 397
 398         medkey_init();
 399
 400         editor_font = gr_init_font( "pc8x16.fnt" );
 401
 402         menubar_init( "MED.MNU" );
 403
 404         canv_offscreen = gr_create_canvas(LVIEW_W,LVIEW_H);
 405
 406         Draw_all_segments = 1;                                          // Say draw all segments, not just connected ones
 407
 408         init_autosave();
 409
 410 //      atexit(close_editor);
 411
 412         Clear_window = 1;       //      do full window clear.
 413 }
 414
 415 int ShowAbout()
 416 {
 417         MessageBox( -2, -2, 1,  "INFERNO Mine Editor\n\n"               \
 418                                                                         "Copyright (c) 1993  Parallax Software Corp.",
 419                                                                         "OK");
 420         return 0;
 421 }
 422
 423 void move_player_2_segment(segment *seg,int side);
 424
 425 int SetPlayerFromCurseg()
 426 {
 427         move_player_2_segment(Cursegp,Curside);
 428         Update_flags |= UF_ED_STATE_CHANGED | UF_GAME_VIEW_CHANGED;
 429         return 1;
 430 }
 431
 432 int fuelcen_create_from_curseg()
 433 {
 434         Curseg2p->special = SEGMENT_IS_FUELCEN;
 435         fuelcen_activate(Cursegp, Curseg2p->special);
 436         return 1;
 437 }
 438
 439 int repaircen_create_from_curseg()
 440 {
 441         Int3(); //      -- no longer supported!
 442 //      Curseg2p->special = SEGMENT_IS_REPAIRCEN;
 443 //      fuelcen_activate(Cursegp, Curseg2p->special);
 444         return 1;
 445 }
 446
 447 int controlcen_create_from_curseg()
 448 {
 449         Curseg2p->special = SEGMENT_IS_CONTROLCEN;
 450         fuelcen_activate(Cursegp, Curseg2p->special);
 451         return 1;
 452 }
 453
 454 int robotmaker_create_from_curseg()
 455 {
 456         Curseg2p->special = SEGMENT_IS_ROBOTMAKER;
 457         fuelcen_activate(Cursegp, Curseg2p->special);
 458         return 1;
 459 }
 460
 461 int fuelcen_reset_all() {
 462         fuelcen_reset();
 463         return 1;
 464 }
 465
 466 int fuelcen_delete_from_curseg() {
 467         fuelcen_delete( Cursegp );
 468         return 1;
 469 }
 470
 471
 472 //@@//this routine places the viewer in the center of the side opposite to curside,
 473 //@@//with the view toward the center of curside
 474 //@@int SetPlayerFromCursegMinusOne()
 475 //@@{
 476 //@@    vms_vector vp;
 477 //@@
 478 //@@//  int newseg,newside;
 479 //@@//  get_previous_segment(SEG_PTR_2_NUM(Cursegp),Curside,&newseg,&newside);
 480 //@@//  move_player_2_segment(&Segments[newseg],newside);
 481 //@@
 482 //@@    med_compute_center_point_on_side(&Player->obj_position,Cursegp,Side_opposite[Curside]);
 483 //@@    med_compute_center_point_on_side(&vp,Cursegp,Curside);
 484 //@@    vm_vec_sub2(&vp,&Player->position);
 485 //@@    vm_vector_2_matrix(&Player->orient,&vp,NULL,NULL);
 486 //@@
 487 //@@    Player->seg = SEG_PTR_2_NUM(Cursegp);
 488 //@@
 489 //@@    Update_flags |= UF_GAME_VIEW_CHANGED;
 490 //@@    return 1;
 491 //@@}
 492
 493 //this constant determines how much of the window will be occupied by the
 494 //viewed side when SetPlayerFromCursegMinusOne() is called.  It actually
 495 //determine how from from the center of the window the farthest point will be
 496 #define SIDE_VIEW_FRAC (f1_0*8/10)      //80%
 497
 498
 499 void move_player_2_segment_and_rotate(segment *seg,int side)
 500 {
 501         vms_vector vp;
 502         vms_vector      upvec;
 503         static int edgenum=0;
 504
 505         compute_segment_center(&ConsoleObject->pos,seg);
 506         compute_center_point_on_side(&vp,seg,side);
 507         vm_vec_sub2(&vp,&ConsoleObject->pos);
 508
 509         vm_vec_sub(&upvec, &Vertices[Cursegp->verts[Side_to_verts[Curside][edgenum%4]]], &Vertices[Cursegp->verts[Side_to_verts[Curside][(edgenum+3)%4]]]);
 510         edgenum++;
 511
 512         vm_vector_2_matrix(&ConsoleObject->orient,&vp,&upvec,NULL);
 513 //      vm_vector_2_matrix(&ConsoleObject->orient,&vp,NULL,NULL);
 514
 515         obj_relink( ConsoleObject-Objects, SEG_PTR_2_NUM(seg) );
 516
 517 }
 518
 519 int SetPlayerFromCursegAndRotate()
 520 {
 521         move_player_2_segment_and_rotate(Cursegp,Curside);
 522         Update_flags |= UF_ED_STATE_CHANGED | UF_GAME_VIEW_CHANGED;
 523         return 1;
 524 }
 525
 526
 527 //sets the player facing curseg/curside, normal to face0 of curside, and
 528 //far enough away to see all of curside
 529 int SetPlayerFromCursegMinusOne()
 530 {
 531         vms_vector view_vec,view_vec2,side_center;
 532         vms_vector corner_v[4];
 533         vms_vector      upvec;
 534         g3s_point corner_p[4];
 535         int i;
 536         fix max,view_dist=f1_0*10;
 537         static int edgenum=0;
 538         int newseg;
 539
 540         view_vec = Cursegp->sides[Curside].normals[0];
 541         vm_vec_negate(&view_vec);
 542
 543         compute_center_point_on_side(&side_center,Cursegp,Curside);
 544         vm_vec_copy_scale(&view_vec2,&view_vec,view_dist);
 545         vm_vec_sub(&ConsoleObject->pos,&side_center,&view_vec2);
 546
 547         vm_vec_sub(&upvec, &Vertices[Cursegp->verts[Side_to_verts[Curside][edgenum%4]]], &Vertices[Cursegp->verts[Side_to_verts[Curside][(edgenum+3)%4]]]);
 548         edgenum++;
 549
 550         vm_vector_2_matrix(&ConsoleObject->orient,&view_vec,&upvec,NULL);
 551
 552         gr_set_current_canvas(Canv_editor_game);
 553         g3_start_frame();
 554         g3_set_view_matrix(&ConsoleObject->pos,&ConsoleObject->orient,Render_zoom);
 555
 556         for (i=max=0;i<4;i++) {
 557                 corner_v[i] = Vertices[Cursegp->verts[Side_to_verts[Curside][i]]];
 558                 g3_rotate_point(&corner_p[i],&corner_v[i]);
 559                 if (labs(corner_p[i].p3_x) > max) max = labs(corner_p[i].p3_x);
 560                 if (labs(corner_p[i].p3_y) > max) max = labs(corner_p[i].p3_y);
 561         }
 562
 563         view_dist = fixmul(view_dist,fixdiv(fixdiv(max,SIDE_VIEW_FRAC),corner_p[0].p3_z));
 564         vm_vec_copy_scale(&view_vec2,&view_vec,view_dist);
 565         vm_vec_sub(&ConsoleObject->pos,&side_center,&view_vec2);
 566
 567         //obj_relink(ConsoleObject-Objects, SEG_PTR_2_NUM(Cursegp) );
 568         //update_object_seg(ConsoleObject);             //might have backed right out of curseg
 569
 570         newseg = find_point_seg(&ConsoleObject->pos,SEG_PTR_2_NUM(Cursegp) );
 571         if (newseg != -1)
 572                 obj_relink(ConsoleObject-Objects,newseg);
 573
 574         Update_flags |= UF_ED_STATE_CHANGED | UF_GAME_VIEW_CHANGED;
 575         return 1;
 576 }
 577
 578 int ToggleLighting(void)
 579 {
 580         char    outstr[80] = "[shift-L] ";
 581         int     chindex;
 582
 583         Lighting_on++;
 584         if (Lighting_on >= 2)
 585                 Lighting_on = 0;
 586
 587         Update_flags |= UF_GAME_VIEW_CHANGED;
 588
 589         if (last_keypress == KEY_L + KEY_SHIFTED)
 590                 chindex = 0;
 591         else
 592                 chindex = 10;
 593
 594         switch (Lighting_on) {
 595                 case 0:
 596                         strcpy(&outstr[chindex],"Lighting off.");
 597                         break;
 598                 case 1:
 599                         strcpy(&outstr[chindex],"Static lighting.");
 600                         break;
 601                 case 2:
 602                         strcpy(&outstr[chindex],"Ship lighting.");
 603                         break;
 604                 case 3:
 605                         strcpy(&outstr[chindex],"Ship and static lighting.");
 606                         break;
 607         }
 608
 609         diagnostic_message(outstr);
 610
 611         return Lighting_on;
 612 }
 613
 614 void find_concave_segs();
 615
 616 int FindConcaveSegs()
 617 {
 618         find_concave_segs();
 619
 620         Update_flags |= UF_ED_STATE_CHANGED;            //list may have changed
 621
 622         return 1;
 623 }
 624
 625 int DosShell()
 626 {
 627         int ok, w, h;
 628         grs_bitmap * save_bitmap;
 629
 630         ok = 1;
 631
 632         // Save the current graphics state.
 633
 634         w = grd_curscreen->sc_canvas.cv_bitmap.bm_w;
 635         h = grd_curscreen->sc_canvas.cv_bitmap.bm_h;
 636
 637         save_bitmap = gr_create_bitmap( w, h );
 638         gr_bm_ubitblt(w, h, 0, 0, 0, 0, &(grd_curscreen->sc_canvas.cv_bitmap), save_bitmap );
 639
 640         gr_set_mode( SM_ORIGINAL );
 641
 642         printf( "\n\nType EXIT to return to Inferno" );
 643         fflush(stdout);
 644
 645         key_close();
 646 #ifdef __MSDOS__
 647         ok = spawnl(P_WAIT,getenv("COMSPEC"), NULL );
 648 #elif defined(__linux__)
 649         system("");
 650 #endif
 651         key_init();
 652
 653         gr_set_mode(grd_curscreen->sc_mode);
 654         gr_bm_ubitblt(w, h, 0, 0, 0, 0, save_bitmap, &(grd_curscreen->sc_canvas.cv_bitmap));
 655         gr_free_bitmap( save_bitmap );
 656         //gr_pal_setblock( 0, 256, grd_curscreen->pal );
 657         //gr_use_palette_table();
 658
 659         return ok;
 660
 661 }
 662
 663 int ToggleOutlineMode()
 664 {       int mode;
 665
 666         mode=toggle_outline_mode();
 667
 668         if (mode)
 669          {
 670                 if (last_keypress != KEY_O)
 671                         diagnostic_message("[O] Outline Mode ON.");
 672                 else
 673                         diagnostic_message("Outline Mode ON.");
 674          }
 675         else
 676          {
 677                 if (last_keypress != KEY_O)
 678                         diagnostic_message("[O] Outline Mode OFF.");
 679                 else
 680                         diagnostic_message("Outline Mode OFF.");
 681          }
 682
 683         Update_flags |= UF_GAME_VIEW_CHANGED;
 684         return mode;
 685 }
 686
 687 //@@int do_reset_orient()
 688 //@@{
 689 //@@    slew_reset_orient(SlewObj);
 690 //@@
 691 //@@    Update_flags |= UF_GAME_VIEW_CHANGED;
 692 //@@
 693 //@@    * (ubyte *) 0x417 &= ~0x20;
 694 //@@
 695 //@@    return 1;
 696 //@@}
 697
 698 int GameZoomOut()
 699 {
 700         Render_zoom = fixmul(Render_zoom,68985);
 701         Update_flags |= UF_GAME_VIEW_CHANGED;
 702         return 1;
 703 }
 704
 705 int GameZoomIn()
 706 {
 707         Render_zoom = fixmul(Render_zoom,62259);
 708         Update_flags |= UF_GAME_VIEW_CHANGED;
 709         return 1;
 710 }
 711
 712
 713 int med_keypad_goto_0() {       ui_pad_goto(0); return 0;       }
 714 int med_keypad_goto_1() {       ui_pad_goto(1); return 0;       }
 715 int med_keypad_goto_2() {       ui_pad_goto(2); return 0;       }
 716 int med_keypad_goto_3() {       ui_pad_goto(3); return 0;       }
 717 int med_keypad_goto_4() {       ui_pad_goto(4); return 0;       }
 718 int med_keypad_goto_5() {       ui_pad_goto(5); return 0;       }
 719 int med_keypad_goto_6() {       ui_pad_goto(6); return 0;       }
 720 int med_keypad_goto_7() {       ui_pad_goto(7); return 0;       }
 721 int med_keypad_goto_8() {       ui_pad_goto(8); return 0;       }
 722
 723 #define PAD_WIDTH       30
 724 #define PAD_WIDTH1      (PAD_WIDTH + 7)
 725
 726 int editor_screen_open = 0;
 727
 728 //setup the editors windows, canvases, gadgets, etc.
 729 //called whenever the editor screen is selected
 730 void init_editor_screen()
 731 {
 732 //      grs_bitmap * bmp;
 733
 734         if (editor_screen_open) return;
 735
 736         grd_curscreen->sc_canvas.cv_font = editor_font;
 737
 738         //create canvas for game on the editor screen
 739         initializing = 1;
 740         gr_set_current_canvas(Canv_editor);
 741         Canv_editor->cv_font = editor_font;
 742         gr_init_sub_canvas(Canv_editor_game,Canv_editor,GAMEVIEW_X,GAMEVIEW_Y,GAMEVIEW_W,GAMEVIEW_H);
 743
 744         //Editor renders into full (320x200) game screen
 745
 746         init_info = 1;
 747
 748         //do other editor screen setup
 749
 750         // Since the palette might have changed, find some good colors...
 751         CBLACK = gr_find_closest_color( 1, 1, 1 );
 752         CGREY = gr_find_closest_color( 28, 28, 28 );
 753         CWHITE = gr_find_closest_color( 38, 38, 38 );
 754         CBRIGHT = gr_find_closest_color( 60, 60, 60 );
 755         CRED = gr_find_closest_color( 63, 0, 0 );
 756
 757         gr_set_curfont(editor_font);
 758         gr_set_fontcolor( CBLACK, CWHITE );
 759
 760         EditorWindow = ui_open_window( 0 , 0, ED_SCREEN_W, ED_SCREEN_H, WIN_FILLED );
 761
 762         LargeViewBox    = ui_add_gadget_userbox( EditorWindow,LVIEW_X,LVIEW_Y,LVIEW_W,LVIEW_H);
 763 #if ORTHO_VIEWS
 764         TopViewBox              = ui_add_gadget_userbox( EditorWindow,TVIEW_X,TVIEW_Y,TVIEW_W,TVIEW_H);
 765         FrontViewBox    = ui_add_gadget_userbox( EditorWindow,FVIEW_X,FVIEW_Y,FVIEW_W,FVIEW_H);
 766         RightViewBox    = ui_add_gadget_userbox( EditorWindow,RVIEW_X,RVIEW_Y,RVIEW_W,RVIEW_H);
 767 #endif
 768         ui_gadget_calc_keys(EditorWindow);      //make tab work for all windows
 769
 770         GameViewBox     = ui_add_gadget_userbox( EditorWindow, GAMEVIEW_X, GAMEVIEW_Y, GAMEVIEW_W, GAMEVIEW_H );
 771 //      GroupViewBox    = ui_add_gadget_userbox( EditorWindow,GVIEW_X,GVIEW_Y,GVIEW_W,GVIEW_H);
 772
 773 //      GameViewBox->when_tab = GameViewBox->when_btab = (UI_GADGET *) LargeViewBox;
 774 //      LargeViewBox->when_tab = LargeViewBox->when_btab = (UI_GADGET *) GameViewBox;
 775
 776 //      ui_gadget_calc_keys(EditorWindow);      //make tab work for all windows
 777
 778         ViewIcon        = ui_add_gadget_icon( EditorWindow, "Lock\nview",       455,25+530,     40, 22, KEY_V+KEY_CTRLED, ToggleLockViewToCursegp );
 779         AllIcon = ui_add_gadget_icon( EditorWindow, "Draw\nall",        500,25+530,     40, 22, KEY_A+KEY_CTRLED, ToggleDrawAllSegments );
 780         AxesIcon        = ui_add_gadget_icon( EditorWindow, "Coord\naxes",545,25+530,           40, 22, KEY_D+KEY_CTRLED, ToggleCoordAxes );
 781 //-NOLIGHTICON- LightIcon       = ui_add_gadget_icon( EditorWindow, "Light\ning",       590,25+530,     40, 22, KEY_L+KEY_SHIFTED,ToggleLighting );
 782         ChaseIcon       = ui_add_gadget_icon( EditorWindow, "Chase\nmode",635,25+530,           40, 22, -1,                             ToggleChaseMode );
 783         OutlineIcon = ui_add_gadget_icon( EditorWindow, "Out\nline",    680,25+530,     40, 22, KEY_O,                  ToggleOutlineMode );
 784         LockIcon        = ui_add_gadget_icon( EditorWindow, "Lock\nstep", 725,25+530,   40, 22, KEY_L,                  ToggleLockstep );
 785
 786         meddraw_init_views(LargeViewBox->canvas);
 787
 788         //ui_add_gadget_button( EditorWindow, 460, 510, 50, 25, "Quit", ExitEditor );
 789         //ui_add_gadget_button( EditorWindow, 520, 510, 50, 25, "Lisp", CallLisp );
 790         //ui_add_gadget_button( EditorWindow, 580, 510, 50, 25, "Mine", MineMenu );
 791         //ui_add_gadget_button( EditorWindow, 640, 510, 50, 25, "Help", DoHelp );
 792         //ui_add_gadget_button( EditorWindow, 460, 540, 50, 25, "Macro", MacroMenu );
 793         //ui_add_gadget_button( EditorWindow, 520, 540, 50, 25, "About", ShowAbout );
 794         //ui_add_gadget_button( EditorWindow, 640, 540, 50, 25, "Shell", DosShell );
 795
 796         ui_pad_activate( EditorWindow, PAD_X, PAD_Y );
 797         Pad_text_canvas = gr_create_sub_canvas(Canv_editor, PAD_X + 250, PAD_Y + 8, 180, 160);
 798         ui_add_gadget_button( EditorWindow, PAD_X+6, PAD_Y+(30*5)+22, PAD_WIDTH, 20, "<<",  med_keypad_goto_prev );
 799         ui_add_gadget_button( EditorWindow, PAD_X+PAD_WIDTH1+6, PAD_Y+(30*5)+22, PAD_WIDTH, 20, ">>",  med_keypad_goto_next );
 800
 801         {       int     i;
 802                 i = 0;  ui_add_gadget_button( EditorWindow, PAD_X+16+(i+2)*PAD_WIDTH1, PAD_Y+(30*5)+22, PAD_WIDTH, 20, "SR",  med_keypad_goto_0 );
 803                 i++;            ui_add_gadget_button( EditorWindow, PAD_X+16+(i+2)*PAD_WIDTH1, PAD_Y+(30*5)+22, PAD_WIDTH, 20, "SS",  med_keypad_goto_1 );
 804                 i++;            ui_add_gadget_button( EditorWindow, PAD_X+16+(i+2)*PAD_WIDTH1, PAD_Y+(30*5)+22, PAD_WIDTH, 20, "CF",  med_keypad_goto_2 );
 805                 i++;            ui_add_gadget_button( EditorWindow, PAD_X+16+(i+2)*PAD_WIDTH1, PAD_Y+(30*5)+22, PAD_WIDTH, 20, "TM",  med_keypad_goto_3 );
 806                 i++;            ui_add_gadget_button( EditorWindow, PAD_X+16+(i+2)*PAD_WIDTH1, PAD_Y+(30*5)+22, PAD_WIDTH, 20, "OP",  med_keypad_goto_4 );
 807                 i++;            ui_add_gadget_button( EditorWindow, PAD_X+16+(i+2)*PAD_WIDTH1, PAD_Y+(30*5)+22, PAD_WIDTH, 20, "OR",  med_keypad_goto_5 );
 808                 i++;            ui_add_gadget_button( EditorWindow, PAD_X+16+(i+2)*PAD_WIDTH1, PAD_Y+(30*5)+22, PAD_WIDTH, 20, "GE",  med_keypad_goto_6 );
 809                 i++;            ui_add_gadget_button( EditorWindow, PAD_X+16+(i+2)*PAD_WIDTH1, PAD_Y+(30*5)+22, PAD_WIDTH, 20, "LI",  med_keypad_goto_7 );
 810                 i++;            ui_add_gadget_button( EditorWindow, PAD_X+16+(i+2)*PAD_WIDTH1, PAD_Y+(30*5)+22, PAD_WIDTH, 20, "TT",  med_keypad_goto_8 );
 811         }
 812
 813         gr_set_curfont(editor_font);
 814         menubar_show();
 815
 816         // INIT TEXTURE STUFF
 817         texpage_init( EditorWindow );
 818         objpage_init( EditorWindow );
 819
 820         EditorWindow->keyboard_focus_gadget = (UI_GADGET *)LargeViewBox;
 821
 822         canv_offscreen->cv_font = grd_curscreen->sc_canvas.cv_font;
 823 //      BigCanvas[0]->cv_font = grd_curscreen->sc_canvas.cv_font;
 824 //      BigCanvas[1]->cv_font = grd_curscreen->sc_canvas.cv_font;
 825 //      BigCanvasFirstTime = 1;
 826
 827         // Draw status box
 828         gr_set_current_canvas( NULL );
 829         gr_setcolor( CGREY );
 830         gr_rect(STATUS_X,STATUS_Y,STATUS_X+STATUS_W-1,STATUS_Y+STATUS_H-1);                     //0, 582, 799, 599 );
 831
 832         // Draw icon box
 833         // gr_set_current_canvas( NULL );
 834         //  gr_setcolor( CBRIGHT );
 835         //  gr_rect( 528, 2, 798, 22);
 836         //  gr_setcolor( CGREY);
 837         //  gr_rect( 530, 2, 799, 20);
 838
 839         Update_flags = UF_ALL;
 840         initializing = 0;
 841         editor_screen_open = 1;
 842 }
 843
 844 //shutdown ui on the editor screen
 845 void close_editor_screen()
 846 {
 847         if (!editor_screen_open) return;
 848
 849         editor_screen_open = 0;
 850         ui_pad_deactivate();
 851         gr_free_sub_canvas(Pad_text_canvas);
 852
 853         ui_close_window(EditorWindow);
 854
 855         close_all_windows();
 856
 857         // CLOSE TEXTURE STUFF
 858         texpage_close();
 859         objpage_close();
 860
 861         menubar_hide();
 862
 863 }
 864
 865 void med_show_warning(char *s)
 866 {
 867         grs_canvas *save_canv=grd_curcanv;
 868
 869         //gr_pal_fade_in(grd_curscreen->pal);   //in case palette is blacked
 870
 871         MessageBox(-2,-2,1,s,"OK");
 872
 873         gr_set_current_canvas(save_canv);
 874
 875 }
 876
 877 // Returns 1 if OK to trash current mine.
 878 int SafetyCheck()
 879 {
 880         int x;
 881
 882         if (mine_changed) {
 883                 stop_time();
 884                 x = nm_messagebox( "Warning!", 2, "Cancel", "OK", "You are about to lose work." );
 885                 if (x<1) {
 886                         start_time();
 887                         return 0;
 888                 }
 889                 start_time();
 890         }
 891         return 1;
 892 }
 893
 894 //called at the end of the program
 895 void close_editor() {
 896
 897         close_autosave();
 898
 899         menubar_close();
 900
 901         gr_close_font(editor_font);
 902
 903         gr_free_canvas(canv_offscreen); canv_offscreen = NULL;
 904
 905         return;
 906
 907 }
 908
 909 //variables for find segments process
 910
 911 // ---------------------------------------------------------------------------------------------------
 912 //      Subtract all elements in Found_segs from selected list.
 913 void subtract_found_segments_from_selected_list(void)
 914 {
 915         int     s,f;
 916
 917         for (f=0; f<N_found_segs; f++) {
 918                 int     foundnum = Found_segs[f];
 919
 920                 for (s=0; s<N_selected_segs; s++) {
 921                         if (Selected_segs[s] == foundnum) {
 922                                 Selected_segs[s] = Selected_segs[N_selected_segs-1];
 923                                 N_selected_segs--;
 924                                 break;
 925                         }
 926                 }
 927         }
 928 }
 929
 930 // ---------------------------------------------------------------------------------------------------
 931 //      Add all elements in Found_segs to selected list.
 932 void add_found_segments_to_selected_list(void) {
 933         int     s,f;
 934
 935         for (f=0; f<N_found_segs; f++) {
 936                 int     foundnum = Found_segs[f];
 937
 938                 for (s=0; s<N_selected_segs; s++)
 939                         if (Selected_segs[s] == foundnum)
 940                                 break;
 941
 942                 if (s == N_selected_segs)
 943                         Selected_segs[N_selected_segs++] = foundnum;
 944         }
 945 }
 946
 947 void gamestate_restore_check() {
 948         char Message[DIAGNOSTIC_MESSAGE_MAX];
 949         obj_position Save_position;
 950
 951         if (gamestate_not_restored) {
 952                 sprintf( Message, "Do you wish to restore game state?\n");
 953
 954                 if (MessageBox( -2, -2, 2, Message, "Yes", "No" )==1) {
 955
 956                         // Save current position
 957                         Save_position.pos = ConsoleObject->pos;
 958                         Save_position.orient = ConsoleObject->orient;
 959                         Save_position.segnum = ConsoleObject->segnum;
 960
 961                         load_level("GAMESAVE.LVL");
 962
 963                         // Restore current position
 964                         if (Save_position.segnum <= Highest_segment_index) {
 965                                 ConsoleObject->pos = Save_position.pos;
 966                                 ConsoleObject->orient = Save_position.orient;
 967                                 obj_relink(ConsoleObject-Objects,Save_position.segnum);
 968                         }
 969
 970                         gamestate_not_restored = 0;
 971                         Update_flags |= UF_WORLD_CHANGED;
 972                         }
 973                 else
 974                         gamestate_not_restored = 1;
 975                 }
 976 }
 977
 978 int RestoreGameState() {
 979         load_level("GAMESAVE.LVL");
 980         gamestate_not_restored = 0;
 981
 982         mprintf((0, "Gamestate restored.\n"));
 983         editor_status("Gamestate restored.\n");
 984
 985         Update_flags |= UF_WORLD_CHANGED;
 986         return 0;
 987 }
 988
 989 extern void check_wall_validity(void);
 990
 991 // ---------------------------------------------------------------------------------------------------
 992 //this function is the editor. called when editor mode selected.  runs until
 993 //game mode or exit selected
 994 void editor(void)
 995 {
 996         int w,h;
 997         grs_bitmap * savedbitmap;
 998         editor_view *new_cv;
 999         static int padnum=0;
1000         vms_matrix      MouseRotMat,tempm;
1001         //@@short camera_objnum;                        //a camera for viewing
1002
1003         init_editor();
1004
1005         InitCurve();
1006
1007         restore_effect_bitmap_icons();
1008
1009         if (!set_screen_mode(SCREEN_EDITOR))    {
1010                 set_screen_mode(SCREEN_GAME);
1011                 Function_mode=FMODE_GAME;                       //force back into game
1012                 return;
1013         }
1014
1015         gr_set_current_canvas( NULL );
1016         gr_set_curfont(editor_font);
1017
1018         //Editor renders into full (320x200) game screen
1019
1020         set_warn_func(med_show_warning);
1021
1022         keyd_repeat = 1;                // Allow repeat in editor
1023
1024 //      _MARK_("start of editor");//Nuked to compile -KRB
1025
1026         ui_mouse_hide();
1027
1028         ui_reset_idle_seconds();
1029
1030 //@@    //create a camera for viewing in the editor. copy position from ConsoleObject
1031 //@@    camera_objnum = obj_create(OBJ_CAMERA,0,ConsoleObject->segnum,&ConsoleObject->pos,&ConsoleObject->orient,0);
1032 //@@    Viewer = &Objects[camera_objnum];
1033 //@@    slew_init(Viewer);              //camera is slewing
1034
1035         Viewer = ConsoleObject;
1036         slew_init(ConsoleObject);
1037
1038         Update_flags = UF_ALL;
1039
1040         medlisp_update_screen();
1041
1042         //set the wire-frame window to be the current view
1043         current_view = &LargeView;
1044
1045         if (faded_in==0)
1046         {
1047                 faded_in = 1;
1048                 //gr_pal_fade_in( grd_curscreen->pal );
1049         }
1050
1051         w = GameViewBox->canvas->cv_bitmap.bm_w;
1052         h = GameViewBox->canvas->cv_bitmap.bm_h;
1053
1054         savedbitmap = gr_create_bitmap(w, h );
1055
1056         gr_bm_ubitblt( w, h, 0, 0, 0, 0, &GameViewBox->canvas->cv_bitmap, savedbitmap );
1057
1058         gr_set_current_canvas( GameViewBox->canvas );
1059         gr_set_curfont(editor_font);
1060         //gr_setcolor( CBLACK );
1061         //gr_deaccent_canvas();
1062         //gr_grey_canvas();
1063
1064         ui_mouse_show();
1065
1066         gr_set_curfont(editor_font);
1067         ui_pad_goto(padnum);
1068
1069         gamestate_restore_check();
1070
1071         while (Function_mode == FMODE_EDITOR) {
1072
1073                 gr_set_curfont(editor_font);
1074                 info_display_all(EditorWindow);
1075
1076                 ModeFlag = 0;
1077
1078                 // Update the windows
1079
1080                 // Only update if there is no key waiting and we're not in
1081                 // fast play mode.
1082                 if (!key_peekkey()) //-- && (MacroStatus != UI_STATUS_FASTPLAY))
1083                         medlisp_update_screen();
1084
1085                 //do editor stuff
1086                 gr_set_curfont(editor_font);
1087                 ui_mega_process();
1088                 last_keypress &= ~KEY_DEBUGGED;         //      mask off delete key bit which has no function in editor.
1089                 ui_window_do_gadgets(EditorWindow);
1090                 do_robot_window();
1091                 do_object_window();
1092                 do_wall_window();
1093                 do_trigger_window();
1094                 do_hostage_window();
1095                 do_centers_window();
1096                 check_wall_validity();
1097                 Assert(Num_walls>=0);
1098
1099                 if (Gameview_lockstep) {
1100                         static segment *old_cursegp=NULL;
1101                         static int old_curside=-1;
1102
1103                         if (old_cursegp!=Cursegp || old_curside!=Curside) {
1104                                 SetPlayerFromCursegMinusOne();
1105                                 old_cursegp = Cursegp;
1106                                 old_curside = Curside;
1107                         }
1108                 }
1109
1110 //              mprintf((0, "%d ", ui_get_idle_seconds() ));
1111
1112                 if ( ui_get_idle_seconds() > COMPRESS_INTERVAL )
1113                         {
1114                         med_compress_mine();
1115                         ui_reset_idle_seconds();
1116                         }
1117
1118 //      Commented out because it occupies about 25% of time in twirling the mine.
1119 // Removes some Asserts....
1120 //              med_check_all_vertices();
1121                 clear_editor_status();          // if enough time elapsed, clear editor status message
1122                 TimedAutosave(mine_filename);
1123                 set_editor_time_of_day();
1124                 gr_set_current_canvas( GameViewBox->canvas );
1125
1126                 // Remove keys used for slew
1127                 switch(last_keypress)
1128                 {
1129                 case KEY_PAD9:
1130                 case KEY_PAD7:
1131                 case KEY_PADPLUS:
1132                 case KEY_PADMINUS:
1133                 case KEY_PAD8:
1134                 case KEY_PAD2:
1135                 case KEY_LBRACKET:
1136                 case KEY_RBRACKET:
1137                 case KEY_PAD1:
1138                 case KEY_PAD3:
1139                 case KEY_PAD6:
1140                 case KEY_PAD4:
1141                         last_keypress = 0;
1142                 }
1143                 if ((last_keypress&0xff)==KEY_LSHIFT) last_keypress=0;
1144                 if ((last_keypress&0xff)==KEY_RSHIFT) last_keypress=0;
1145                 if ((last_keypress&0xff)==KEY_LCTRL) last_keypress=0;
1146                 if ((last_keypress&0xff)==KEY_RCTRL) last_keypress=0;
1147 //              if ((last_keypress&0xff)==KEY_LALT) last_keypress=0;
1148 //              if ((last_keypress&0xff)==KEY_RALT) last_keypress=0;
1149
1150                 gr_set_curfont(editor_font);
1151                 menubar_do( last_keypress );
1152
1153                 //=================== DO FUNCTIONS ====================
1154
1155                 if ( KeyFunction[ last_keypress ] != NULL )     {
1156                         KeyFunction[last_keypress]();
1157                         last_keypress = 0;
1158                 }
1159                 switch (last_keypress)
1160                 {
1161                 case 0:
1162                 case KEY_Z:
1163                 case KEY_G:
1164                 case KEY_LALT:
1165                 case KEY_RALT:
1166                 case KEY_LCTRL:
1167                 case KEY_RCTRL:
1168                 case KEY_LSHIFT:
1169                 case KEY_RSHIFT:
1170                 case KEY_LAPOSTRO:
1171                         break;
1172                 case KEY_SHIFTED + KEY_L:
1173                         ToggleLighting();
1174                         break;
1175                 case KEY_F1:
1176                         render_3d_in_big_window = !render_3d_in_big_window;
1177                         Update_flags |= UF_ALL;
1178                         break;
1179                 default:
1180                         {
1181                         char kdesc[100];
1182                         GetKeyDescription( kdesc, last_keypress );
1183                         editor_status("Error: %s isn't bound to anything.", kdesc  );
1184                         }
1185                 }
1186
1187                 //================================================================
1188
1189                 if (ModeFlag==1)
1190                 {
1191                         close_editor_screen();
1192                         Function_mode=FMODE_EXIT;
1193                                 gr_free_bitmap( savedbitmap );
1194                         break;
1195                 }
1196
1197                 if (ModeFlag==2) //-- && MacroStatus==UI_STATUS_NORMAL )
1198                 {
1199                         ui_mouse_hide();
1200                         Function_mode = FMODE_GAME;
1201                         gr_bm_ubitblt( w, h, 0, 0, 0, 0, savedbitmap, &GameViewBox->canvas->cv_bitmap);
1202                         gr_free_bitmap( savedbitmap );
1203                         break;
1204                 }
1205
1206                 if (ModeFlag==3) //-- && MacroStatus==UI_STATUS_NORMAL )
1207                 {
1208 //                      med_compress_mine();                                            //will be called anyways before game.
1209                         close_editor_screen();
1210                         Function_mode=FMODE_GAME;                       //force back into game
1211                         set_screen_mode(SCREEN_GAME);           //put up game screen
1212                         gr_free_bitmap( savedbitmap );
1213                         break;
1214                 }
1215
1216 //              if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)GameViewBox) current_view=NULL;
1217 //              if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)GroupViewBox) current_view=NULL;
1218
1219                 new_cv = current_view ;
1220
1221 #if ORTHO_VIEWS
1222                 if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)LargeViewBox) new_cv=&LargeView;
1223                 if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)TopViewBox)        new_cv=&TopView;
1224                 if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)FrontViewBox) new_cv=&FrontView;
1225                 if (CurWindow->keyboard_focus_gadget == (UI_GADGET *)RightViewBox) new_cv=&RightView;
1226 #endif
1227                 if (new_cv != current_view ) {
1228                         current_view->ev_changed = 1;
1229                         new_cv->ev_changed = 1;
1230                         current_view = new_cv;
1231                 }
1232
1233                 calc_frame_time();
1234                 if (slew_frame(0)) {            //do movement and check keys
1235                         Update_flags |= UF_GAME_VIEW_CHANGED;
1236                         if (Gameview_lockstep) {
1237                                 Cursegp = &Segments[ConsoleObject->segnum];
1238                                 med_create_new_segment_from_cursegp();
1239                                 Update_flags |= UF_ED_STATE_CHANGED;
1240                         }
1241                 }
1242
1243                 // DO TEXTURE STUFF
1244                 texpage_do();
1245                 objpage_do();
1246
1247
1248                 // Process selection of Cursegp using mouse.
1249                 if (LargeViewBox->mouse_onme && LargeViewBox->b1_clicked && !render_3d_in_big_window)
1250                 {
1251                         int     xcrd,ycrd;
1252                         xcrd = LargeViewBox->b1_drag_x1;
1253                         ycrd = LargeViewBox->b1_drag_y1;
1254
1255                         find_segments(xcrd,ycrd,LargeViewBox->canvas,&LargeView,Cursegp,Big_depth);     // Sets globals N_found_segs, Found_segs
1256
1257                         // If shift is down, then add segment to found list
1258                         if (keyd_pressed[ KEY_LSHIFT ] || keyd_pressed[ KEY_RSHIFT ])
1259                                 subtract_found_segments_from_selected_list();
1260                         else
1261                                 add_found_segments_to_selected_list();
1262
1263                         Found_seg_index = 0;
1264
1265                         if (N_found_segs > 0) {
1266                                 sort_seg_list(N_found_segs,Found_segs,&ConsoleObject->pos);
1267                                 Cursegp = &Segments[Found_segs[0]];
1268                                 med_create_new_segment_from_cursegp();
1269                                 if (Lock_view_to_cursegp)
1270                                         set_view_target_from_segment(Cursegp);
1271                         }
1272
1273                         Update_flags |= UF_ED_STATE_CHANGED | UF_VIEWPOINT_MOVED;
1274                 }
1275
1276                 if (GameViewBox->mouse_onme && GameViewBox->b1_dragging) {
1277                         int     x, y;
1278                         x = GameViewBox->b1_drag_x2;
1279                         y = GameViewBox->b1_drag_y2;
1280
1281                         ui_mouse_hide();
1282                         gr_set_current_canvas( GameViewBox->canvas );
1283                         gr_setcolor( 15 );
1284                         gr_rect( x-1, y-1, x+1, y+1 );
1285                         ui_mouse_show();
1286
1287                 }
1288
1289                 // Set current segment and side by clicking on a polygon in game window.
1290                 //      If ctrl pressed, also assign current texture map to that side.
1291                 //if (GameViewBox->mouse_onme && (GameViewBox->b1_done_dragging || GameViewBox->b1_clicked)) {
1292                 if ((GameViewBox->mouse_onme && GameViewBox->b1_clicked && !render_3d_in_big_window) ||
1293                         (LargeViewBox->mouse_onme && LargeViewBox->b1_clicked && render_3d_in_big_window)) {
1294
1295                         int     xcrd,ycrd;
1296                         int seg,side,face,poly,tmap;
1297
1298                         if (render_3d_in_big_window) {
1299                                 xcrd = LargeViewBox->b1_drag_x1;
1300                                 ycrd = LargeViewBox->b1_drag_y1;
1301                         }
1302                         else {
1303                                 xcrd = GameViewBox->b1_drag_x1;
1304                                 ycrd = GameViewBox->b1_drag_y1;
1305                         }
1306
1307                         //Int3();
1308
1309                         if (find_seg_side_face(xcrd,ycrd,&seg,&side,&face,&poly)) {
1310
1311
1312                                 if (seg<0) {                                                    //found an object
1313
1314                                         Cur_object_index = -seg-1;
1315                                         editor_status("Object %d selected.",Cur_object_index);
1316
1317                                         Update_flags |= UF_ED_STATE_CHANGED;
1318                                 }
1319                                 else {
1320
1321                                         //      See if either shift key is down and, if so, assign texture map
1322                                         if (keyd_pressed[KEY_LSHIFT] || keyd_pressed[KEY_RSHIFT]) {
1323                                                 Cursegp = &Segments[seg];
1324                                                 Curside = side;
1325                                                 AssignTexture();
1326                                                 med_create_new_segment_from_cursegp();
1327                                                 editor_status("Texture assigned");
1328                                         } else if (keyd_pressed[KEY_G]) {
1329                                                 tmap = Segments[seg].sides[side].tmap_num;
1330                                                 texpage_grab_current(tmap);
1331                                                 editor_status( "Texture grabbed." );
1332                                         } else if (keyd_pressed[ KEY_LAPOSTRO] ) {
1333                                                 ui_mouse_hide();
1334                                                 move_object_to_mouse_click();
1335                                         } else {
1336                                                 Cursegp = &Segments[seg];
1337                                                 Curside = side;
1338                                                 med_create_new_segment_from_cursegp();
1339                                                 editor_status("Curseg and curside selected");
1340                                         }
1341                                 }
1342
1343                                 Update_flags |= UF_ED_STATE_CHANGED;
1344                         }
1345                         else
1346                                 editor_status("Click on non-texture ingored");
1347
1348                 }
1349
1350                 // Allow specification of LargeView using mouse
1351                 if (keyd_pressed[ KEY_LCTRL ] || keyd_pressed[ KEY_RCTRL ]) {
1352                         ui_mouse_hide();
1353                         if ( (Mouse.dx!=0) && (Mouse.dy!=0) ) {
1354                                 GetMouseRotation( Mouse.dx, Mouse.dy, &MouseRotMat );
1355                                 vm_matrix_x_matrix(&tempm,&LargeView.ev_matrix,&MouseRotMat);
1356                                 LargeView.ev_matrix = tempm;
1357                                 LargeView.ev_changed = 1;
1358                                 Large_view_index = -1;                  // say not one of the orthogonal views
1359                         }
1360                 } else  {
1361                         ui_mouse_show();
1362                 }
1363
1364                 if ( keyd_pressed[ KEY_Z ] ) {
1365                         ui_mouse_hide();
1366                         if ( Mouse.dy!=0 ) {
1367                                 current_view->ev_dist += Mouse.dy*10000;
1368                                 current_view->ev_changed = 1;
1369                         }
1370                 } else {
1371                         ui_mouse_show();
1372                 }
1373
1374         }
1375
1376 //      _MARK_("end of editor");//Nuked to compile -KRB
1377
1378         clear_warn_func(med_show_warning);
1379
1380         //kill our camera object
1381
1382         Viewer = ConsoleObject;                                 //reset viewer
1383         //@@obj_delete(camera_objnum);
1384
1385         padnum = ui_pad_get_current();
1386
1387         close_editor();
1388         ui_close();
1389
1390
1391 }
1392
1393 void test_fade(void)
1394 {
1395         int     i,c;
1396
1397         for (c=0; c<256; c++) {
1398                 printf("%4i: {%3i %3i %3i} ",c,gr_palette[3*c],gr_palette[3*c+1],gr_palette[3*c+2]);
1399                 for (i=0; i<16; i++) {
1400                         int col = gr_fade_table[256*i+c];
1401
1402                         printf("[%3i %3i %3i] ",gr_palette[3*col],gr_palette[3*col+1],gr_palette[3*col+2]);
1403                 }
1404                 if ( (c%16) == 15)
1405                         printf("\n");
1406                 printf("\n");
1407         }
1408 }
1409
1410 void dump_stuff(void)
1411 {
1412         int     i,j,prev_color;
1413
1414         printf("Palette:\n");
1415
1416         for (i=0; i<256; i++)
1417                 printf("%3i: %2i %2i %2i\n",i,gr_palette[3*i],gr_palette[3*i+1],gr_palette[3*i+2]);
1418
1419         for (i=0; i<16; i++) {
1420                 printf("\nFade table #%i\n",i);
1421                 for (j=0; j<256; j++) {
1422                         int     c = gr_fade_table[i*256 + j];
1423                         printf("[%3i %2i %2i %2i] ",c, gr_palette[3*c], gr_palette[3*c+1], gr_palette[3*c+2]);
1424                         if ((j % 8) == 7)
1425                                 printf("\n");
1426                 }
1427         }
1428
1429         printf("Colors indexed by intensity:\n");
1430         printf(". = change from previous, * = no change\n");
1431         for (j=0; j<256; j++) {
1432                 printf("%3i: ",j);
1433                 prev_color = -1;
1434                 for (i=0; i<16; i++) {
1435                         int     c = gr_fade_table[i*256 + j];
1436                         if (c == prev_color)
1437                                 printf("*");
1438                         else
1439                                 printf(".");
1440                         prev_color = c;
1441                 }
1442                 printf("  ");
1443                 for (i=0; i<16; i++) {
1444                         int     c = gr_fade_table[i*256 + j];
1445                         printf("[%3i %2i %2i %2i] ", c, gr_palette[3*c], gr_palette[3*c+1], gr_palette[3*c+2]);
1446                 }
1447                 printf("\n");
1448         }
1449
1450 }
1451
1452
1453 int MarkStart(void)
1454 {
1455         char mystr[30];
1456         sprintf(mystr,"mark %i start",Mark_count);
1457 //      _MARK_(mystr);//Nuked to compile -KRB
1458
1459         return 1;
1460 }
1461
1462 int MarkEnd(void)
1463 {
1464         char mystr[30];
1465         sprintf(mystr,"mark %i end",Mark_count);
1466         Mark_count++;
1467 //      _MARK_(mystr);//Nuked to compile -KRB
1468
1469         return 1;
1470 }
1471