main/editor/objpage.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 /*
  15  *
  16  * object selection stuff.
  17  *
  18  */
  19
  20 // Num_robot_types -->  N_polygon_models
  21 // Cur_robot_type --> Cur_robot_type
  22 // Texture[Cur_robot_type]->bitmap  ---> robot_bms[robot_bm_nums[ Cur_robot_type ] ]
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "conf.h"
  26 #endif
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30
  31
  32 #include "inferno.h"
  33 #include "screens.h"                    // For GAME_SCREEN?????
  34 #include "editor.h"                     // For TMAP_CURBOX??????
  35 #include "gr.h"                         // For canves, font stuff
  36 #include "ui.h"                         // For UI_GADGET stuff
  37 #include "object.h"                     // For robot_bms
  38 #include "mono.h"                               // For debugging
  39 #include "error.h"
  40
  41 #include "objpage.h"
  42 #include "bm.h"
  43 #include "player.h"
  44 #include "piggy.h"
  45 #include "cntrlcen.h"
  46
  47 #define OBJS_PER_PAGE 8
  48
  49 static UI_GADGET_USERBOX * ObjBox[OBJS_PER_PAGE];
  50 static UI_GADGET_USERBOX * ObjCurrent;
  51
  52 static int ObjectPage = 0;
  53
  54 //static char Description[8][20] = { "Pig", "Star", "Little\nJosh", "Big\nJosh", "Flying\nPig", "Flying\nStar",
  55 //"Little\nFlying\nJosh", "Big\nFlying\nJosh" };
  56
  57 //static grs_canvas * ObjnameCanvas;
  58 //static char object_filename[13];
  59
  60 //static void objpage_print_name( char name[13] ) {
  61 //       short w,h,aw;
  62 //
  63 //    gr_set_current_canvas( ObjnameCanvas );
  64 //    gr_get_string_size( name, &w, &h, &aw );
  65 //    gr_string( 0, 0, name );
  66 //       //gr_set_fontcolor( CBLACK, CWHITE );
  67 //}
  68
  69 //static void objpage_display_name( char *format, ... ) {
  70 //      va_list ap;
  71 //
  72 //      va_start(ap, format);
  73 //   vsprintf(object_filename, format, ap);
  74 //      va_end(ap);
  75 //
  76 //   objpage_print_name(object_filename);
  77 //
  78 //}
  79
  80 #include "vecmat.h"
  81 #include "3d.h"
  82 #include "polyobj.h"
  83 #include "texmap.h"
  84
  85 #include "hostage.h"
  86 #include "powerup.h"
  87
  88 vms_angvec objpage_view_orient;
  89 fix objpage_view_dist;
  90
  91 //this is bad to have the extern, but this snapshot stuff is special
  92 extern int polyobj_lighting;
  93
  94
  95 //canvas set
  96 void draw_object_picture(int id, vms_angvec *orient_angles, int type)
  97 {
  98
  99         if (id >= Num_object_subtypes)
 100                 return;
 101
 102         switch (type) {
 103
 104                 case OBJ_HOSTAGE:
 105                         PIGGY_PAGE_IN(Vclip[Hostage_vclip_num[id]].frames[0]);
 106                         gr_bitmap(0,0,&GameBitmaps[Vclip[Hostage_vclip_num[id]].frames[0].index]);
 107                         break;
 108
 109                 case OBJ_POWERUP:
 110                         if ( Powerup_info[id].vclip_num > -1 )  {
 111                                 PIGGY_PAGE_IN(Vclip[Powerup_info[id].vclip_num].frames[0]);
 112                                 gr_bitmap(0,0,&GameBitmaps[Vclip[Powerup_info[id].vclip_num].frames[0].index]);
 113                         }
 114                         break;
 115
 116                 case OBJ_PLAYER:
 117                         draw_model_picture(Player_ship->model_num,orient_angles);               // Draw a poly model below
 118                         break;
 119
 120                 case OBJ_ROBOT:
 121                         draw_model_picture(Robot_info[id].model_num,orient_angles);     // Draw a poly model below
 122                         break;
 123
 124                 case OBJ_CNTRLCEN:
 125                 case OBJ_CLUTTER:
 126                         draw_model_picture(Reactors[id].model_num, orient_angles);
 127                         break;
 128                 default:
 129                         //Int3();       // Invalid type!!!
 130                         return;
 131         }
 132
 133 }
 134
 135 void redraw_current_object()
 136 {
 137         grs_canvas * cc;
 138
 139         cc = grd_curcanv;
 140         gr_set_current_canvas(ObjCurrent->canvas);
 141         draw_object_picture(Cur_object_id, &objpage_view_orient, Cur_object_type);
 142         gr_set_current_canvas(cc);
 143 }
 144
 145 void gr_label_box( int i)
 146 {
 147
 148         gr_clear_canvas(BM_XRGB(0,0,0));
 149         draw_object_picture(i, &objpage_view_orient, Cur_object_type);
 150
 151 //      char s[20];
 152 //      sprintf( s, " %d ", i );
 153 //      gr_clear_canvas( BM_XRGB(0,15,0) );
 154 //      gr_set_fontcolor( CWHITE, BM_XRGB(0,15,0) );
 155 //      ui_string_centered(  grd_curcanv->cv_bitmap.bm_w/2, grd_curcanv->cv_bitmap.bm_h/2, Description[i] );
 156 }
 157
 158 int objpage_goto_first()
 159 {
 160         int i;
 161
 162         ObjectPage=0;
 163         for (i=0;  i<OBJS_PER_PAGE; i++ ) {
 164                 gr_set_current_canvas(ObjBox[i]->canvas);
 165                 if (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes ) {
 166                         //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 167                         gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 168                 } else
 169                         gr_clear_canvas( CGREY );
 170         }
 171
 172         return 1;
 173 }
 174
 175 int objpage_goto_last()
 176 {
 177         int i;
 178
 179         ObjectPage=(Num_object_subtypes)/OBJS_PER_PAGE;
 180         for (i=0;  i<OBJS_PER_PAGE; i++ )
 181         {
 182                 gr_set_current_canvas(ObjBox[i]->canvas);
 183                 if (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes )
 184                 {
 185                         //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 186                         gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 187                 } else {
 188                         gr_clear_canvas( CGREY );
 189                 }
 190         }
 191         return 1;
 192 }
 193
 194 static int objpage_goto_prev()
 195 {
 196         int i;
 197         if (ObjectPage > 0) {
 198                 ObjectPage--;
 199                 for (i=0;  i<OBJS_PER_PAGE; i++ )
 200                 {
 201                         gr_set_current_canvas(ObjBox[i]->canvas);
 202                         if (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes)
 203                         {
 204                                 //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 205                                 gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 206                         } else {
 207                                 gr_clear_canvas( CGREY );
 208                         }
 209                 }
 210         }
 211         return 1;
 212 }
 213
 214 static int objpage_goto_next()
 215 {
 216         int i;
 217         if ((ObjectPage+1)*OBJS_PER_PAGE < Num_object_subtypes) {
 218                 ObjectPage++;
 219                 for (i=0;  i<OBJS_PER_PAGE; i++ )
 220                 {
 221                         gr_set_current_canvas(ObjBox[i]->canvas);
 222                         if (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes)
 223                         {
 224                                 //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 225                                 gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 226                         } else {
 227                                 gr_clear_canvas( CGREY );
 228                         }
 229                 }
 230         }
 231         return 1;
 232 }
 233
 234 int objpage_grab_current(int n)
 235 {
 236         int i;
 237
 238         if ((n < 0) || (n >= Num_object_subtypes)) return 0;
 239
 240         ObjectPage = n / OBJS_PER_PAGE;
 241
 242         if (ObjectPage*OBJS_PER_PAGE < Num_object_subtypes) {
 243                 for (i=0;  i<OBJS_PER_PAGE; i++ )
 244                 {
 245                         gr_set_current_canvas(ObjBox[i]->canvas);
 246                         if (i + ObjectPage*OBJS_PER_PAGE < Num_object_subtypes)
 247                         {
 248                                 //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 249                                 gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 250                         } else {
 251                                 gr_clear_canvas( CGREY );
 252                         }
 253                 }
 254         }
 255
 256         Cur_object_id = n;
 257         gr_set_current_canvas(ObjCurrent->canvas);
 258         //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ Cur_robot_type ] ] );
 259         gr_label_box(Cur_object_id);
 260
 261         //objpage_display_name( Texture[Cur_robot_type]->filename );
 262
 263         return 1;
 264 }
 265
 266 int objpage_goto_next_object()
 267 {
 268         // there should be a pop-up menu for this
 269         switch (Cur_object_type)
 270         {
 271                 case OBJ_ROBOT:
 272                         Cur_object_type = OBJ_HOSTAGE;
 273                         Num_object_subtypes = 1;
 274                         break;
 275
 276                 case OBJ_HOSTAGE:
 277                         Cur_object_type = OBJ_PLAYER;
 278                         Num_object_subtypes = 1;        // can have anarchy/coop, but this is handled automatically
 279                         break;
 280
 281                 case OBJ_PLAYER:
 282                         Cur_object_type = OBJ_POWERUP;
 283                         Num_object_subtypes = N_powerup_types;
 284                         break;
 285
 286                 case OBJ_POWERUP:
 287                         Cur_object_type = OBJ_CNTRLCEN;
 288                         Num_object_subtypes = Num_reactors;
 289                         break;
 290
 291                 case OBJ_CNTRLCEN:
 292                 default:
 293                         Cur_object_type = OBJ_ROBOT;
 294                         Num_object_subtypes = N_robot_types;
 295                         break;
 296         }
 297
 298         objpage_grab_current(0);
 299
 300         return 1;
 301
 302 }
 303
 304 #define OBJBOX_X        (TMAPBOX_X)     //location of first one
 305 #define OBJBOX_Y        (OBJCURBOX_Y - 24 )
 306 #define OBJBOX_W        64
 307 #define OBJBOX_H        64
 308
 309 #define DELTA_ANG 0x800
 310
 311 int objpage_increase_pitch()
 312 {
 313         objpage_view_orient.p += DELTA_ANG;
 314         redraw_current_object();
 315         return 1;
 316 }
 317
 318 int objpage_decrease_pitch()
 319 {
 320         objpage_view_orient.p -= DELTA_ANG;
 321         redraw_current_object();
 322         return 1;
 323 }
 324
 325 int objpage_increase_heading()
 326 {
 327         objpage_view_orient.h += DELTA_ANG;
 328         redraw_current_object();
 329         return 1;
 330 }
 331
 332 int objpage_decrease_heading()
 333 {
 334         objpage_view_orient.h -= DELTA_ANG;
 335         redraw_current_object();
 336         return 1;
 337 }
 338
 339 int objpage_increase_bank()
 340 {
 341         objpage_view_orient.b += DELTA_ANG;
 342         redraw_current_object();
 343         return 1;
 344 }
 345
 346 int objpage_decrease_bank()
 347 {
 348         objpage_view_orient.b -= DELTA_ANG;
 349         redraw_current_object();
 350         return 1;
 351 }
 352
 353 int objpage_increase_z()
 354 {
 355         objpage_view_dist -= 0x8000;
 356         redraw_current_object();
 357         return 1;
 358 }
 359
 360 int objpage_decrease_z()
 361 {
 362         objpage_view_dist += 0x8000;
 363         redraw_current_object();
 364         return 1;
 365 }
 366
 367 int objpage_reset_orient()
 368 {
 369         objpage_view_orient.p = 0;
 370         objpage_view_orient.b = 0;
 371         objpage_view_orient.h = -0x8000;
 372         //objpage_view_dist = DEFAULT_VIEW_DIST;
 373         redraw_current_object();
 374         return 1;
 375 }
 376
 377
 378 // INIT TEXTURE STUFF
 379
 380 void objpage_init( UI_WINDOW *win )
 381 {
 382         int i;
 383
 384         //Num_total_object_types = N_polygon_models + N_hostage_types + N_powerup_types;
 385         //Assert (N_polygon_models < MAX_POLYGON_MODELS);
 386         //Assert (Num_total_object_types < MAX_OBJTYPE );
 387         //Assert (N_hostage_types < MAX_HOSTAGE_TYPES );
 388         //Assert (N_powerup_types < MAX_POWERUP_TYPES );
 389         // Assert (N_robot_types < MAX_ROBOTS);
 390
 391         ui_add_gadget_button( win, OBJCURBOX_X + 00, OBJCURBOX_Y - 27, 30, 20, "<<", objpage_goto_prev );
 392         ui_add_gadget_button( win, OBJCURBOX_X + 32, OBJCURBOX_Y - 27, 30, 20, ">>", objpage_goto_next );
 393
 394         ui_add_gadget_button( win, OBJCURBOX_X + 00, OBJCURBOX_Y - 54, 30, 20, "B", objpage_goto_first );
 395         ui_add_gadget_button( win, OBJCURBOX_X + 32, OBJCURBOX_Y - 54, 30, 20, "E", objpage_goto_last );
 396
 397         ui_add_gadget_button( win, OBJCURBOX_X + 25, OBJCURBOX_Y + 62, 22, 13, "P-", objpage_decrease_pitch );
 398         ui_add_gadget_button( win, OBJCURBOX_X + 25, OBJCURBOX_Y + 90, 22, 13, "P+", objpage_increase_pitch );
 399         ui_add_gadget_button( win, OBJCURBOX_X + 00, OBJCURBOX_Y + 90, 22, 13, "B-", objpage_decrease_bank );
 400         ui_add_gadget_button( win, OBJCURBOX_X + 50, OBJCURBOX_Y + 90, 22, 13, "B+", objpage_increase_bank );
 401         ui_add_gadget_button( win, OBJCURBOX_X + 00, OBJCURBOX_Y + 76, 22, 13, "H-", objpage_decrease_heading );
 402         ui_add_gadget_button( win, OBJCURBOX_X + 50, OBJCURBOX_Y + 76, 22, 13, "H+", objpage_increase_heading );
 403         ui_add_gadget_button( win, OBJCURBOX_X + 00, OBJCURBOX_Y + 62, 22, 13, "Z+", objpage_increase_z );
 404         ui_add_gadget_button( win, OBJCURBOX_X + 50, OBJCURBOX_Y + 62, 22, 13, "Z-", objpage_decrease_z );
 405         ui_add_gadget_button( win, OBJCURBOX_X + 25, OBJCURBOX_Y + 76, 22, 13, "R", objpage_reset_orient );
 406
 407         for (i=0;i<OBJS_PER_PAGE;i++)
 408                 ObjBox[i] = ui_add_gadget_userbox( win, OBJBOX_X + (i/2)*(2+OBJBOX_W), OBJBOX_Y + (i%2)*(2+OBJBOX_H), OBJBOX_W, OBJBOX_H);
 409
 410         ObjCurrent = ui_add_gadget_userbox( win, OBJCURBOX_X, OBJCURBOX_Y-5, 64, 64 );
 411
 412         objpage_reset_orient();
 413
 414         for (i=0;  i<OBJS_PER_PAGE; i++ )
 415         {
 416                 gr_set_current_canvas(ObjBox[i]->canvas);
 417                 if (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes)
 418                 {
 419                                 //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 420                                 gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 421                 } else {
 422                         gr_clear_canvas( CGREY );
 423                 }
 424         }
 425
 426 // Don't reset robot_type when we return to editor.
 427 //      Cur_robot_type = ObjectPage*OBJS_PER_PAGE;
 428         gr_set_current_canvas(ObjCurrent->canvas);
 429         //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ Cur_robot_type ] ] );
 430         gr_label_box(Cur_object_id);
 431
 432         //ObjnameCanvas = gr_create_sub_canvas(&grd_curscreen->sc_canvas, OBJCURBOX_X , OBJCURBOX_Y + OBJBOX_H + 10, 100, 20);
 433         //gr_set_current_canvas( ObjnameCanvas );
 434         //gr_set_curfont( ui_small_font );
 435    //gr_set_fontcolor( CBLACK, CWHITE );
 436         //objpage_display_name( Texture[Cur_robot_type]->filename );
 437
 438 }
 439
 440 void objpage_close()
 441 {
 442         //gr_free_sub_canvas(ObjnameCanvas);
 443 }
 444
 445
 446 // DO TEXTURE STUFF
 447
 448 void objpage_do()
 449 {
 450         int i;
 451
 452         for (i=0; i<OBJS_PER_PAGE; i++ )
 453         {
 454                 if (ObjBox[i]->b1_clicked && (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes))
 455                 {
 456                         Cur_object_id = i+ObjectPage*OBJS_PER_PAGE;
 457                         gr_set_current_canvas(ObjCurrent->canvas);
 458                         //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ Cur_robot_type ] ] );
 459                         gr_label_box(Cur_object_id);
 460                         //objpage_display_name( Texture[Cur_robot_type]->filename );
 461                 }
 462         }
 463 }