prj/cam/src/deepc/ui/dpcmenu.cpp

   1 /*
   2 @Copyright Looking Glass Studios, Inc.
   3 1996,1997,1998,1999,2000 Unpublished Work.
   4 */
   5
   6 ////////////////////////////////////////////////////////////
   7 // Deep Cover METAGAME MENUS
   8 //
   9
  10 #include <dpcmenu.h>
  11 #include <appagg.h>
  12 #include <drkpanl.h>
  13 #include <dpcoptmn.h>
  14 #include <dpcsavui.h>
  15 #include <dpcnetui.h>
  16
  17 #include <resapi.h>
  18 #include <imgrstyp.h>
  19 #include <schema.h>
  20
  21 #include <drawelem.h>
  22 #include <gcompose.h>
  23 #include <questapi.h>
  24 #include <drkdiff.h>
  25 #include <config.h>
  26 #include <uigame.h>
  27
  28 #include <panltool.h>
  29 #include <appapi.h>
  30 #include <mprintf.h>
  31 #include <campaign.h>
  32 #include <metasnd.h>
  33
  34 #include <command.h>
  35 #include <uiamov.h>
  36 #include <uianim.h>
  37
  38 #include <netman.h>
  39
  40 #include <dpcmulti.h>
  41 #include <dpcgame.h>
  42 #include <dpcutils.h>
  43 #include <playrobj.h>
  44 #include <dpclding.h>
  45 #include <dpcpgapi.h>
  46
  47
  48 #include <netsynch.h>
  49
  50
  51 //
  52 // Base Menu class
  53 //
  54 // Some day, I expect this will
  55 // deal with levers and other festoonery
  56 //
  57
  58 class cMenuBase: public cDarkPanel, public cUiAnim
  59 {
  60 public:
  61    cMenuBase(const sDarkPanelDesc* desc)
  62       : cDarkPanel(desc), cUiAnim(desc->panel_name,INTERFACE_PATH)
  63    {
  64    };
  65
  66    ~cMenuBase() {};
  67
  68 protected:
  69    void InitUI()
  70    {
  71       cDarkPanel::InitUI();
  72       cUiAnim::InitUI();
  73    }
  74
  75    void TermUI()
  76    {
  77       cUiAnim::TermUI();
  78       cDarkPanel::TermUI();
  79    }
  80
  81    void OnLoopMsg(eLoopMessage msg, tLoopMessageData data)
  82    {
  83       cUiAnim::OnLoopMsg(msg,data);
  84       cDarkPanel::OnLoopMsg(msg,data);
  85    }
  86 };
  87
  88 //------------------------------------------------------------
  89 // MAIN MENU
  90 //
  91
  92 // Avoid name conflicts
  93 class cDPCMainMenu;
  94 typedef cDPCMainMenu cMainMenu;
  95
  96 EXTERN void SwitchToDPCNewGameMode(BOOL push);
  97
  98
  99 class cDPCMainMenu: public cMenuBase
 100 {
 101    static sDarkPanelDesc gDesc;
 102
 103 public:
 104    cMainMenu() : cMenuBase(&gDesc)
 105    {
 106    };
 107
 108    cMainMenu(const sDarkPanelDesc* pdesc) : cMenuBase(pdesc)
 109    {
 110    };
 111
 112
 113    enum eRects
 114    {
 115       kNewGame,
 116       kLoadGame,
 117       kOptions,
 118       kCredits,
 119       kIntro,
 120       kQuit,
 121
 122       kNumRects
 123    };
 124
 125
 126 protected:
 127
 128    void OnButtonList(ushort action, int button)
 129    {
 130       if (!(action & BUTTONGADG_LCLICK))
 131          return ;
 132
 133       //SchemaPlay((Label *)"menubutt",NULL);
 134
 135       switch (button)
 136       {
 137          case kNewGame:
 138             SwitchToDPCNewGameMode(TRUE);
 139             break;
 140
 141          case kLoadGame:
 142             SwitchToDPCLoadGameMode(TRUE);
 143             break;
 144
 145          case kOptions:
 146             SwitchToDPCOptionsMode(TRUE);
 147             break;
 148
 149          case kCredits:
 150             MoviePanel("credits.avi");
 151             break;
 152
 153          case kIntro:
 154             MoviePanel("cs1.avi");
 155             break;
 156
 157          case kQuit:
 158          {
 159             AutoAppIPtr_(Application,pApp);
 160             pApp->Quit();
 161             return;
 162          }
 163          break;
 164
 165       }
 166    }
 167
 168
 169
 170
 171    void OnEscapeKey()  // trap escape
 172    {
 173    }
 174 };
 175
 176 //
 177 // Main Menu descriptor
 178 //
 179
 180 static const char* main_button_names[] =
 181 {
 182    "new_game",
 183    "load_game",
 184    "options",
 185    "credits",
 186    "intro",
 187    "quit",
 188 };
 189
 190 sDarkPanelDesc cMainMenu::gDesc =
 191 {
 192    "main",
 193    cMainMenu::kNumRects,
 194    cMainMenu::kNumRects,
 195    cMainMenu::kNumRects,
 196    main_button_names,
 197    NULL, // font
 198    0,
 199    kMetaSndPanelMain,
 200 };
 201
 202 //------------------------------------------------------------
 203 // NET MAIN MENU
 204 //
 205
 206 class cDPCNetMainMenu: public cDPCMainMenu
 207 {
 208    static sDarkPanelDesc gDesc;
 209    typedef cDPCMainMenu cParent;
 210
 211 public:
 212    cDPCNetMainMenu() : cParent(&gDesc)
 213    {
 214    };
 215
 216    enum eRects
 217    {
 218       kNewGame,
 219       kLoadGame,
 220       kOptions,
 221       kCredits,
 222       kIntro,
 223       kQuit,
 224       kMultiPlayer,
 225
 226       kNumRects
 227    };
 228
 229
 230 protected:
 231
 232    void OnButtonList(ushort action, int button)
 233    {
 234       if (!(action & BUTTONGADG_LCLICK))
 235          return ;
 236
 237       switch (button)
 238       {
 239          case kMultiPlayer:
 240             SwitchToDPCMultiplayUIMode(TRUE);
 241             break;
 242
 243          default:
 244             cParent::OnButtonList(action,button);
 245             break;
 246       }
 247    }
 248
 249
 250    void OnLoopMsg(eLoopMessage msg, tLoopMessageData data)
 251    {
 252       cParent::OnLoopMsg(msg,data);
 253       switch (msg)
 254       {
 255          case kMsgEnterMode:
 256          case kMsgResumeMode:
 257          {
 258             // Disconnect any net session we may be in
 259             AutoAppIPtr(NetManager);
 260             pNetManager->Leave();
 261             // If we had network synch disabled, make sure it's normal
 262             // again:
 263             NetSynchEnable();
 264          }
 265          break;
 266       }
 267    }
 268
 269
 270
 271 };
 272
 273 //
 274 // Main Menu descriptor
 275 //
 276
 277 static const char* netmain_button_names[] =
 278 {
 279    "new_game",
 280    "load_game",
 281    "options",
 282    "credits",
 283    "intro",
 284    "quit",
 285    "multiplayer",
 286 };
 287
 288 sDarkPanelDesc cDPCNetMainMenu::gDesc =
 289 {
 290    "netmain",
 291    cDPCNetMainMenu::kNumRects,
 292    cDPCNetMainMenu::kNumRects,
 293    cDPCNetMainMenu::kNumRects,
 294    netmain_button_names,
 295    NULL, // font
 296    0,
 297    kMetaSndPanelMain,
 298 };
 299
 300
 301
 302
 303 static cMainMenu* gpMainMenu = NULL;
 304
 305 void SwitchToDPCMainMenuMode(BOOL push)
 306 {
 307    if (gpMainMenu)
 308    {
 309       cAutoIPtr<IPanelMode> panel = gpMainMenu->GetPanelMode();
 310       panel->Switch((push) ? kLoopModePush : kLoopModeSwitch);
 311    }
 312 }
 313
 314
 315 const sLoopInstantiator* DescribeDPCMainMenuMode(void)
 316 {
 317    if (gpMainMenu)
 318    {
 319       cAutoIPtr<IPanelMode> panel = gpMainMenu->GetPanelMode();
 320       return panel->Instantiator();
 321    }
 322    return NULL;
 323 }
 324
 325 //------------------------------------------------------------
 326 // SIM MENU
 327 //
 328
 329 // Avoid name conflicts
 330 class cDPCSimMenu;
 331 typedef cDPCSimMenu cSimMenu;
 332
 333 class cDPCSimMenu: public cMenuBase
 334 {
 335    static sDarkPanelDesc gDesc;
 336
 337 public:
 338    cSimMenu() : cMenuBase(&gDesc)
 339    {
 340    };
 341
 342    enum eRects
 343    {
 344       kContinue,
 345       kOptions,
 346       kSaveGame,
 347       kLoadGame,
 348       kQuit,
 349
 350       kNumRects
 351    };
 352
 353 protected:
 354
 355    void OnButtonList(ushort action, int button)
 356    {
 357       if (!(action & BUTTONGADG_LCLICK))
 358          return ;
 359
 360       //SchemaPlay((Label *)"menubutt",NULL);
 361
 362       AutoAppIPtr(NetManager);
 363
 364       switch (button)
 365       {
 366          case kContinue:
 367          {
 368             cAutoIPtr<IPanelMode> mode = GetPanelMode();
 369             mode->Exit();
 370          }
 371          break;
 372
 373
 374          case kOptions:
 375             SwitchToDPCOptionsMode(TRUE);
 376             break;
 377
 378          case kSaveGame:
 379             if (pNetManager->IsNetworkGame())
 380             {
 381                char levelname[64];
 382                DPCGetLevelName(levelname,sizeof(levelname));
 383                // okay this is hack-a-riffic
 384                if ((stricmp(levelname,"station") == 0) || (stricmp(levelname,"earth") == 0))
 385                   break;
 386             }
 387             SwitchToDPCSaveGameMode(TRUE);
 388             break;
 389
 390          case kLoadGame:
 391             SwitchToDPCLoadGameMode(TRUE);
 392             break;
 393
 394          case kQuit:
 395          {
 396             if (gpMainMenu)
 397             {
 398                // Unwind to the main menu
 399                cAutoIPtr<IPanelMode> panel = gpMainMenu->GetPanelMode();
 400                panel->Switch(kLoopModeUnwindTo);
 401             }
 402
 403
 404          }
 405          break;
 406
 407          default:
 408             Warning(("%s button is unimplemented\n",gDesc.string_names[button]));
 409             break;
 410
 411       }
 412    }
 413 };
 414
 415 //
 416 // Sim Menu descriptor
 417 //
 418
 419 static const char* sim_button_names[] =
 420 {
 421    "continue",
 422    "options",
 423    "save_game",
 424    "load_game",
 425    "quit",
 426 };
 427
 428 sDarkPanelDesc cSimMenu::gDesc =
 429 {
 430    "sim",
 431    cSimMenu::kNumRects,
 432    cSimMenu::kNumRects,
 433    cSimMenu::kNumRects,
 434    sim_button_names,
 435 };
 436
 437
 438 static cSimMenu* gpSimMenu = NULL;
 439
 440 void SwitchToDPCSimMenuMode(BOOL push)
 441 {
 442    if (gpSimMenu)
 443    {
 444       cAutoIPtr<IPanelMode> panel = gpSimMenu->GetPanelMode();
 445       panel->Switch((push) ? kLoopModePush : kLoopModeSwitch);
 446    }
 447 }
 448
 449
 450 const sLoopInstantiator* DescribeDPCSimMenuMode(void)
 451 {
 452    if (gpSimMenu)
 453    {
 454       cAutoIPtr<IPanelMode> panel = gpSimMenu->GetPanelMode();
 455       return panel->Instantiator();
 456    }
 457    return NULL;
 458 }
 459
 460
 461 //------------------------------------------------------------
 462 // NewGame MENU
 463 //
 464
 465 #define MIN_DIFF 1
 466 extern int g_diff;
 467 #define DIFF2BUTT(x) (((x) < MIN_DIFF) ? MIN_DIFF - 1 : (x) - 1)
 468 #define BUTT2DIFF(x) ((x) + 1)
 469
 470 class cDPCNewGame: public cDarkPanel
 471 {
 472    static sDarkPanelDesc gDesc;
 473
 474 public:
 475    cDPCNewGame()
 476       : cDarkPanel(&gDesc)
 477    {
 478       memset(&mDiffButtons,0,sizeof(mDiffButtons));
 479    };
 480
 481    enum eRects
 482    {
 483       kStart,
 484       kOptions,
 485       kCancel,
 486       kNumButts,
 487
 488       kDifficulty = kNumButts,
 489       kDiff0,
 490       kDiff1,
 491       kDiff2,
 492       kDiff3,
 493
 494       kNumRects,
 495
 496       kNumDiffs = kNumRects - kDiff0,
 497    };
 498
 499
 500 protected:
 501    guiStyle mDiffStyle;
 502    LGadButtonList mDiffButtons;
 503    DrawElement mDiffElems[kNumDiffs];
 504    cStr mDiffStrs[kNumDiffs];
 505
 506    static bool DiffCB (ushort action, int button, void *data, LGadBox *)
 507    {
 508       g_diff = BUTT2DIFF(button);
 509       return FALSE;
 510    }
 511
 512    void InitUI()
 513    {
 514       cDarkPanel::InitUI();
 515
 516       // default to current style colors
 517       AssertMsg(GetCurrentStyle(),"No current style for diff defaults");
 518       memset(&mDiffStyle,0,sizeof(mDiffStyle));
 519       memcpy(mDiffStyle.colors,GetCurrentStyle()->colors,sizeof(mDiffStyle.colors));
 520       uiGameLoadStyle("diff_",&mDiffStyle,mResPath);
 521
 522       // set up drawlelems for diff
 523       for (int i = 0; i < kNumDiffs; i++)
 524       {
 525          DrawElement& elem = mDiffElems[i];
 526          memset(&elem,0,sizeof(elem));
 527
 528          char buf[16];
 529          sprintf(buf,"diff_%d",i);
 530          mDiffStrs[i] = FetchUIString(panel_name,buf,mResPath);
 531          elem.draw_type = DRAWTYPE_TEXT;
 532          elem.draw_data = (void*)(const char*)mDiffStrs[i];
 533          elem.draw_flags = INTERNAL(DRAWFLAG_INT_TRANSP);
 534       }
 535
 536       LGadButtonListDesc desc =
 537       {
 538          kNumDiffs,
 539          &mRects[(int)kDiff0],
 540          mDiffElems,
 541          DiffCB,
 542          0,
 543          BUTTONLIST_RADIO_FLAG,
 544       };
 545
 546       LGadCreateButtonListDesc(&mDiffButtons,LGadCurrentRoot(),&desc);
 547
 548       //set the current difficulty setting
 549       if (g_diff < MIN_DIFF) g_diff = MIN_DIFF;
 550       LGadRadioButtonSelect (&mDiffButtons, DIFF2BUTT(g_diff));
 551       int flags = LGadBoxFlags(&mDiffButtons);
 552       LGadBoxSetFlags(&mDiffButtons, flags | BOXFLAG_CLEAR);
 553       LGadBoxSetStyle(&mDiffButtons,&mDiffStyle);
 554    }
 555
 556    void TermUI()
 557    {
 558       g_diff = BUTT2DIFF(LGadRadioButtonSelection(&mDiffButtons));
 559       LGadDestroyButtonList(&mDiffButtons);
 560       memset(&mDiffElems,0,sizeof(mDiffElems));
 561       for (int i = 0; i < kNumDiffs; i++)
 562          mDiffStrs[i] = "";
 563
 564       uiGameUnloadStyle(&mDiffStyle);
 565       cDarkPanel::TermUI();
 566    }
 567
 568    void RedrawDisplay()
 569    {
 570
 571       // Draw the difficulty string.  This is a lot of code to draw a lousy string.
 572
 573       cStr str = FetchUIString(panel_name,"difficulty",mResPath);  // copy the string
 574       char* s = (char*)(const char*)str;  // get a mutable pointer
 575
 576       Rect& r = mRects[(int)kDifficulty];
 577
 578       GUIcompose c;
 579       GUIsetup(&c,&r,GUIcomposeFlags(ComposeFlagClear|ComposeFlagRead),GUI_CANV_ANY);
 580
 581       guiStyleSetupFont(&mDiffStyle,StyleFontTitle);
 582       gr_set_fcolor(guiStyleGetColor(&mDiffStyle,StyleColorText));
 583
 584       gr_font_string_wrap(gr_get_font(),s,RectWidth(&r));
 585
 586       short w,h;
 587       gr_string_size(s,&w,&h);
 588
 589       gr_string(s,(RectWidth(&r) - w)/2,(RectHeight(&r) - h)/2);
 590       //      gr_string(s,gr_char_width('X'),(RectHeight(&r) - h)/2);
 591
 592       guiStyleCleanupFont(&mDiffStyle,StyleFontTitle) ;
 593
 594       GUIdone(&c);
 595
 596       //
 597       // Make sure the buttonlist gets drawn
 598       //
 599       region_expose(LGadBoxRegion(&mDiffButtons),LGadBoxRect(&mDiffButtons));
 600
 601    }
 602
 603    // Actually do the work of starting a game
 604
 605    void StartGame()
 606    {
 607
 608       // Push the init game mode, and the initial cutscene
 609       // mode to the mode stack.  That way the cutscene happens first.
 610       SwitchToDPCInitGame(FALSE);
 611       MoviePanel("cs1.avi");
 612
 613    }
 614
 615    BOOL mGo;
 616
 617    void OnButtonList(ushort action, int button)
 618    {
 619       if (!(action & BUTTONGADG_LCLICK))
 620          return ;
 621
 622       //SchemaPlay((Label *)"menubutt",NULL);
 623
 624       switch (button)
 625       {
 626          case kStart:
 627          {
 628             mGo = TRUE;
 629          }
 630          break;
 631
 632          case kOptions:
 633             SwitchToDPCOptionsMode(TRUE);
 634             break;
 635
 636          case kCancel:
 637          {
 638             cAutoIPtr<IPanelMode> mode = GetPanelMode();
 639             mode->Exit();
 640          }
 641          break;
 642       }
 643    }
 644
 645
 646
 647    void OnLoopMsg(eLoopMessage msg, tLoopMessageData data)
 648    {
 649       switch(msg)
 650       {
 651          case kMsgEnterMode:
 652             mGo = FALSE;
 653             break;
 654          case kMsgNormalFrame:
 655             if (mGo) StartGame();
 656             break;
 657       }
 658
 659       cDarkPanel::OnLoopMsg(msg,data);
 660    }
 661
 662
 663 };
 664
 665 //
 666 // NewGame Menu descriptor
 667 //
 668
 669 static const char* newgame_button_names[] =
 670 {
 671    "start",
 672    "options",
 673    "cancel"
 674 };
 675
 676 sDarkPanelDesc cDPCNewGame::gDesc =
 677 {
 678    "newgame",
 679    cDPCNewGame::kNumButts,
 680    cDPCNewGame::kNumRects,
 681    cDPCNewGame::kNumButts,
 682    newgame_button_names,
 683    NULL,
 684    0,
 685    kMetaSndPanelMain,
 686 };
 687
 688
 689 static cDPCNewGame* gpNewGame = NULL;
 690
 691 void SwitchToDPCNewGameMode(BOOL push)
 692 {
 693    if (gpNewGame)
 694    {
 695       cAutoIPtr<IPanelMode> panel = gpNewGame->GetPanelMode();
 696       panel->Switch((push) ? kLoopModePush : kLoopModeSwitch);
 697    }
 698 }
 699
 700
 701 const sLoopInstantiator* DescribeDPCNewGameMode(void)
 702 {
 703    if (gpNewGame)
 704    {
 705       cAutoIPtr<IPanelMode> panel = gpNewGame->GetPanelMode();
 706       return panel->Instantiator();
 707    }
 708    return NULL;
 709 }
 710
 711 //------------------------------------------------------------------
 712 // INIT/TERM
 713 //
 714
 715
 716 void init_commands();
 717
 718
 719 void DPCMenusInit()
 720 {
 721    if (config_is_defined("netplay_ui"))
 722       gpMainMenu = new cDPCNetMainMenu;
 723    else
 724       gpMainMenu = new cMainMenu;
 725    gpSimMenu = new cSimMenu;
 726    gpNewGame = new cDPCNewGame;
 727
 728    init_commands();
 729
 730    // default difficulty
 731    g_diff = MIN_DIFF + 1;
 732
 733    // What the hell.  Initialize the loading screens too
 734    DPCLoadingInit();
 735    DPCMultiplayUIInit();
 736 }
 737
 738 void DPCMenusTerm()
 739 {
 740    delete gpMainMenu;
 741    delete gpSimMenu;
 742    delete gpNewGame;
 743
 744    DPCLoadingTerm();
 745    DPCMultiplayUITerm();
 746 }
 747
 748
 749 //----------------------------------------
 750 // COMMANDS
 751 //
 752
 753 static void do_mainmenu()
 754 {
 755    SwitchToDPCMainMenuMode(TRUE);
 756 }
 757
 758 static void do_simmenu()
 759 {
 760    // don't do anything if the trigger is pulled
 761    AutoAppIPtr(PlayerGun);
 762    ObjID gun = pPlayerGun->Get();
 763    if ((gun != OBJ_NULL) && pPlayerGun->IsTriggerPulled())
 764       return;
 765
 766    // throw any objects on the cursor into the world
 767    if (drag_obj != OBJ_NULL)
 768    {
 769       ThrowObj(drag_obj,PlayerObject());
 770       ClearCursor();
 771    }
 772    SwitchToDPCSimMenuMode(TRUE);
 773 }
 774
 775
 776
 777 static Command commands[] =
 778 {
 779    { "main_menu", FUNC_VOID, do_mainmenu, "Go to main menu.", HK_ALL },
 780    { "sim_menu", FUNC_VOID, do_simmenu, "Go to sim menu.", HK_ALL },
 781
 782 };
 783
 784
 785 static void init_commands()
 786 {
 787    COMMANDS(commands,HK_ALL);
 788 }