1 #include "3dc.h"
2 #include "inline.h"
3 #include "module.h"
4 #include "stratdef.h"
5 #include "gamedef.h"
6 #include "bh_types.h"
7 #include "cheatmodes.h"
8 #include "net.h"
9 #include "opengl.h"
10 #include "pldnet.h"
11
12 #include "avp_menudata.h"
13 #include "avp_menus.h"
14 #include "avp_envinfo.h"
15
16 #include "hud_layout.h"
17 #include "avp_userprofile.h"
18 #include "huffman.hpp"
19
20 #include "hudgfx.h"
21 #include "usr_io.h"
22 #define UseLocalAssert Yes
23 #include "ourasert.h"
24 #include "iofocus.h"
25 #include <time.h>
26 #include "gammacontrol.h"
27 #include "avp_mp_config.h"
28 #include "psnd.h"
29 #include "savegame.h"
30 #include "game.h"
31 #include "avp_menugfx.hpp"
32 #include "avp_intro.h"
33 #include "fmv.h"
34
35 /* used to get file time */
36 #include <sys/types.h>
37 #include <sys/stat.h>
38
39 int SelectDirectDrawObject(void *pGUID);
40
41 extern void StartMenuBackgroundBink(void);
42 extern int PlayMenuBackgroundBink(void);
43 extern void EndMenuBackgroundBink(void);
44
45
46 /* KJL 11:22:37 23/06/98 - Hopefully these will be the final menus! */
47
48 extern int IDemandSelect(void);
49
50 extern char *GetVideoModeDescription(void);
51 extern char *GetVideoModeDescription2(void);
52 extern char *GetVideoModeDescription3(void);
53 extern void PreviousVideoMode(void);
54 extern void PreviousVideoMode2(void);
55 extern void NextVideoMode(void);
56 extern void NextVideoMode2(void);
57 extern void SaveVideoModeSettings(void);
58 extern void LoadDeviceAndVideoModePreferences(void);
59 extern void SaveDeviceAndVideoModePreferences(void);
60
61 extern void MakeSelectSessionMenu(void);
62
63 extern void MakeInGameMenu(void);
64 extern void MakeMarineKeyConfigMenu(void);
65 extern void MakePredatorKeyConfigMenu(void);
66 extern void MakeAlienKeyConfigMenu(void);
67 extern void MakeUserProfileSelectMenu(void);
68
69 extern void SaveKeyConfiguration(void);
70
71
72 extern void D3D_DrawSliderBar(int x, int y, int alpha);
73 extern void D3D_DrawSlider(int x, int y, int alpha);
74 extern void D3D_FadeDownScreen(int brightness, int colour);
75 extern void PlayIntroSequence(void);
76
77 extern void MinimalNetCollectMessages(void);
78
79 extern int DirectPlay_HostGame(char *playerName, char *sessionName,int species,int gamestyle,int level);
80 extern int DirectPlay_JoinGame(void);
81 extern int DirectPlay_ConnectToSession(int sessionNumber, char *playerName);
82 extern int DirectPlay_Disconnect(void);
83
84 extern void ShowSplashScreens(void);
85 extern void Show_WinnerScreen(void);
86
87 extern void GetNextAllowedSpecies(int* species,BOOL search_forwards);
88 static void SetBriefingTextForMultiplayer();
89 int NumberOfAvailableLevels(I_PLAYER_TYPE playerID);
90 int LevelMostLikelyToPlay(I_PLAYER_TYPE playerID);
91 int MaxDifficultyLevelAllowed(I_PLAYER_TYPE playerID, int level);
92
93 int CloudTable[128][128];
94
95 extern char MP_Config_Name[];
96
97 void HandlePostGameFMVs(void);
98 void HandlePreGameFMVs(void);
99 extern void AvP_UpdateMenus(void);
100 static void SetupNewMenu(enum AVPMENU_ID menuID);
101 static void RenderMenu(void);
102 static void RenderBriefingScreenInfo(void);
103 static void RenderEpisodeSelectMenu(void);
104 static void RenderKeyConfigurationMenu(void);
105 static void RenderUserProfileSelectMenu(void);
106 static void RenderLoadGameMenu(void);
107 static void RenderConfigurationDescriptionString();
108 static void ActUponUsersInput(void);
109 static void InteractWithMenuElement(enum AVPMENU_ELEMENT_INTERACTION_ID interactionID);
110 static void RenderMenuElement(AVPMENU_ELEMENT *elementPtr, int e, int y);
111 static int HeightOfMenuElement(AVPMENU_ELEMENT *elementPtr);
112 void DisplayVideoModeUnavailableScreen(void);
113 void CheckForCredits(void);
114 void DoCredits(void);
115 BOOL RollCreditsText(int position, unsigned char *textPtr);
116 extern void SelectMenuDisplayMode(void);
117 static void InitMainMenusBackdrop(void);
118 extern void DrawMainMenusBackdrop(void);
119 static void TestValidityOfCheatMenu(void);
120 void SetBriefingTextForEpisode(int episode, I_PLAYER_TYPE playerID);
121 void SetBriefingTextToBlank(void);
122 void CheckForKeysWithMultipleAssignments(void);
123 void HandleCheatModeFeatures(void);
124 void ShowMenuFrameRate(void);
125 static void KeyboardEntryQueue_Clear(void);
126 static void KeyboardEntryQueue_StartProcessing(void);
127
128 static void PasteFromClipboard(char* Text,int MaxTextLength);
129 /* KJL 11:23:03 23/06/98 - Requirements
130
131 1. 'Floating' over backdrop, possibly using translucency effects
132 2. Quick to write!
133 3. Quick to change
134 4. Certain menus need to be used in-game - e.g. key configuration
135 */
136
137 /* KJL 11:27:18 23/06/98 - Available menus
138
139 1. Main Menu
140
141 Start Singleplayer
142 Start Multiplayer
143 Gameplay Options
144 Audio/Visual Options
145 Exit
146
147 2. Singleplayer
148
149 Alien
150 Marine
151 Predator
152 Exit
153
154 3. Multiplayer
155
156 -> Complex
157
158 4. Gameplay Options
159
160 5. Audio/Visual Options
161
162 */
163
164
165 /* KJL 11:57:21 23/06/98 -
166
167
168 Need mouse position code (?) etc. In-game menus using mouse? Ugh.
169 No mouse then.
170
171 */
172 SAVE_SLOT_HEADER SaveGameSlot[NUMBER_OF_SAVE_SLOTS];
173
174
175 extern int VideoModeNotAvailable;
176
177 extern int RealFrameTime;
178 extern unsigned char KeyboardInput[];
179 extern unsigned char DebouncedKeyboardInput[];
180 extern int DebouncedGotAnyKey;
181 extern SCREENDESCRIPTORBLOCK ScreenDescriptorBlock;
182 extern int TimeScale;
183
184 static AVP_MENUS AvPMenus;
185 extern AVPMENU AvPMenusData[];
186
187 extern int AlienEpisodeToPlay;
188 extern int MarineEpisodeToPlay;
189 extern int PredatorEpisodeToPlay;
190 extern int UserProfileNumber;
191 AVP_USER_PROFILE *UserProfilePtr;
192
193 SESSION_DESC SessionData[MAX_NO_OF_SESSIONS];
194 int NumberOfSessionsFound;
195 extern NETGAME_GAMEDATA netGameData;
196
197 static int InputIsDebounced = 0;
198 static int KeyDepressedCounter = 0;
199 extern int CloakingPhase;
200 static int EpisodeSelectScrollOffset;
201 static int MaximumSelectableLevel;
202 static int KeyConfigSelectionColumn;
203
204 static int Brightness[16];
205
206 static unsigned char MultipleAssignments[2][32];
207
208 static char *GetDescriptionOfKey(unsigned char key);
209 static int OkayToPlayNextEpisode(void);
210 static PLAYER_INPUT_CONFIGURATION PlayerInputPrimaryConfig;
211 static PLAYER_INPUT_CONFIGURATION PlayerInputSecondaryConfig;
212 CONTROL_METHODS PlayerControlMethods;
213 JOYSTICK_CONTROL_METHODS PlayerJoystickControlMethods;
214
215 static void RenderScrollyMenu();
216 static void RenderHelpString();
217 static void CheckForLoadGame();
218
219 static void UpdateMultiplayerConfigurationMenu();
220
221 static char KeyboardEntryQueue_ProcessCharacter(void);
222
223 static BOOL LaunchingMplayer=FALSE;
224
225 static int MultiplayerConfigurationIndex; //just used for the configuration deletion stuff
226 static const char* MultiplayerConfigurationName=0; //ditto
227
228 extern int DebuggingCommandsActive;
229
AvP_MainMenus_Init(void)230 int AvP_MainMenus_Init(void)
231 {
232 #if 0
233 SaveDefaultPrimaryConfigs();
234 #else
235 LoadDefaultPrimaryConfigs();
236 #endif
237
238 SoundSys_ResetFadeLevel();
239 SoundSys_Management();
240
241 TimeScale = ONE_FIXED;
242
243
244
245 if (!LobbiedGame) // Edmond
246 CheckForCredits();
247
248 TimeStampedMessage("start of menus");
249 // open a 640x480x16 screen
250 SelectMenuDisplayMode();
251 TimeStampedMessage("after SelectMenuDisplayMode");
252
253
254
255
256
257 InitialiseMenuGfx();
258 TimeStampedMessage("after InitialiseMenuGfx");
259
260 // inform backdrop code
261 InitMainMenusBackdrop();
262 TimeStampedMessage("after InitMainMenusBackdrop");
263
264
265 #if PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO
266 if (AvP.LevelCompleted)
267 {
268 Show_WinnerScreen();
269 }
270 #endif
271
272 LoadAllAvPMenuGfx();
273 TimeStampedMessage("after LoadAllAvPMenuGfx");
274
275
276
277 ResetFrameCounter();
278
279 if (!LobbiedGame) // Edmond
280 PlayIntroSequence();
281
282 if (VideoModeNotAvailable)
283 {
284 LoadGameRequest = SAVELOAD_REQUEST_NONE;
285 DisplayVideoModeUnavailableScreen();
286 }
287 VideoModeNotAvailable = 0;
288
289 if(AvP.LevelCompleted && CheatMode_Active == CHEATMODE_NONACTIVE && !DebuggingCommandsActive)
290 {
291 HandlePostGameFMVs();
292 OkayToPlayNextEpisode();
293 AvP.LevelCompleted = 0;
294 AvPMenus.MenusState = MENUSSTATE_MAINMENUS;
295 }
296 else if(!LobbiedGame)
297 {
298 if (UserProfileNumber==-1)
299 {
300 SetupNewMenu(AVPMENU_USERPROFILESELECT);
301 }
302 else
303 {
304 SetupNewMenu(AVPMENU_MAIN);
305 }
306 AvPMenus.MenusState = MENUSSTATE_MAINMENUS;
307 }
308 else
309 {
310 SetupNewMenu(AVPMENU_USERPROFILESELECT);
311 //AvPMenus.MenusState = MENUSSTATE_STARTGAME;
312
313 }
314
315 CheatMode_Active = CHEATMODE_NONACTIVE;
316
317
318 TimeStampedMessage("starting general menus");
319
320 return 0;
321 }
322
AvP_MainMenus_Update(void)323 int AvP_MainMenus_Update(void) {
324 CheckForWindowsMessages();
325 DrawMainMenusBackdrop();
326 ReadUserInput();
327 AvP_UpdateMenus();
328 // BezierCurve();
329
330 ShowMenuFrameRate();
331
332 FlipBuffers();
333 FrameCounterHandler();
334 PlayMenuMusic();
335 #if 0
336 {
337 extern int EffectsSoundVolume;
338 SoundSys_ChangeVolume(EffectsSoundVolume);
339 }
340 #endif
341 SoundSys_Management();
342 UpdateGammaSettings();
343
344 CheckForLoadGame();
345
346 return AvPMenus.MenusState == MENUSSTATE_MAINMENUS;
347 }
348
AvP_MainMenus_Deinit(void)349 int AvP_MainMenus_Deinit(void) {
350 if (AvPMenus.MenusState==MENUSSTATE_OUTSIDEMENUS)
351 {
352 //Don't bother showing credits if we are just exiting in order to start a game
353 //using mplayer. The credits will get shown later after the player has actually
354 //played the game
355 if(!LaunchingMplayer)
356 {
357 if (!LobbiedGame) // Edmond
358 DoCredits();
359 }
360 }
361 TimeStampedMessage("ready to exit menus");
362
363 EndMenuMusic();
364 EndMenuBackgroundBink();
365 TimeStampedMessage("after EndMenuMusic");
366
367 #if PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO
368 if ((AvPMenus.MenusState != MENUSSTATE_STARTGAME)) ShowSplashScreens();
369 TimeStampedMessage("after ShowSplashScreens");
370 #endif
371 ReleaseAllAvPMenuGfx();
372
373 TimeStampedMessage("after ReleaseAllAvPMenuGfx");
374
375 SoundSys_StopAll();
376 SoundSys_Management();
377
378 if (CheatMode_Active == CHEATMODE_NONACTIVE) HandlePreGameFMVs();
379
380 HandleCheatModeFeatures();
381 AvP.LevelCompleted = 0;
382
383 return (AvPMenus.MenusState == MENUSSTATE_STARTGAME);
384 }
385
AvP_MainMenus(void)386 int AvP_MainMenus(void)
387 {
388 #if 0
389 SaveDefaultPrimaryConfigs();
390 #else
391 LoadDefaultPrimaryConfigs();
392 #endif
393
394 SoundSys_ResetFadeLevel();
395 SoundSys_Management();
396
397 TimeScale = ONE_FIXED;
398
399
400
401 if (!LobbiedGame) // Edmond
402 CheckForCredits();
403
404 TimeStampedMessage("start of menus");
405 // open a 640x480x16 screen
406 SelectMenuDisplayMode();
407 TimeStampedMessage("after SelectMenuDisplayMode");
408
409
410
411
412
413 InitialiseMenuGfx();
414 TimeStampedMessage("after InitialiseMenuGfx");
415
416 // inform backdrop code
417 InitMainMenusBackdrop();
418 TimeStampedMessage("after InitMainMenusBackdrop");
419
420
421 #if PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO
422 if (AvP.LevelCompleted)
423 {
424 Show_WinnerScreen();
425 }
426 #endif
427
428 LoadAllAvPMenuGfx();
429 TimeStampedMessage("after LoadAllAvPMenuGfx");
430
431
432
433 ResetFrameCounter();
434
435 if (!LobbiedGame) // Edmond
436 PlayIntroSequence();
437
438 if (VideoModeNotAvailable)
439 {
440 LoadGameRequest = SAVELOAD_REQUEST_NONE;
441 DisplayVideoModeUnavailableScreen();
442 }
443 VideoModeNotAvailable = 0;
444
445 if(AvP.LevelCompleted && CheatMode_Active == CHEATMODE_NONACTIVE && !DebuggingCommandsActive)
446 {
447 HandlePostGameFMVs();
448 OkayToPlayNextEpisode();
449 AvP.LevelCompleted = 0;
450 AvPMenus.MenusState = MENUSSTATE_MAINMENUS;
451 }
452 else if(!LobbiedGame)
453 {
454 if (UserProfileNumber==-1)
455 {
456 SetupNewMenu(AVPMENU_USERPROFILESELECT);
457 }
458 else
459 {
460 SetupNewMenu(AVPMENU_MAIN);
461 }
462 AvPMenus.MenusState = MENUSSTATE_MAINMENUS;
463 }
464 else
465 {
466 SetupNewMenu(AVPMENU_USERPROFILESELECT);
467 //AvPMenus.MenusState = MENUSSTATE_STARTGAME;
468
469 }
470
471 CheatMode_Active = CHEATMODE_NONACTIVE;
472
473
474 TimeStampedMessage("starting general menus");
475
476 while(AvPMenus.MenusState == MENUSSTATE_MAINMENUS)
477 {
478 CheckForWindowsMessages();
479 DrawMainMenusBackdrop();
480 ReadUserInput();
481 AvP_UpdateMenus();
482 // BezierCurve();
483
484 ShowMenuFrameRate();
485
486 FlipBuffers();
487 FrameCounterHandler();
488 PlayMenuMusic();
489 #if 0
490 {
491 extern int EffectsSoundVolume;
492 SoundSys_ChangeVolume(EffectsSoundVolume);
493 }
494 #endif
495 SoundSys_Management();
496 UpdateGammaSettings();
497
498 CheckForLoadGame();
499 }
500
501 if (AvPMenus.MenusState==MENUSSTATE_OUTSIDEMENUS)
502 {
503 //Don't bother showing credits if we are just exiting in order to start a game
504 //using mplayer. The credits will get shown later after the player has actually
505 //played the game
506 if(!LaunchingMplayer)
507 {
508 if (!LobbiedGame) // Edmond
509 DoCredits();
510 }
511 }
512 TimeStampedMessage("ready to exit menus");
513
514 EndMenuMusic();
515 EndMenuBackgroundBink();
516 TimeStampedMessage("after EndMenuMusic");
517
518 #if PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO
519 if ((AvPMenus.MenusState != MENUSSTATE_STARTGAME)) ShowSplashScreens();
520 TimeStampedMessage("after ShowSplashScreens");
521 #endif
522 ReleaseAllAvPMenuGfx();
523
524 TimeStampedMessage("after ReleaseAllAvPMenuGfx");
525
526 SoundSys_StopAll();
527 SoundSys_Management();
528
529 if (CheatMode_Active == CHEATMODE_NONACTIVE) HandlePreGameFMVs();
530
531 HandleCheatModeFeatures();
532 AvP.LevelCompleted = 0;
533
534 return (AvPMenus.MenusState == MENUSSTATE_STARTGAME);
535 }
HandlePostGameFMVs(void)536 void HandlePostGameFMVs(void)
537 {
538 switch(AvP.PlayerType)
539 {
540 case I_Marine:
541 {
542 if (MarineEpisodeToPlay==MAX_NO_OF_BASIC_MARINE_EPISODES-1)
543 {
544 ClearScreenToBlack();
545 FlipBuffers();
546 ClearScreenToBlack();
547 PlayBinkedFMV("FMVs/marineoutro.bik");
548 }
549 break;
550 }
551 case I_Alien:
552 {
553 if (AlienEpisodeToPlay==MAX_NO_OF_BASIC_ALIEN_EPISODES-1)
554 {
555 ClearScreenToBlack();
556 FlipBuffers();
557 ClearScreenToBlack();
558 PlayBinkedFMV("FMVs/alienoutro.bik");
559 }
560 break;
561 }
562 case I_Predator:
563 {
564 if (PredatorEpisodeToPlay==MAX_NO_OF_BASIC_PREDATOR_EPISODES-1)
565 {
566 ClearScreenToBlack();
567 FlipBuffers();
568 ClearScreenToBlack();
569 PlayBinkedFMV("FMVs/predatoroutro.bik");
570 }
571 break;
572 }
573 }
574 }
HandlePreGameFMVs(void)575 void HandlePreGameFMVs(void)
576 {
577 if (AvPMenus.MenusState == MENUSSTATE_STARTGAME && LoadGameRequest == SAVELOAD_REQUEST_NONE)
578 {
579 extern char LevelName[];
580 if (!stricmp("derelict", LevelName))
581 {
582 ClearScreenToBlack();
583 FlipBuffers();
584 ClearScreenToBlack();
585 PlayBinkedFMV("FMVs/marineintro.bik");
586 }
587 else if (!stricmp("temple", LevelName))
588 {
589 ClearScreenToBlack();
590 FlipBuffers();
591 ClearScreenToBlack();
592 PlayBinkedFMV("FMVs/alienintro.bik");
593 }
594 else if (!stricmp("fall", LevelName))
595 {
596 ClearScreenToBlack();
597 FlipBuffers();
598 ClearScreenToBlack();
599 PlayBinkedFMV("FMVs/predatorintro.bik");
600 }
601 }
602 }
603
QuickSplashScreens(void)604 extern void QuickSplashScreens(void)
605 {
606 SelectMenuDisplayMode();
607 if (AvP.LevelCompleted)
608 {
609 Show_WinnerScreen();
610 }
611 ShowSplashScreens();
612 }
613
AvP_TriggerInGameMenus(void)614 extern void AvP_TriggerInGameMenus(void)
615 {
616 AvPMenus.MenusState = MENUSSTATE_INGAMEMENUS;
617 SetupNewMenu(AVPMENU_INGAME);
618
619 /* KJL 16:32:55 21/07/98 - tell the console to go away */
620 if (IOFOCUS_AcceptTyping()) IOFOCUS_Toggle();
621 // SoundSys_PauseOn();
622 }
623
AvP_InGameMenus(void)624 int AvP_InGameMenus(void)
625 {
626 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
627 {
628 D3D_FadeDownScreen(ONE_FIXED/8,0);
629 AvP_UpdateMenus();
630 UpdateGammaSettings();
631
632 return 1;
633 }
634 else return 0;
635 }
636
InGameMenusAreRunning(void)637 int InGameMenusAreRunning(void)
638 {
639 return (AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS);
640 }
AvP_UpdateMenus(void)641 extern void AvP_UpdateMenus(void)
642 {
643 // DrawAvPMenuGfx(AVPMENUGFX_BIG_AVP_LOGO,50,50,16384);
644 // DrawAvPMenuGfx(AVPMENUGFX_ALIENS_LOGO,10,75,16384,AVPMENUFORMAT_LEFTJUSTIFIED);
645 // DrawAvPMenuGfx(AVPMENUGFX_PREDATOR_LOGO,380,77,16384,AVPMENUFORMAT_LEFTJUSTIFIED);
646 // RenderMenuText("VS",330,95,16384,AVPMENUFORMAT_CENTREJUSTIFIED);
647
648 #if 0
649 if (AvPMenus.CurrentMenu == AVPMENU_MULTIPLAYERJOINGAME2)
650 {
651 MinimalNetCollectMessages();
652 /* KJL 19:49:04 05/07/98 - ugh, there goes the interface */
653 {
654 extern int MP_GameStyle;
655 extern int MP_LevelNumber;
656 extern int MP_Species;
657 MP_GameStyle = netGameData.gameType;
658 MP_LevelNumber = netGameData.levelNumber;
659 switch (MP_Species)
660 {
661 default:
662 case 0:
663 netGameData.myCharacterType = NGCT_Marine;
664 netGameData.myNextCharacterType = NGCT_Marine;
665 AvP.PlayerType = I_Marine;
666 break;
667 case 1:
668 netGameData.myCharacterType = NGCT_Predator;
669 netGameData.myNextCharacterType = NGCT_Predator;
670 AvP.PlayerType = I_Predator;
671 break;
672 case 2:
673 netGameData.myCharacterType = NGCT_Alien;
674 netGameData.myNextCharacterType = NGCT_Alien;
675 AvP.PlayerType = I_Alien;
676 break;
677 }
678 }
679 AddNetMsg_PlayerDescription();
680
681 NetSendMessages();
682 }
683 #endif
684
685 if (AvPMenus.CurrentMenu == AVPMENU_MULTIPLAYER_SPECIES_JOIN ||
686 AvPMenus.CurrentMenu == AVPMENU_MULTIPLAYER_CONFIG_JOIN)
687 {
688 MinimalNetCollectMessages();
689 if(AvP.Network==I_Host)
690 { /*
691 We have become host while in the process of joining.
692 This is bad.
693 Best leave the game and return to the main menus.
694 */
695 DirectPlay_Disconnect();
696 SetupNewMenu(AVPMENU_MAIN);
697 return;
698 }
699
700 if (AvPMenus.CurrentMenu == AVPMENU_MULTIPLAYER_SPECIES_JOIN)
701 {
702 /* KJL 19:49:04 05/07/98 - ugh, there goes the interface */
703 {
704 // extern int MP_GameStyle;
705 // extern int MP_LevelNumber;
706 extern int MP_Species;
707 // MP_GameStyle = netGameData.gameType;
708 // MP_LevelNumber = netGameData.levelNumber;
709
710 GetNextAllowedSpecies(&MP_Species,TRUE);
711 netGameData.myCharacterSubType=NGSCT_General;
712 switch (MP_Species)
713 {
714 default:
715 case 0:
716 netGameData.myCharacterType = NGCT_Marine;
717 netGameData.myNextCharacterType = NGCT_Marine;
718 AvP.PlayerType = I_Marine;
719 break;
720 case 1:
721 netGameData.myCharacterType = NGCT_Predator;
722 netGameData.myNextCharacterType = NGCT_Predator;
723 AvP.PlayerType = I_Predator;
724 break;
725 case 2:
726 netGameData.myCharacterType = NGCT_Alien;
727 netGameData.myNextCharacterType = NGCT_Alien;
728 AvP.PlayerType = I_Alien;
729 break;
730
731 case 3: //various marine subtypes
732 case 4:
733 case 5:
734 case 6:
735 case 7:
736 case 8:
737 case 9:
738 case 10:
739 netGameData.myCharacterType = NGCT_Marine;
740 netGameData.myNextCharacterType = NGCT_Marine;
741 AvP.PlayerType = I_Marine;
742 netGameData.myCharacterSubType =(NETGAME_SPECIALISTCHARACTERTYPE) (MP_Species-2);
743 break;
744 }
745 }
746 AddNetMsg_PlayerDescription();
747
748 NetSendMessages();
749 }
750 }
751 else if (AvPMenus.CurrentMenu == AVPMENU_MULTIPLAYER_SPECIES_HOST)
752 {
753 extern int MP_Species;
754 GetNextAllowedSpecies(&MP_Species,TRUE);
755 }
756 else if (AvPMenus.CurrentMenu == AVPMENU_MULTIPLAYER_JOINING)
757 {
758 //check status of joining game
759 int retval=0;
760 if(LobbiedGame)
761 {
762 extern char MP_PlayerName[];
763 retval=DirectPlay_ConnectingToLobbiedGame(MP_PlayerName);
764 if(!retval)
765 {
766 //player has aborted , go back a menu
767 SetupNewMenu(AVPMENU_MULTIPLAYER_LOBBIEDCLIENT);
768 return ;
769 }
770 }
771 else
772 {
773 retval=DirectPlay_ConnectingToSession();
774 if(!retval)
775 {
776 //player has aborted , go back a menu
777 SetupNewMenu(AVPMENU_MULTIPLAYER);
778 return ;
779 }
780 }
781
782 if(retval==AVPMENU_MULTIPLAYER_CONFIG_JOIN)
783 {
784 //successfully joined
785 SetupNewMenu(AVPMENU_MULTIPLAYER_CONFIG_JOIN);
786 }
787 }
788 else if (AvPMenus.CurrentMenu == AVPMENU_MULTIPLAYERSELECTSESSION)
789 {
790 extern BOOL DirectPlay_UpdateSessionList(int * SelectedItem);
791 int selection=AvPMenus.CurrentlySelectedElement;
792
793 if(DirectPlay_UpdateSessionList(&selection))
794 {
795 //session list has changed , so we need to set the menu again
796 SetupNewMenu(AVPMENU_MULTIPLAYERSELECTSESSION);
797 //adjust the selected menu item
798 AvPMenus.CurrentlySelectedElement=selection;
799 }
800 }
801
802
803
804 /* render menu; episode select goes through a separate system */
805 switch (AvPMenus.CurrentMenu)
806 {
807 case AVPMENU_LOADGAME:
808 case AVPMENU_SAVEGAME:
809 {
810 RenderLoadGameMenu();
811 RenderHelpString();
812 break;
813 }
814
815 case AVPMENU_MARINELEVELS:
816 case AVPMENU_PREDATORLEVELS:
817 case AVPMENU_ALIENLEVELS:
818 {
819 RenderEpisodeSelectMenu();
820 break;
821 }
822 case AVPMENU_USERPROFILESELECT:
823 {
824 RenderUserProfileSelectMenu();
825 RenderHelpString();
826 break;
827 }
828 case AVPMENU_USERPROFILEDELETE:
829 {
830 int i;
831 AVP_USER_PROFILE *profilePtr = GetFirstUserProfile();
832 time_t FileTime = profilePtr->FileTime;
833 for (i=0; i<UserProfileNumber; i++)
834 profilePtr = GetNextUserProfile();
835
836 RenderMenuText(profilePtr->Name,MENU_CENTREX,MENU_CENTREY-100,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
837 RenderSmallMenuText(ctime(&FileTime),MENU_CENTREX,MENU_CENTREY-70,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
838
839 RenderMenu();
840 RenderHelpString();
841 break;
842
843 }
844 case AVPMENU_MULTIPLAYER_DELETECONFIG :
845 {
846 //show the name of the configuration we're trying to delete
847 RenderMenuText(MultiplayerConfigurationName,MENU_CENTREX,MENU_CENTREY-100,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
848
849 RenderMenu();
850 RenderHelpString();
851 break;
852 }
853
854 case AVPMENU_ALIENKEYCONFIG:
855 case AVPMENU_MARINEKEYCONFIG:
856 case AVPMENU_PREDATORKEYCONFIG:
857 {
858 CheckForKeysWithMultipleAssignments();
859 RenderKeyConfigurationMenu();
860
861 if (AvPMenus.MenusState == MENUSSTATE_MAINMENUS)
862 {
863 RenderHelpString();
864 }
865
866 break;
867 }
868 case AVPMENU_SKIRMISH_CONFIG :
869 case AVPMENU_MULTIPLAYER_CONFIG :
870 case AVPMENU_MULTIPLAYER_CONFIG_JOIN :
871 {
872 UpdateMultiplayerConfigurationMenu();
873 RenderScrollyMenu();
874 RenderHelpString();
875 break;
876 }
877 case AVPMENU_MULTIPLAYEROPENADDRESS :
878 {
879 RenderMenu();
880 RenderHelpString();
881 break;
882 }
883
884 case AVPMENU_MULTIPLAYER_LOADIPADDRESS :
885 {
886 RenderScrollyMenu();
887 break;
888 }
889
890 case AVPMENU_MULTIPLAYER_LOADCONFIG :
891 {
892 RenderScrollyMenu();
893 RenderConfigurationDescriptionString();
894 RenderHelpString();
895 break;
896 }
897 case AVPMENU_INGAMEAVOPTIONS:
898 {
899 int scale = DIV_FIXED(ScreenDescriptorBlock.SDB_Height,480);
900 int h = scale/2048;
901 int offset = scale/4096;
902 D3D_DrawColourBar(offset, offset+h, ONE_FIXED, 0, 0);
903 D3D_DrawColourBar(offset*2+h, offset*2+h*2, 0, ONE_FIXED, 0);
904 D3D_DrawColourBar(ScreenDescriptorBlock.SDB_Height-offset*2-h*2, ScreenDescriptorBlock.SDB_Height-offset*2-h, 0, 0, ONE_FIXED);
905 D3D_DrawColourBar(ScreenDescriptorBlock.SDB_Height-offset-h, ScreenDescriptorBlock.SDB_Height-offset, ONE_FIXED, ONE_FIXED, ONE_FIXED);
906 RenderMenu();
907 break;
908 }
909
910 case AVPMENU_CHEATOPTIONS:
911 {
912 TestValidityOfCheatMenu();
913 RenderMenu();
914 RenderHelpString();
915 break;
916 }
917 default:
918 {
919 RenderMenu();
920 RenderHelpString();
921 break;
922 }
923 }
924 ActUponUsersInput();
925
926 }
927
SetupNewMenu(enum AVPMENU_ID menuID)928 static void SetupNewMenu(enum AVPMENU_ID menuID)
929 {
930 enum AVPMENU_ID previousMenuID = AvPMenus.CurrentMenu;
931 AvPMenus.CurrentMenu = menuID;
932
933 /* set pointer to the start of the menu's element data */
934 AvPMenus.MenuElements = AvPMenusData[menuID].MenuElements; // could use default
935
936 AvPMenus.FontToUse = AvPMenusData[menuID].FontToUse;
937 AvPMenus.CurrentlySelectedElement = 0;
938 AvPMenus.UserEnteringText = 0;
939 AvPMenus.UserEnteringNumber = 0;
940 AvPMenus.UserChangingKeyConfig = 0;
941 AvPMenus.PositionInTextField = 0;
942 AvPMenus.WidthLeftForText = 0;
943
944
945 /* menu specific stuff */
946 switch (menuID)
947 {
948 case AVPMENU_MAIN:
949 {
950 GetSettingsFromUserProfile();
951 SaveUserProfile(UserProfilePtr);
952
953 if (DebuggingCommandsActive)
954 {
955 if (AnyCheatModesAllowed())
956 {
957 // turn on cheats
958 SetupNewMenu(AVPMENU_DEBUG_MAIN_WITHCHEATS);
959 }
960 else
961 {
962 SetupNewMenu(AVPMENU_DEBUG_MAIN);
963 }
964 }
965 else
966 {
967 if (AnyCheatModesAllowed())
968 {
969 // turn on cheats
970 SetupNewMenu(AVPMENU_MAIN_WITHCHEATS);
971 }
972 }
973 break;
974 }
975
976 case AVPMENU_VIDEOMODE:
977 {
978 LoadDeviceAndVideoModePreferences();
979 break;
980 }
981
982 case AVPMENU_USERPROFILESELECT:
983 {
984 InitialiseGammaSettings(128);
985 EpisodeSelectScrollOffset=0;
986 ExamineSavedUserProfiles();
987 MakeUserProfileSelectMenu();
988 break;
989 }
990 case AVPMENU_USERPROFILEENTERNAME:
991 {
992 AvPMenus.UserEnteringText = 1;
993 KeyboardEntryQueue_Clear();
994 AvPMenus.MenuElements->c.TextPtr = UserProfilePtr->Name;
995 UserProfilePtr->Name[0] = 0;
996 AvPMenus.WidthLeftForText = 0; //will be calculated properly when menus are drawn
997 break;
998 }
999 case AVPMENU_MULTIPLAYER_SAVECONFIG:
1000 {
1001 AvPMenus.UserEnteringText = 1;
1002 KeyboardEntryQueue_Clear();
1003 AvPMenus.WidthLeftForText = 0; //will be calculated properly when menus are drawn
1004 break;
1005 }
1006
1007 case AVPMENU_SINGLEPLAYER:
1008 {
1009 break;
1010 }
1011
1012 case AVPMENU_MARINELEVELS:
1013 {
1014 MarineEpisodeToPlay=0;
1015 EpisodeSelectScrollOffset=0;
1016 AvPMenus.MenuElements->b.MaxSliderValue = NumberOfAvailableLevels(I_Marine);
1017 *AvPMenus.MenuElements->c.SliderValuePtr = LevelMostLikelyToPlay(I_Marine);
1018 break;
1019 }
1020 case AVPMENU_PREDATORLEVELS:
1021 {
1022 PredatorEpisodeToPlay=0;
1023 EpisodeSelectScrollOffset=0;
1024 AvPMenus.MenuElements->b.MaxSliderValue = NumberOfAvailableLevels(I_Predator);
1025 *AvPMenus.MenuElements->c.SliderValuePtr = LevelMostLikelyToPlay(I_Predator);
1026 break;
1027 }
1028 case AVPMENU_ALIENLEVELS:
1029 {
1030 AlienEpisodeToPlay=0;
1031 EpisodeSelectScrollOffset=0;
1032 AvPMenus.MenuElements->b.MaxSliderValue = NumberOfAvailableLevels(I_Alien);
1033 *AvPMenus.MenuElements->c.SliderValuePtr = LevelMostLikelyToPlay(I_Alien);
1034 break;
1035 }
1036 case AVPMENU_MULTIPLAYERSELECTSESSION:
1037 {
1038 if(previousMenuID!=AVPMENU_MULTIPLAYERSELECTSESSION)
1039 {
1040 //save ip address (if it has been set)
1041 extern char IPAddressString[];
1042 SaveIPAddress(IP_Address_Name,IPAddressString);
1043 DirectPlay_JoinGame();
1044 }
1045 MakeSelectSessionMenu();
1046 break;
1047 }
1048
1049 case AVPMENU_MULTIPLAYER_SKIRMISH :
1050 {
1051 extern char MP_Config_Description[];
1052 netGameData.skirmishMode=TRUE;
1053 LoadMultiplayerConfiguration(GetTextString(TEXTSTRING_PREVIOUSGAME_FILENAME));
1054 MP_Config_Description[0]=0;
1055 break;
1056 }
1057
1058 case AVPMENU_MULTIPLAYER_CONNECTION:
1059 {
1060 extern char MP_Config_Description[];
1061 //skirmishMode must be false
1062 netGameData.skirmishMode=FALSE;
1063
1064 LoadMultiplayerConfiguration(GetTextString(TEXTSTRING_PREVIOUSGAME_FILENAME));
1065 MP_Config_Description[0]=0;
1066
1067
1068 if(LobbiedGame)
1069 {
1070 //use alternative multiplayer menus for lobbied games
1071 if(LobbiedGame==LobbiedGame_Server)
1072 {
1073 SetupNewMenu(AVPMENU_MULTIPLAYER_LOBBIEDSERVER);
1074 }
1075 else
1076 {
1077 SetupNewMenu(AVPMENU_MULTIPLAYER_LOBBIEDCLIENT);
1078 }
1079 return;
1080 }
1081
1082 DirectPlay_EnumConnections();
1083 MakeConnectionSelectMenu();
1084 break;
1085 }
1086
1087 case AVPMENU_INGAME:
1088 case AVPMENU_INNETGAME:
1089 {
1090 if(AvP.Network != I_No_Network)
1091 {
1092 //in a multiplayer game set up a menu without the restart mission option
1093 menuID=AVPMENU_INNETGAME;
1094 AvPMenus.CurrentMenu = menuID;
1095 AvPMenus.MenuElements = AvPMenusData[menuID].MenuElements; // could use default
1096 AvPMenus.FontToUse = AvPMenusData[menuID].FontToUse;
1097 }
1098 MakeInGameMenu();
1099 break;
1100 }
1101 case AVPMENU_MARINEKEYCONFIG:
1102 {
1103 MakeMarineKeyConfigMenu();
1104 PlayerInputPrimaryConfig = MarineInputPrimaryConfig;
1105 PlayerInputSecondaryConfig = MarineInputSecondaryConfig;
1106 EpisodeSelectScrollOffset=0;
1107 KeyConfigSelectionColumn = 0;
1108 break;
1109 }
1110 case AVPMENU_PREDATORKEYCONFIG:
1111 {
1112 MakePredatorKeyConfigMenu();
1113 PlayerInputPrimaryConfig = PredatorInputPrimaryConfig;
1114 PlayerInputSecondaryConfig = PredatorInputSecondaryConfig;
1115 EpisodeSelectScrollOffset=0;
1116 KeyConfigSelectionColumn = 0;
1117 break;
1118 }
1119 case AVPMENU_ALIENKEYCONFIG:
1120 {
1121 MakeAlienKeyConfigMenu();
1122 PlayerInputPrimaryConfig = AlienInputPrimaryConfig;
1123 PlayerInputSecondaryConfig = AlienInputSecondaryConfig;
1124 EpisodeSelectScrollOffset=0;
1125 KeyConfigSelectionColumn = 0;
1126 break;
1127 }
1128 case AVPMENU_CONTROLS:
1129 {
1130 PlayerControlMethods = ControlMethods;
1131 break;
1132 }
1133 case AVPMENU_JOYSTICKCONTROLS:
1134 {
1135 PlayerJoystickControlMethods = JoystickControlMethods;
1136 break;
1137 }
1138
1139 case AVPMENU_MULTIPLAYERJOINGAME:
1140 {
1141 extern char IPAddressString[];
1142 extern char CommandLineIPAddressString[];
1143 strcpy(IPAddressString,CommandLineIPAddressString);
1144 IP_Address_Name[0] = 0;
1145
1146 if(netGameData.connectionType!=CONN_TCPIP)
1147 {
1148 ////for non tcpip games skip to the select session menu
1149 SetupNewMenu(AVPMENU_MULTIPLAYERSELECTSESSION);
1150 return;
1151
1152 }
1153
1154
1155 break;
1156 }
1157
1158 case AVPMENU_MULTIPLAYER :
1159 {
1160 break;
1161 }
1162
1163 case AVPMENU_MULTIPLAYER_LOADCONFIG :
1164 {
1165 extern AVPMENU_ELEMENT* AvPMenu_Multiplayer_LoadConfig;
1166 if(!BuildLoadMPConfigMenu())
1167 {
1168 SetupNewMenu(AVPMENU_MULTIPLAYER_CONFIG);
1169 return;
1170 }
1171 AvPMenus.MenuElements=AvPMenu_Multiplayer_LoadConfig;
1172 break;
1173 }
1174
1175 case AVPMENU_MULTIPLAYER_CONFIG :
1176 {
1177 //need to set the menu we return to , according to whether this is
1178 //a lobbied game or not.
1179 if(LobbiedGame)
1180 {
1181 AvPMenusData[AvPMenus.CurrentMenu].ParentMenu=AVPMENU_MULTIPLAYER_LOBBIEDSERVER;
1182 }
1183 else if(netGameData.skirmishMode)
1184 {
1185 //for skirmish games , use skirmish config menu instead
1186 SetupNewMenu(AVPMENU_SKIRMISH_CONFIG);
1187 return;
1188 }
1189 else
1190 {
1191 AvPMenusData[AvPMenus.CurrentMenu].ParentMenu=AVPMENU_MULTIPLAYER;
1192 }
1193 break;
1194 }
1195
1196 case AVPMENU_MULTIPLAYER_CONFIG_JOIN :
1197 {
1198 //need to set the menu we return to , according to whether this is
1199 //a lobbied game or not.
1200 if(LobbiedGame)
1201 {
1202 AvPMenusData[AvPMenus.CurrentMenu].ParentMenu=AVPMENU_MULTIPLAYER_LOBBIEDCLIENT;
1203 }
1204 else
1205 {
1206 AvPMenusData[AvPMenus.CurrentMenu].ParentMenu=AVPMENU_MULTIPLAYER;
1207 }
1208 break;
1209 }
1210
1211 case AVPMENU_MULTIPLAYER_LOADIPADDRESS :
1212 {
1213 extern AVPMENU_ELEMENT* AvPMenu_Multiplayer_LoadIPAddress;
1214 AvPMenus.MenuElements=AvPMenu_Multiplayer_LoadIPAddress;
1215 break;
1216 }
1217
1218 case AVPMENU_MULTIPLAYEROPENADDRESS :
1219 {
1220 extern void MakeOpenIPAddressMenu();
1221 MakeOpenIPAddressMenu();
1222 break;
1223 }
1224
1225 case AVPMENU_SAVEGAME:
1226 case AVPMENU_LOADGAME:
1227 {
1228 ScanSaveSlots();
1229 break;
1230 }
1231
1232 default:
1233 break;
1234 }
1235
1236 /* count the number of elements in the menu */
1237 {
1238 AVPMENU_ELEMENT *elementPtr = AvPMenus.MenuElements;
1239 AvPMenus.NumberOfElementsInMenu=0;
1240 AvPMenus.MenuHeight=0;
1241 do
1242 {
1243 elementPtr->Brightness = BRIGHTNESS_OF_DARKENED_ELEMENT;
1244
1245 AvPMenus.MenuHeight += HeightOfMenuElement(elementPtr);
1246
1247 AvPMenus.NumberOfElementsInMenu++;
1248 elementPtr++;
1249 }
1250 while(elementPtr->ElementID != AVPMENU_ELEMENT_ENDOFMENU);
1251 }
1252
1253 switch(menuID)
1254 {
1255 case AVPMENU_CHEATOPTIONS:
1256 {
1257 CheatMode_Active = 0;
1258 break;
1259 }
1260
1261 case AVPMENU_MARINEKEYCONFIG:
1262 case AVPMENU_ALIENKEYCONFIG:
1263 case AVPMENU_PREDATORKEYCONFIG:
1264 AvPMenus.MenuHeight += 50;
1265 break;
1266 case AVPMENU_LEVELBRIEFING_BASIC:
1267 {
1268 int episodeToPlay;
1269 switch (AvP.PlayerType)
1270 {
1271 case I_Marine:
1272 {
1273 episodeToPlay = MarineEpisodeToPlay;
1274 break;
1275 }
1276 case I_Predator:
1277 {
1278 episodeToPlay = PredatorEpisodeToPlay;
1279 break;
1280 }
1281 case I_Alien:
1282 {
1283 episodeToPlay = AlienEpisodeToPlay;
1284 break;
1285 }
1286 }
1287
1288 /* find available difficulty levels */
1289 AvPMenus.NumberOfElementsInMenu=MaxDifficultyLevelAllowed(AvP.PlayerType, episodeToPlay);
1290 /* highlight a suitable level of difficulty */
1291 if (episodeToPlay)
1292 {
1293 AvPMenus.CurrentlySelectedElement = AvPMenus.NumberOfElementsInMenu-1;
1294 }
1295 else // default to medium difficulty for first level
1296 {
1297 AvPMenus.CurrentlySelectedElement = 1;
1298 }
1299
1300 SetBriefingTextForEpisode(episodeToPlay, AvP.PlayerType);
1301
1302 break;
1303 }
1304 case AVPMENU_LEVELBRIEFING_BONUS:
1305 {
1306 int episodeToPlay;
1307 switch (AvP.PlayerType)
1308 {
1309 case I_Marine:
1310 {
1311 episodeToPlay = MarineEpisodeToPlay;
1312 break;
1313 }
1314 case I_Predator:
1315 {
1316 episodeToPlay = PredatorEpisodeToPlay;
1317 break;
1318 }
1319 case I_Alien:
1320 {
1321 episodeToPlay = AlienEpisodeToPlay;
1322 break;
1323 }
1324 }
1325
1326 SetBriefingTextForEpisode(episodeToPlay, AvP.PlayerType);
1327 break;
1328 }
1329 default:
1330 SetBriefingTextToBlank();
1331 break;
1332 }
1333 }
1334
1335
RenderMenu(void)1336 static void RenderMenu(void)
1337 {
1338 AVPMENU_ELEMENT *elementPtr = AvPMenus.MenuElements;
1339 int e;
1340 int y;
1341
1342
1343 if (AvPMenus.MenusState == MENUSSTATE_MAINMENUS)
1344 {
1345 if ((AvPMenus.CurrentMenu == AVPMENU_LEVELBRIEFING_BASIC)
1346 ||(AvPMenus.CurrentMenu == AVPMENU_LEVELBRIEFING_BONUS))
1347 {
1348 y = MENU_BOTTOMYEDGE - AvPMenus.MenuHeight;
1349 RenderBriefingScreenInfo();
1350 }
1351 else
1352 {
1353 y = MENU_CENTREY - (AvPMenus.MenuHeight)/2;
1354 }
1355 }
1356 else // in game menus
1357 {
1358 y = (ScreenDescriptorBlock.SDB_Height - AvPMenus.MenuHeight)/2;
1359 }
1360
1361 for (e = 0; e<AvPMenus.NumberOfElementsInMenu; e++, elementPtr++)
1362 {
1363 int targetBrightness;
1364
1365 if (e==AvPMenus.CurrentlySelectedElement)
1366 {
1367 targetBrightness = BRIGHTNESS_OF_HIGHLIGHTED_ELEMENT;
1368 }
1369 else
1370 {
1371 targetBrightness = BRIGHTNESS_OF_DARKENED_ELEMENT;
1372 }
1373
1374 if (targetBrightness > elementPtr->Brightness)
1375 {
1376 elementPtr->Brightness+=BRIGHTNESS_CHANGE_SPEED;
1377 if(elementPtr->Brightness>targetBrightness)
1378 {
1379 elementPtr->Brightness = targetBrightness;
1380 }
1381 }
1382 else
1383 {
1384 elementPtr->Brightness-=BRIGHTNESS_CHANGE_SPEED;
1385 if(elementPtr->Brightness<targetBrightness)
1386 {
1387 elementPtr->Brightness = targetBrightness;
1388 }
1389
1390 }
1391
1392 RenderMenuElement(elementPtr,e,y);
1393 y += HeightOfMenuElement(elementPtr);
1394 }
1395
1396 /* Render Menu Title */
1397 if (AvPMenus.MenusState == MENUSSTATE_MAINMENUS)
1398 {
1399 char *textPtr = GetTextString(AvPMenusData[AvPMenus.CurrentMenu].MenuTitle);
1400 RenderMenuText(textPtr,MENU_CENTREX,70,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
1401
1402 #if 1 // and now we've been told to remove the "Gamers Edition" etc. :)
1403 // main menu subtitle e.g. "Gamers Edition" etc.
1404 if (AvPMenusData[AvPMenus.CurrentMenu].MenuTitle==TEXTSTRING_MAINMENU_TITLE)
1405 RenderMenuText(GetTextString(TEXTSTRING_MAINMENU_SUBTITLE),MENU_CENTREX,100,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
1406 #endif
1407 }
1408
1409 #if 0
1410 else
1411 {
1412 char *textPtr = GetTextString(AvPMenusData[AvPMenus.CurrentMenu].MenuTitle);
1413 Hardware_RenderSmallMenuText(textPtr,MENU_CENTREX,70,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
1414 }
1415 #endif
1416
1417 }
RenderBriefingScreenInfo(void)1418 static void RenderBriefingScreenInfo(void)
1419 {
1420 enum TEXTSTRING_ID textID;
1421 switch (AvP.PlayerType)
1422 {
1423 case I_Marine:
1424 {
1425 textID = MarineEpisodeToPlay+TEXTSTRING_MARINELEVELS_1;
1426 break;
1427 }
1428 case I_Predator:
1429 {
1430 textID = PredatorEpisodeToPlay+TEXTSTRING_PREDATORLEVELS_1;
1431 break;
1432 }
1433 case I_Alien:
1434 {
1435 textID = AlienEpisodeToPlay+TEXTSTRING_ALIENLEVELS_1;
1436 break;
1437 }
1438 }
1439 RenderMenuText(GetTextString(textID),MENU_LEFTXEDGE,120,ONE_FIXED,AVPMENUFORMAT_LEFTJUSTIFIED);
1440 #if 0
1441 switch (AvP.PlayerType)
1442 {
1443 case I_Marine:
1444 {
1445 textID = MarineEpisodeToPlay+TEXTSTRING_LEVELBRIEFING_MARINELEVELS_1;
1446 break;
1447 }
1448 case I_Predator:
1449 {
1450 textID = PredatorEpisodeToPlay+TEXTSTRING_LEVELBRIEFING_PREDATORLEVELS_1;
1451 break;
1452 }
1453 case I_Alien:
1454 {
1455 textID = AlienEpisodeToPlay+TEXTSTRING_LEVELBRIEFING_ALIENLEVELS_1;
1456 break;
1457 }
1458 }
1459 RenderMenuText(GetTextString(textID),MENU_LEFTXEDGE,180,ONE_FIXED/2,AVPMENUFORMAT_LEFTJUSTIFIED);
1460 #endif
1461 RenderBriefingText(ScreenDescriptorBlock.SDB_Height/2,ONE_FIXED);
1462 }
1463 /* KJL 12:11:18 24/09/98 - specialised code to handle episode selection screen, which
1464 has features which make it too awkward to add to the general system */
RenderEpisodeSelectMenu(void)1465 static void RenderEpisodeSelectMenu(void)
1466 {
1467 AVPMENU_ELEMENT *elementPtr = &AvPMenus.MenuElements[AvPMenus.CurrentlySelectedElement];
1468 int currentEpisode = *(elementPtr->c.SliderValuePtr);
1469 int centrePosition = (currentEpisode)*65536+EpisodeSelectScrollOffset;
1470 enum AVPMENUGFX_ID graphicID;
1471 I_PLAYER_TYPE playerID;
1472 int i;
1473 int numberOfBasicLevels;
1474
1475 switch (AvPMenus.CurrentMenu)
1476 {
1477 default:
1478 {
1479 LOCALASSERT(0);/* Panic */
1480 }
1481 case AVPMENU_MARINELEVELS:
1482 {
1483 graphicID = AVPMENUGFX_MARINE_EPISODE1;
1484 numberOfBasicLevels = MAX_NO_OF_BASIC_MARINE_EPISODES;
1485 playerID = I_Marine;
1486 break;
1487 }
1488 case AVPMENU_PREDATORLEVELS:
1489 {
1490 graphicID = AVPMENUGFX_PREDATOR_EPISODE1;
1491 numberOfBasicLevels = MAX_NO_OF_BASIC_PREDATOR_EPISODES;
1492 playerID = I_Predator;
1493 break;
1494 }
1495 case AVPMENU_ALIENLEVELS:
1496 {
1497 graphicID = AVPMENUGFX_ALIEN_EPISODE1;
1498 numberOfBasicLevels = MAX_NO_OF_BASIC_ALIEN_EPISODES;
1499 playerID = I_Alien;
1500 break;
1501 }
1502 }
1503 {
1504 char *textPtr = GetTextString(AvPMenusData[AvPMenus.CurrentMenu].MenuTitle);
1505 RenderMenuText(textPtr,MENU_CENTREX,70,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
1506 }
1507 for (i=0; i<=elementPtr->b.MaxSliderValue; i++)
1508 {
1509 int y;
1510
1511 y = MUL_FIXED(i*65536-centrePosition,100);
1512
1513 if (y>=-150 && y<=150)
1514 {
1515 char *textPtr = GetTextString(elementPtr->a.TextDescription+i);
1516 int b;
1517 int targetBrightness;
1518
1519 if (i==currentEpisode)
1520 {
1521 targetBrightness = BRIGHTNESS_OF_HIGHLIGHTED_ELEMENT;
1522 }
1523 else
1524 {
1525 targetBrightness = BRIGHTNESS_OF_DARKENED_ELEMENT;
1526 }
1527
1528 if (targetBrightness > Brightness[i])
1529 {
1530 Brightness[i]+=BRIGHTNESS_CHANGE_SPEED;
1531 if(Brightness[i]>targetBrightness)
1532 {
1533 Brightness[i] = targetBrightness;
1534 }
1535 }
1536 else
1537 {
1538 Brightness[i]-=BRIGHTNESS_CHANGE_SPEED;
1539 if(Brightness[i]<targetBrightness)
1540 {
1541 Brightness[i] = targetBrightness;
1542 }
1543 }
1544
1545 b=Brightness[i];
1546 {
1547 int yCoord = MENU_CENTREY+y-60;
1548
1549 RenderMenuText_Clipped(textPtr,MENU_LEFTXEDGE+150, yCoord, b,AVPMENUFORMAT_LEFTJUSTIFIED,MENU_CENTREY-60-100,MENU_CENTREY-60+180);
1550 DrawAvPMenuGfx_Clipped(graphicID+i, MENU_LEFTXEDGE, yCoord, b,AVPMENUFORMAT_LEFTJUSTIFIED, MENU_CENTREY-60-100, MENU_CENTREY-60+180);
1551
1552 if (MaximumSelectableLevel>=i)
1553 {
1554 char *completedTextPtr;
1555
1556 if (i<numberOfBasicLevels)
1557 {
1558 completedTextPtr = GetTextString(TEXTSTRING_NOTYETCOMPLETED+UserProfilePtr->LevelCompleted[playerID][i]);
1559 }
1560 else
1561 {
1562 if (UserProfilePtr->LevelCompleted[playerID][i])
1563 {
1564 completedTextPtr = GetTextString(TEXTSTRING_COMPLETED);
1565 }
1566 else
1567 {
1568 completedTextPtr = GetTextString(TEXTSTRING_NOTYETCOMPLETED);
1569 }
1570 }
1571
1572 RenderSmallMenuText
1573 (
1574 completedTextPtr,
1575 MENU_LEFTXEDGE+150,
1576 yCoord+30,
1577 b,
1578 AVPMENUFORMAT_LEFTJUSTIFIED
1579 );
1580 }
1581 else
1582 {
1583 if (i == elementPtr->b.MaxSliderValue)
1584 {
1585 RenderSmallMenuText
1586 (
1587 GetTextString(TEXTSTRING_NOTYETAVAILABLE_2),
1588 MENU_LEFTXEDGE+150,
1589 yCoord+30,
1590 b,
1591 AVPMENUFORMAT_LEFTJUSTIFIED
1592 );
1593 }
1594 else
1595 {
1596 RenderSmallMenuText
1597 (
1598 GetTextString(TEXTSTRING_NOTYETAVAILABLE_1),
1599 MENU_LEFTXEDGE+150,
1600 yCoord+30,
1601 b,
1602 AVPMENUFORMAT_LEFTJUSTIFIED
1603 );
1604 }
1605 }
1606 /*
1607 ,MENU_CENTREY-60-100,
1608 MENU_CENTREY-60+180
1609 );*/
1610 }
1611 }
1612 }
1613
1614 if (EpisodeSelectScrollOffset>0)
1615 {
1616 EpisodeSelectScrollOffset -= MUL_FIXED(EpisodeSelectScrollOffset*2+8192,RealFrameTime<<1);
1617 if (EpisodeSelectScrollOffset<0)
1618 {
1619 EpisodeSelectScrollOffset=0;
1620 }
1621 }
1622 else if (EpisodeSelectScrollOffset<0)
1623 {
1624 EpisodeSelectScrollOffset += MUL_FIXED(-EpisodeSelectScrollOffset*2+8192,RealFrameTime<<1);
1625 if (EpisodeSelectScrollOffset>0)
1626 {
1627 EpisodeSelectScrollOffset=0;
1628 }
1629 }
1630
1631
1632 }
RenderKeyConfigurationMenu(void)1633 static void RenderKeyConfigurationMenu(void)
1634 {
1635 AVPMENU_ELEMENT *elementPtr = AvPMenus.MenuElements;//AvPMenus.CurrentlySelectedElement];
1636 int centrePosition;
1637 int i;
1638 int centreY = ScreenDescriptorBlock.SDB_Height/2+25;
1639 int y;
1640
1641 if (AvPMenus.MenusState == MENUSSTATE_MAINMENUS)
1642 {
1643 char *textPtr = GetTextString(AvPMenusData[AvPMenus.CurrentMenu].MenuTitle);
1644 int b;
1645 if (AvPMenus.CurrentlySelectedElement>=2)
1646 {
1647 b = ONE_FIXED;
1648 }
1649 else
1650 {
1651 b = ONE_FIXED/4;
1652 }
1653
1654 RenderKeyConfigRectangle(b);
1655 RenderMenuText(textPtr,MENU_CENTREX,70,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
1656 }
1657 else
1658 {
1659 int b;
1660 if (AvPMenus.CurrentlySelectedElement>=2)
1661 {
1662 b = ONE_FIXED;
1663 }
1664 else
1665 {
1666 b = ONE_FIXED/4;
1667 }
1668
1669 Hardware_RenderKeyConfigRectangle(b);
1670 }
1671 y = centreY-160;
1672 for (i = 0; i<2; i++, elementPtr++)
1673 {
1674 int targetBrightness;
1675
1676 if (i==AvPMenus.CurrentlySelectedElement)
1677 {
1678 targetBrightness = BRIGHTNESS_OF_HIGHLIGHTED_ELEMENT;
1679 }
1680 else
1681 {
1682 targetBrightness = BRIGHTNESS_OF_DARKENED_ELEMENT;
1683 }
1684
1685 if (targetBrightness > elementPtr->Brightness)
1686 {
1687 elementPtr->Brightness+=BRIGHTNESS_CHANGE_SPEED;
1688 if(elementPtr->Brightness>targetBrightness)
1689 {
1690 elementPtr->Brightness = targetBrightness;
1691 }
1692 }
1693 else
1694 {
1695 elementPtr->Brightness-=BRIGHTNESS_CHANGE_SPEED;
1696 if(elementPtr->Brightness<targetBrightness)
1697 {
1698 elementPtr->Brightness = targetBrightness;
1699 }
1700
1701 }
1702
1703 RenderMenuElement(elementPtr,i,y);
1704 y += HeightOfMenuElement(elementPtr);
1705 }
1706 centrePosition = (AvPMenus.CurrentlySelectedElement)*ONE_FIXED;
1707 if (centrePosition<2*ONE_FIXED) centrePosition = 2*ONE_FIXED;
1708 for (i=2; i<AvPMenus.NumberOfElementsInMenu; i++,elementPtr++)
1709 {
1710
1711 y = MUL_FIXED(i*65536-centrePosition,20);
1712
1713 if (y>=-100 && y<=100)
1714 {
1715 // char *textPtr = GetTextString(elementPtr->TextDescription);
1716 int targetBrightness;
1717
1718 if (i==AvPMenus.CurrentlySelectedElement)
1719 {
1720 targetBrightness = BRIGHTNESS_OF_HIGHLIGHTED_ELEMENT;
1721 }
1722 else
1723 {
1724 targetBrightness = BRIGHTNESS_OF_DARKENED_ELEMENT;
1725 }
1726
1727 #if 0
1728 if (targetBrightness > elementPtr->Brightness)
1729 {
1730 elementPtr->Brightness+=BRIGHTNESS_CHANGE_SPEED;
1731 if(elementPtr->Brightness>targetBrightness)
1732 {
1733 elementPtr->Brightness = targetBrightness;
1734 }
1735 }
1736 else
1737 {
1738 elementPtr->Brightness-=BRIGHTNESS_CHANGE_SPEED;
1739 if(elementPtr->Brightness<targetBrightness)
1740 {
1741 elementPtr->Brightness = targetBrightness;
1742 }
1743
1744 }
1745 #else
1746 elementPtr->Brightness = targetBrightness;
1747 #endif
1748 RenderMenuElement(elementPtr, i, centreY+y);
1749 #if 0
1750 if (AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
1751 {
1752 Hardware_RenderSmallMenuText(textPtr,MENU_LEFTXEDGE+150,centreY+y,b,AVPMENUFORMAT_LEFTJUSTIFIED/*,MENU_CENTREY-60-100,MENU_CENTREY-60+180*/);
1753 }
1754 else
1755 {
1756 RenderSmallMenuText(textPtr,MENU_LEFTXEDGE+150,centreY+y,b,AVPMENUFORMAT_LEFTJUSTIFIED/*,MENU_CENTREY-60-100,MENU_CENTREY-60+180*/);
1757 }
1758 #endif
1759
1760 }
1761 }
1762
1763 if (EpisodeSelectScrollOffset>0)
1764 {
1765 EpisodeSelectScrollOffset -= MUL_FIXED(EpisodeSelectScrollOffset*2+8192,RealFrameTime<<1);
1766 if (EpisodeSelectScrollOffset<0)
1767 {
1768 EpisodeSelectScrollOffset=0;
1769 }
1770 }
1771 else if (EpisodeSelectScrollOffset<0)
1772 {
1773 EpisodeSelectScrollOffset += MUL_FIXED(-EpisodeSelectScrollOffset*2+8192,RealFrameTime<<1);
1774 if (EpisodeSelectScrollOffset>0)
1775 {
1776 EpisodeSelectScrollOffset=0;
1777 }
1778 }
1779 }
1780
RenderScrollyMenu()1781 static void RenderScrollyMenu()
1782 {
1783 AVPMENU_ELEMENT *elementPtr = AvPMenus.MenuElements;
1784 {
1785 //draw the title
1786 char *textPtr = GetTextString(AvPMenusData[AvPMenus.CurrentMenu].MenuTitle);
1787 RenderMenuText(textPtr,MENU_CENTREX,70,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
1788 }
1789
1790 {
1791 int first=AvPMenus.CurrentlySelectedElement;
1792 int last=AvPMenus.CurrentlySelectedElement;
1793 int i;
1794 int y;
1795 BOOL done=FALSE;
1796
1797 int available_above=(MENU_HEIGHT-HeightOfMenuElement(&elementPtr[AvPMenus.CurrentlySelectedElement]))/2;
1798 int available_below=available_above;
1799
1800 //work out the first and last element to be drawn
1801 do
1802 {
1803 done=TRUE;
1804 if(first-1>=0)
1805 {
1806 int h=HeightOfMenuElement(&elementPtr[first-1]);
1807 if(h<=available_above)
1808 {
1809 available_above-=h;
1810 first--;
1811 done=FALSE;
1812 }
1813 else
1814 {
1815 available_below+=available_above;
1816 available_above=0;
1817 }
1818 }
1819 if(first==0)
1820 {
1821 //no more elements above selected element
1822 available_below+=available_above;
1823 available_above=0;
1824 }
1825
1826 if(last+1<AvPMenus.NumberOfElementsInMenu)
1827 {
1828 int h=HeightOfMenuElement(&elementPtr[last+1]);
1829 if(h<=available_below)
1830 {
1831 available_below-=h;
1832 last++;
1833 done=FALSE;
1834 }
1835 }
1836 if(last==(AvPMenus.NumberOfElementsInMenu-1))
1837 {
1838 //no more elements below selected element
1839 available_above+=available_below;
1840 available_below=0;
1841 }
1842 }
1843 while(!done);
1844
1845
1846 //draw the appropriate elements
1847 elementPtr=&elementPtr[first];
1848 y=MENU_TOPY;
1849 for(i=first;i<=last;i++,elementPtr++)
1850 {
1851 // char *textPtr = GetTextString(elementPtr->TextDescription);
1852 int targetBrightness;
1853
1854 if (i==AvPMenus.CurrentlySelectedElement)
1855 {
1856 targetBrightness = BRIGHTNESS_OF_HIGHLIGHTED_ELEMENT;
1857 }
1858 else
1859 {
1860 targetBrightness = BRIGHTNESS_OF_DARKENED_ELEMENT;
1861 }
1862
1863 elementPtr->Brightness = targetBrightness;
1864
1865 RenderMenuElement(elementPtr, i, y);
1866 y+=HeightOfMenuElement(elementPtr);
1867 }
1868
1869 }
1870
1871 }
1872
1873
RenderUserProfileSelectMenu(void)1874 static void RenderUserProfileSelectMenu(void)
1875 {
1876 AVPMENU_ELEMENT *elementPtr = &AvPMenus.MenuElements[AvPMenus.CurrentlySelectedElement];
1877 int currentEpisode = *(elementPtr->c.SliderValuePtr);
1878 int centrePosition = (currentEpisode)*65536+EpisodeSelectScrollOffset;
1879 int i;
1880 AVP_USER_PROFILE *profilePtr = GetFirstUserProfile();
1881 {
1882 char *textPtr = GetTextString(AvPMenusData[AvPMenus.CurrentMenu].MenuTitle);
1883 RenderMenuText(textPtr,MENU_CENTREX,70,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
1884 }
1885
1886 for (i=0; i<=elementPtr->b.MaxSliderValue; i++, profilePtr = GetNextUserProfile())
1887 {
1888 int y;
1889
1890 y = MUL_FIXED(i*65536-centrePosition,80);
1891
1892 if (y>=-150 && y<=150)
1893 {
1894 char *textPtr = profilePtr->Name;
1895 time_t FileTime = profilePtr->FileTime;
1896 int b;
1897 int targetBrightness;
1898
1899 if (i==currentEpisode)
1900 {
1901 targetBrightness = BRIGHTNESS_OF_HIGHLIGHTED_ELEMENT;
1902 }
1903 else
1904 {
1905 targetBrightness = BRIGHTNESS_OF_DARKENED_ELEMENT;
1906 }
1907
1908 if (targetBrightness > Brightness[i])
1909 {
1910 Brightness[i]+=BRIGHTNESS_CHANGE_SPEED;
1911 if(Brightness[i]>targetBrightness)
1912 {
1913 Brightness[i] = targetBrightness;
1914 }
1915 }
1916 else
1917 {
1918 Brightness[i]-=BRIGHTNESS_CHANGE_SPEED;
1919 if(Brightness[i]<targetBrightness)
1920 {
1921 Brightness[i] = targetBrightness;
1922 }
1923 }
1924 b=Brightness[i];
1925 RenderMenuText_Clipped(textPtr,MENU_CENTREX,MENU_CENTREY+y-60,b,AVPMENUFORMAT_CENTREJUSTIFIED,MENU_CENTREY-60-100,MENU_CENTREY-30+150);
1926 if (i > 0)
1927 RenderSmallMenuText(ctime(&FileTime),MENU_CENTREX,MENU_CENTREY+y-30,b,AVPMENUFORMAT_CENTREJUSTIFIED);
1928 }
1929 }
1930
1931 if (EpisodeSelectScrollOffset>0)
1932 {
1933 EpisodeSelectScrollOffset -= MUL_FIXED(EpisodeSelectScrollOffset*2+8192,RealFrameTime<<1);
1934 if (EpisodeSelectScrollOffset<0)
1935 {
1936 EpisodeSelectScrollOffset=0;
1937 }
1938 }
1939 else if (EpisodeSelectScrollOffset<0)
1940 {
1941 EpisodeSelectScrollOffset += MUL_FIXED(-EpisodeSelectScrollOffset*2+8192,RealFrameTime<<1);
1942 if (EpisodeSelectScrollOffset>0)
1943 {
1944 EpisodeSelectScrollOffset=0;
1945 }
1946 }
1947
1948
1949 }
1950
RenderLoadGameMenu(void)1951 static void RenderLoadGameMenu(void)
1952 {
1953 AVPMENU_ELEMENT *elementPtr = AvPMenus.MenuElements;
1954 int e;
1955 int y;
1956 int (*RenderText)(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
1957
1958 if (AvPMenus.MenusState == MENUSSTATE_MAINMENUS)
1959 {
1960 y = MENU_CENTREY - (AvPMenus.MenuHeight)/2;
1961 RenderText = RenderSmallMenuText;
1962 }
1963 else // in game menus
1964 {
1965 y = (ScreenDescriptorBlock.SDB_Height - AvPMenus.MenuHeight)/2;
1966 RenderText = Hardware_RenderSmallMenuText;
1967 }
1968
1969 for (e = 0; e<AvPMenus.NumberOfElementsInMenu; e++, elementPtr++)
1970 {
1971 char buffer[100];
1972 SAVE_SLOT_HEADER *slotPtr = &SaveGameSlot[e];
1973 int targetBrightness;
1974
1975 if (e==AvPMenus.CurrentlySelectedElement)
1976 {
1977 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
1978 {
1979 Hardware_RenderHighlightRectangle(MENU_LEFTXEDGE,y-2,MENU_RIGHTXEDGE,y+4+HUD_FONT_HEIGHT*2,0,128,0);
1980 }
1981 else
1982 {
1983 RenderHighlightRectangle(MENU_LEFTXEDGE,y-2,MENU_RIGHTXEDGE,y+4+HUD_FONT_HEIGHT*2,0,128,0);
1984 }
1985 targetBrightness = BRIGHTNESS_OF_HIGHLIGHTED_ELEMENT;
1986 }
1987 else
1988 {
1989 targetBrightness = BRIGHTNESS_OF_DARKENED_ELEMENT;
1990 }
1991
1992 if (targetBrightness > elementPtr->Brightness)
1993 {
1994 elementPtr->Brightness+=BRIGHTNESS_CHANGE_SPEED;
1995 if(elementPtr->Brightness>targetBrightness)
1996 {
1997 elementPtr->Brightness = targetBrightness;
1998 }
1999 }
2000 else
2001 {
2002 elementPtr->Brightness-=BRIGHTNESS_CHANGE_SPEED;
2003 if(elementPtr->Brightness<targetBrightness)
2004 {
2005 elementPtr->Brightness = targetBrightness;
2006 }
2007
2008 }
2009
2010 sprintf(buffer,"%d.",e+1);
2011 RenderText(buffer,MENU_LEFTXEDGE+20,y,elementPtr->Brightness,AVPMENUFORMAT_RIGHTJUSTIFIED);
2012
2013 if (slotPtr->SlotUsed)
2014 {
2015 int textID;
2016 int numberOfBasicEpisodes;
2017 switch(slotPtr->Species)
2018 {
2019 case I_Marine:
2020 {
2021 textID = TEXTSTRING_MARINELEVELS_1;
2022 numberOfBasicEpisodes = MAX_NO_OF_BASIC_MARINE_EPISODES;
2023 break;
2024 }
2025 case I_Alien:
2026 {
2027 textID = TEXTSTRING_ALIENLEVELS_1;
2028 numberOfBasicEpisodes = MAX_NO_OF_BASIC_ALIEN_EPISODES;
2029 break;
2030 }
2031 case I_Predator:
2032 {
2033 textID = TEXTSTRING_PREDATORLEVELS_1;
2034 numberOfBasicEpisodes = MAX_NO_OF_BASIC_PREDATOR_EPISODES;
2035 break;
2036 }
2037 }
2038
2039
2040 sprintf(buffer,"%s",GetTextString(TEXTSTRING_MULTIPLAYER_MARINE+slotPtr->Species));
2041 RenderText(buffer,MENU_LEFTXEDGE+30,y,elementPtr->Brightness,AVPMENUFORMAT_LEFTJUSTIFIED);
2042
2043 sprintf(buffer,"%s",GetTextString(textID+slotPtr->Episode));
2044 RenderText(buffer,MENU_CENTREX,y,elementPtr->Brightness,AVPMENUFORMAT_CENTREJUSTIFIED);
2045
2046 if (numberOfBasicEpisodes>slotPtr->Episode)
2047 {
2048 sprintf(buffer,"%s",GetTextString(TEXTSTRING_DIFFICULTY_EASY+slotPtr->Difficulty));
2049 RenderText(buffer,MENU_RIGHTXEDGE-30,y,elementPtr->Brightness,AVPMENUFORMAT_RIGHTJUSTIFIED);
2050 }
2051
2052 sprintf(buffer, "%s %02d:%02d:%02d",GetTextString(TEXTSTRING_GAMESTATS_TIMEELAPSED),slotPtr->ElapsedTime_Hours,slotPtr->ElapsedTime_Minutes,slotPtr->ElapsedTime_Seconds);
2053 RenderText(buffer,MENU_LEFTXEDGE+30,y+HUD_FONT_HEIGHT+1,elementPtr->Brightness,AVPMENUFORMAT_LEFTJUSTIFIED);
2054
2055 sprintf(buffer, "%s: %d",GetTextString(TEXTSTRING_SAVEGAME_SAVESLEFT),slotPtr->SavesLeft);
2056 RenderText(buffer,MENU_CENTREX,y+HUD_FONT_HEIGHT+1,elementPtr->Brightness,AVPMENUFORMAT_CENTREJUSTIFIED);
2057 RenderText(ctime(&slotPtr->TimeStamp),MENU_RIGHTXEDGE-30,y+HUD_FONT_HEIGHT+1,elementPtr->Brightness,AVPMENUFORMAT_RIGHTJUSTIFIED);
2058 }
2059 else
2060 {
2061 RenderText(GetTextString(TEXTSTRING_SAVEGAME_EMPTYSLOT),MENU_CENTREX,y,elementPtr->Brightness,AVPMENUFORMAT_CENTREJUSTIFIED);
2062 }
2063
2064 y += HeightOfMenuElement(elementPtr);
2065 }
2066
2067
2068 /* Render Menu Title */
2069 if (AvPMenus.MenusState == MENUSSTATE_MAINMENUS)
2070 {
2071 char *textPtr = GetTextString(AvPMenusData[AvPMenus.CurrentMenu].MenuTitle);
2072 RenderMenuText(textPtr,MENU_CENTREX,70,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
2073 }
2074 else
2075 {
2076 char *textPtr = GetTextString(AvPMenusData[AvPMenus.CurrentMenu].MenuTitle);
2077 AVPMENU_ELEMENT *elementPtr = &AvPMenus.MenuElements[AvPMenus.CurrentlySelectedElement];
2078 y = (ScreenDescriptorBlock.SDB_Height - AvPMenus.MenuHeight)/2 - 30;
2079 RenderText(textPtr,MENU_CENTREX,y,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
2080 y = (ScreenDescriptorBlock.SDB_Height + AvPMenus.MenuHeight)/2 + 20;
2081 RenderText(GetTextString(elementPtr->HelpString),MENU_CENTREX,y,ONE_FIXED,AVPMENUFORMAT_CENTREJUSTIFIED);
2082 }
2083 }
2084
RenderHelpString()2085 static void RenderHelpString()
2086 {
2087 AVPMENU_ELEMENT *elementPtr = &AvPMenus.MenuElements[AvPMenus.CurrentlySelectedElement];
2088
2089 if(elementPtr->HelpString!=TEXTSTRING_BLANK && AvPMenus.MenusState != MENUSSTATE_INGAMEMENUS)
2090 {
2091 RECT area;
2092 //draw the attached string at the bottom of the screen
2093
2094 area.left=MENU_LEFTXEDGE;
2095 area.right=MENU_RIGHTXEDGE;
2096 area.top=420;
2097 area.bottom=ScreenDescriptorBlock.SDB_Height;
2098
2099 RenderSmallFontString_Wrapped(GetTextString(elementPtr->HelpString),&area,BRIGHTNESS_OF_HIGHLIGHTED_ELEMENT,0,0);
2100
2101 }
2102 }
2103
RenderConfigurationDescriptionString()2104 static void RenderConfigurationDescriptionString()
2105 {
2106 const char* text=GetMultiplayerConfigDescription(AvPMenus.CurrentlySelectedElement);
2107 if(text)
2108 {
2109 RECT area;
2110 //draw the text at the bottom of the screen
2111 //now at the top.
2112
2113 area.left=MENU_LEFTXEDGE;
2114 area.right=MENU_RIGHTXEDGE;
2115 area.top=0;
2116 area.bottom=60;
2117
2118 RenderSmallFontString_Wrapped(text,&area,BRIGHTNESS_OF_HIGHLIGHTED_ELEMENT,0,0);
2119 }
2120 }
2121
2122
ActUponUsersInput(void)2123 static void ActUponUsersInput(void)
2124 {
2125 static int BackspaceTimer=0;
2126 //Set up a keyboard repeat rate thingy for deleting long strings
2127 if(KeyboardInput[KEY_BACKSPACE])
2128 {
2129 BackspaceTimer+=RealFrameTime;
2130 }
2131 else
2132 {
2133 BackspaceTimer=0;
2134 }
2135
2136 if (AvPMenus.UserEnteringText)
2137 {
2138 AVPMENU_ELEMENT *elementPtr = &AvPMenus.MenuElements[AvPMenus.CurrentlySelectedElement];
2139
2140 if (DebouncedKeyboardInput[KEY_ESCAPE] || DebouncedKeyboardInput[KEY_CR])
2141 {
2142 elementPtr->c.TextPtr[AvPMenus.PositionInTextField] = 0;
2143 AvPMenus.UserEnteringText = 0;
2144
2145 // KJL 10:09:35 09/02/00 - when the user has entered their name,
2146 // move down to the next option. If the user enters a null
2147 // string, replace it with a placeholder name
2148 if((AvPMenus.CurrentMenu == AVPMENU_USERPROFILEENTERNAME)
2149 ||(AvPMenus.CurrentMenu == AVPMENU_MULTIPLAYER_SKIRMISH)
2150 ||(AvPMenus.CurrentMenu == AVPMENU_MULTIPLAYER))
2151 {
2152 if(AvPMenus.PositionInTextField==0)
2153 {
2154 strcpy(elementPtr->c.TextPtr,"DeadMeat");
2155 }
2156 AvPMenus.CurrentlySelectedElement++;
2157 }
2158 }
2159 else if (DebouncedKeyboardInput[KEY_BACKSPACE] || DebouncedKeyboardInput[KEY_LEFT])
2160 {
2161 if (AvPMenus.PositionInTextField>0)
2162 {
2163 elementPtr->c.TextPtr[--AvPMenus.PositionInTextField] = 0;
2164 }
2165 }
2166 else if(BackspaceTimer>ONE_FIXED/2)
2167 {
2168 //check for backspace being held down for a long time
2169 while(BackspaceTimer>ONE_FIXED/2)
2170 {
2171 BackspaceTimer-=ONE_FIXED/20;
2172 if (AvPMenus.PositionInTextField>0)
2173 {
2174 elementPtr->c.TextPtr[--AvPMenus.PositionInTextField] = 0;
2175 }
2176 }
2177 }
2178 else
2179 {
2180 //allow Ctrl+V to paste from the clipboard (really just for pasting in ip addresses)
2181 if((KeyboardInput[KEY_LEFTCTRL] || KeyboardInput[KEY_RIGHTCTRL]) && KeyboardInput[KEY_V])
2182 {
2183 PasteFromClipboard(elementPtr->c.TextPtr,elementPtr->b.MaxTextLength);
2184 AvPMenus.PositionInTextField = strlen(elementPtr->c.TextPtr);
2185 }
2186 else if (AvPMenus.PositionInTextField<elementPtr->b.MaxTextLength)
2187 {
2188 char c=0;
2189 KeyboardEntryQueue_StartProcessing();
2190
2191 while((c=KeyboardEntryQueue_ProcessCharacter()))
2192 {
2193 if (AvPMenus.PositionInTextField<elementPtr->b.MaxTextLength)
2194 {
2195 //see if there is room for this character
2196 if(AvPMenus.FontToUse==AVPMENU_FONT_BIG && elementPtr->ElementID !=AVPMENU_ELEMENT_TEXTFIELD_SMALLWRAPPED)
2197 {
2198 //using large font
2199 //allocate 32 pixels for each new character for the moment
2200 //the true amount used will be worked out when the font is drawn
2201 //Might cause a slight glitch for fast typists , but I forgot about
2202 //the damned kerned fonts until after I'd written most of this
2203 if(AvPMenus.WidthLeftForText<32) break;
2204 AvPMenus.WidthLeftForText-=32;
2205
2206 }
2207 else
2208 {
2209 extern char AAFontWidths[256];
2210 //using small font
2211 if(AvPMenus.WidthLeftForText<AAFontWidths[(unsigned char)c]) break;
2212 AvPMenus.WidthLeftForText-=AAFontWidths[(unsigned char)c];
2213 }
2214
2215 elementPtr->c.TextPtr[AvPMenus.PositionInTextField++] = c;
2216 elementPtr->c.TextPtr[AvPMenus.PositionInTextField] = 0;
2217 }
2218 }
2219
2220 }
2221
2222 KeyboardEntryQueue_Clear();
2223
2224 }
2225 }
2226 else if (AvPMenus.UserEnteringNumber)
2227 {
2228 AVPMENU_ELEMENT *elementPtr = &AvPMenus.MenuElements[AvPMenus.CurrentlySelectedElement];
2229
2230 if (DebouncedKeyboardInput[KEY_ESCAPE] || DebouncedKeyboardInput[KEY_CR])
2231 {
2232 AvPMenus.UserEnteringNumber = 0;
2233 }
2234 else if (DebouncedKeyboardInput[KEY_BACKSPACE] || DebouncedKeyboardInput[KEY_LEFT])
2235 {
2236 (*elementPtr->c.NumberPtr)/=10;
2237 }
2238 else
2239 {
2240 char c=0;
2241
2242 KeyboardEntryQueue_StartProcessing();
2243 while((c=KeyboardEntryQueue_ProcessCharacter()))
2244 {
2245 if (AvPMenus.PositionInTextField<elementPtr->b.MaxTextLength)
2246 {
2247 if(c>='0' && c<='9')
2248 {
2249 (*elementPtr->c.NumberPtr)*=10;
2250 (*elementPtr->c.NumberPtr)+=c-'0';
2251
2252 if((*elementPtr->c.NumberPtr)>elementPtr->b.MaxValue)
2253 {
2254 (*elementPtr->c.NumberPtr)=elementPtr->b.MaxValue;
2255 }
2256 }
2257 }
2258 }
2259 }
2260 KeyboardEntryQueue_Clear();
2261 }
2262 else if (AvPMenus.UserChangingKeyConfig)
2263 {
2264 if (DebouncedKeyboardInput[KEY_ESCAPE])
2265 {
2266 AvPMenus.UserChangingKeyConfig = 0;
2267 }
2268 else
2269 {
2270 signed int key,selectedKey=-1;
2271
2272 // see if a valid key has been pressed
2273 for (key = 0 ; key <= MAX_NUMBER_OF_INPUT_KEYS ; key++)
2274 {
2275 if (!(key == KEY_ESCAPE) &&
2276 // !(key >= KEY_F1 && key <= KEY_F12) &&
2277 !(key >= KEY_0 && key <= KEY_9) )
2278 {
2279 if (DebouncedKeyboardInput[key])
2280 {
2281 selectedKey = key;
2282 break;
2283 }
2284 }
2285 }
2286
2287 if (AvPMenus.ChangingPrimaryConfig)
2288 {
2289 if (selectedKey!=-1)
2290 {
2291 *(((unsigned char*)&PlayerInputPrimaryConfig)+AvPMenus.CurrentlySelectedElement-2) = selectedKey;
2292 AvPMenus.UserChangingKeyConfig=0;
2293 }
2294 }
2295 else // changing Secondary
2296 {
2297 if (selectedKey!=-1)
2298 {
2299 *(((unsigned char*)&PlayerInputSecondaryConfig)+AvPMenus.CurrentlySelectedElement-2) = selectedKey;
2300 AvPMenus.UserChangingKeyConfig=0;
2301 }
2302 }
2303 }
2304 }
2305 else
2306 {
2307 if (DebouncedKeyboardInput[KEY_ESCAPE] && (AvPMenus.CurrentMenu != AVPMENU_MAIN && AvPMenus.CurrentMenu != AVPMENU_INGAME))
2308 {
2309 //if (AvPMenus.CurrentMenu == AVPMENU_MULTIPLAYERJOINGAME2)
2310 switch(AvPMenus.CurrentMenu)
2311 {
2312 case AVPMENU_MULTIPLAYER_CONFIG_JOIN:
2313 {
2314 AddNetMsg_PlayerLeaving();
2315 NetSendMessages();
2316 if(!LobbiedGame)
2317 {
2318 DirectPlay_Disconnect();
2319 }
2320 break;
2321 }
2322 case AVPMENU_DETAILLEVELS:
2323 {
2324 SetDetailLevelsFromMenu();
2325 SaveUserProfile(UserProfilePtr);
2326 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
2327 {
2328 SetupNewMenu(AVPMENU_INGAMEAVOPTIONS);
2329 }
2330 break;
2331 }
2332 case AVPMENU_INGAMEAVOPTIONS:
2333 case AVPMENU_MAINMENUAVOPTIONS:
2334 {
2335 SaveUserProfile(UserProfilePtr);
2336 break;
2337 }
2338 case AVPMENU_CHEATOPTIONS:
2339 {
2340 CheatMode_Active = CHEATMODE_NONACTIVE;
2341 break;
2342 }
2343
2344 case AVPMENU_MULTIPLAYER_CONFIG :
2345 case AVPMENU_SKIRMISH_CONFIG :
2346 {
2347 //reload the previous multiplayer configuration
2348 extern char MP_Config_Description[];
2349 LoadMultiplayerConfiguration(GetTextString(TEXTSTRING_PREVIOUSGAME_FILENAME));
2350 MP_Config_Description[0]=0;
2351 break;
2352 }
2353
2354 default:
2355 break;
2356 }
2357
2358
2359 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
2360 {
2361 SetupNewMenu(AVPMENU_INGAME);
2362 }
2363 else
2364 {
2365 SetupNewMenu(AvPMenusData[AvPMenus.CurrentMenu].ParentMenu);
2366 }
2367 }
2368 else if (IDemandSelect()) // select element
2369 {
2370 if (InputIsDebounced)
2371 {
2372 InteractWithMenuElement(AVPMENU_ELEMENT_INTERACTION_SELECT);
2373 InputIsDebounced = 0;
2374 }
2375 }
2376 else if (IDemandGoForward()) // previous element
2377 {
2378 if (InputIsDebounced)
2379 {
2380 switch (AvPMenus.CurrentMenu)
2381 {
2382 case AVPMENU_USERPROFILESELECT:
2383 case AVPMENU_MARINELEVELS:
2384 case AVPMENU_PREDATORLEVELS:
2385 case AVPMENU_ALIENLEVELS:
2386 {
2387 InteractWithMenuElement(AVPMENU_ELEMENT_INTERACTION_DECREASE);
2388 break;
2389 }
2390 case AVPMENU_MARINEKEYCONFIG:
2391 case AVPMENU_PREDATORKEYCONFIG:
2392 case AVPMENU_ALIENKEYCONFIG:
2393 {
2394 if (AvPMenus.CurrentlySelectedElement>0)
2395 {
2396 AvPMenus.CurrentlySelectedElement--;
2397 Sound_Play(SID_MENUS_CHANGE_ITEM,"r");
2398 }
2399 break;
2400 }
2401 default:
2402 {
2403 AvPMenus.CurrentlySelectedElement--;
2404 if (AvPMenus.CurrentlySelectedElement<0)
2405 {
2406 AvPMenus.CurrentlySelectedElement= AvPMenus.NumberOfElementsInMenu-1;
2407 }
2408 Sound_Play(SID_MENUS_CHANGE_ITEM,"r");
2409 break;
2410 }
2411 }
2412 InputIsDebounced = 0;
2413 }
2414 else
2415 {
2416 KeyDepressedCounter += RealFrameTime;
2417 }
2418
2419 }
2420 else if (IDemandGoBackward()) // next element
2421 {
2422 if (InputIsDebounced)
2423 {
2424 switch (AvPMenus.CurrentMenu)
2425 {
2426 case AVPMENU_USERPROFILESELECT:
2427 case AVPMENU_MARINELEVELS:
2428 case AVPMENU_PREDATORLEVELS:
2429 case AVPMENU_ALIENLEVELS:
2430 {
2431 InteractWithMenuElement(AVPMENU_ELEMENT_INTERACTION_INCREASE);
2432 break;
2433 }
2434 case AVPMENU_MARINEKEYCONFIG:
2435 case AVPMENU_PREDATORKEYCONFIG:
2436 case AVPMENU_ALIENKEYCONFIG:
2437 {
2438 if (AvPMenus.CurrentlySelectedElement<AvPMenus.NumberOfElementsInMenu-1)
2439 {
2440 AvPMenus.CurrentlySelectedElement++;
2441 Sound_Play(SID_MENUS_CHANGE_ITEM,"r");
2442 }
2443 break;
2444 }
2445 default:
2446 {
2447 AvPMenus.CurrentlySelectedElement++;
2448 if (AvPMenus.CurrentlySelectedElement>=AvPMenus.NumberOfElementsInMenu)
2449 {
2450 AvPMenus.CurrentlySelectedElement= 0;
2451 }
2452 Sound_Play(SID_MENUS_CHANGE_ITEM,"r");
2453 break;
2454 }
2455 }
2456
2457 InputIsDebounced = 0;
2458 }
2459 else
2460 {
2461 KeyDepressedCounter += RealFrameTime;
2462 }
2463 }
2464 else if (IDemandTurnLeft())
2465 {
2466 if (InputIsDebounced)
2467 {
2468 InteractWithMenuElement(AVPMENU_ELEMENT_INTERACTION_DECREASE);
2469 InputIsDebounced = 0;
2470 }
2471 else
2472 {
2473 KeyDepressedCounter += RealFrameTime;
2474 }
2475 }
2476 else if (IDemandTurnRight())
2477 {
2478 if (InputIsDebounced)
2479 {
2480 InteractWithMenuElement(AVPMENU_ELEMENT_INTERACTION_INCREASE);
2481 InputIsDebounced = 0;
2482 }
2483 else
2484 {
2485 KeyDepressedCounter += RealFrameTime;
2486 }
2487 }
2488 else if (DebouncedKeyboardInput[KEY_BACKSPACE])
2489 {
2490 switch (AvPMenus.MenuElements[AvPMenus.CurrentlySelectedElement].ElementID)
2491 {
2492 case AVPMENU_ELEMENT_KEYCONFIG:
2493 {
2494 if (!KeyConfigSelectionColumn)
2495 {
2496 *(((unsigned char*)&PlayerInputPrimaryConfig)+AvPMenus.CurrentlySelectedElement-2) = KEY_VOID;
2497 }
2498 else // changing Secondary
2499 {
2500 *(((unsigned char*)&PlayerInputSecondaryConfig)+AvPMenus.CurrentlySelectedElement-2) = KEY_VOID;
2501 }
2502 break;
2503 }
2504 case AVPMENU_ELEMENT_USERPROFILE:
2505 {
2506 if (UserProfileNumber)
2507 {
2508 SetupNewMenu(AVPMENU_USERPROFILEDELETE);
2509 }
2510 break;
2511 }
2512 case AVPMENU_ELEMENT_LOADMPCONFIG :
2513 {
2514 //take note of the current configuration
2515 MultiplayerConfigurationIndex=AvPMenus.CurrentlySelectedElement;
2516 MultiplayerConfigurationName=AvPMenus.MenuElements[AvPMenus.CurrentlySelectedElement].c.TextPtr;
2517 //setup the delete configuration menu
2518 SetupNewMenu(AVPMENU_MULTIPLAYER_DELETECONFIG);
2519 break;
2520 }
2521 default:
2522 break;
2523 }
2524 }
2525 else
2526 {
2527 InputIsDebounced=1;
2528 KeyDepressedCounter = 0;
2529 }
2530
2531 if (KeyDepressedCounter>ONE_FIXED)
2532 InputIsDebounced = 1;
2533 }
2534
2535 }
InteractWithMenuElement(enum AVPMENU_ELEMENT_INTERACTION_ID interactionID)2536 static void InteractWithMenuElement(enum AVPMENU_ELEMENT_INTERACTION_ID interactionID)
2537 {
2538 AVPMENU_ELEMENT *elementPtr = &AvPMenus.MenuElements[AvPMenus.CurrentlySelectedElement];
2539
2540 if (interactionID==AVPMENU_ELEMENT_INTERACTION_SELECT)
2541 {
2542 Sound_Play(SID_MENUS_SELECT_ITEM,"r");
2543 }
2544 else
2545 {
2546 Sound_Play(SID_MENUS_CHANGE_ITEM,"r");
2547 }
2548 switch(elementPtr->ElementID)
2549 {
2550 default:
2551 GLOBALASSERT("UNKNOWN MENU ELEMENT"==0);
2552 case AVPMENU_ELEMENT_GOTOMENU:
2553 case AVPMENU_ELEMENT_GOTOMENU_GFX:
2554 {
2555 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2556 {
2557 //Check to see if we are on one of the menus for entering multiplayer name
2558 if(AvPMenus.CurrentMenu==AVPMENU_MULTIPLAYER ||
2559 AvPMenus.CurrentMenu==AVPMENU_MULTIPLAYER_LOBBIEDSERVER)
2560 {
2561 //save profile , so that multiplayer name is remembered
2562 SaveUserProfile(UserProfilePtr);
2563 }
2564
2565 SetupNewMenu(elementPtr->b.MenuToGoTo);
2566 }
2567 break;
2568 }
2569 case AVPMENU_ELEMENT_SAVEMPCONFIG :
2570 {
2571 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2572 {
2573 if(MP_Config_Name[0])
2574 {
2575 SaveMultiplayerConfiguration(MP_Config_Name);
2576 }
2577 SetupNewMenu(elementPtr->b.MenuToGoTo);
2578 }
2579 break;
2580 }
2581 case AVPMENU_ELEMENT_TEXTFIELD:
2582 {
2583 AvPMenus.UserEnteringText = 1;
2584 KeyboardEntryQueue_Clear();
2585 AvPMenus.PositionInTextField = strlen(elementPtr->c.TextPtr);
2586 elementPtr->c.TextPtr[AvPMenus.PositionInTextField] = 0;
2587 AvPMenus.WidthLeftForText = 0; //will be calculated properly when menus are drawn
2588 break;
2589 }
2590 case AVPMENU_ELEMENT_TEXTFIELD_SMALLWRAPPED:
2591 {
2592 AvPMenus.UserEnteringText = 1;
2593 KeyboardEntryQueue_Clear();
2594 AvPMenus.PositionInTextField = strlen(elementPtr->c.TextPtr);
2595 AvPMenus.WidthLeftForText = 0; //will be calculated properly when menus are drawn
2596 break;
2597 }
2598
2599 case AVPMENU_ELEMENT_NUMBERFIELD:
2600 {
2601 if(interactionID == AVPMENU_ELEMENT_INTERACTION_DECREASE)
2602 {
2603 (*elementPtr->c.NumberPtr)--;
2604 if(*elementPtr->c.NumberPtr<0)
2605 {
2606 *elementPtr->c.NumberPtr=0;
2607 }
2608 }
2609 else if(interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE)
2610 {
2611 (*elementPtr->c.NumberPtr)++;
2612 if(*elementPtr->c.NumberPtr>elementPtr->b.MaxValue)
2613 {
2614 *elementPtr->c.NumberPtr=elementPtr->b.MaxValue;
2615 }
2616
2617 }
2618 else
2619 {
2620 *elementPtr->c.NumberPtr=0;
2621 AvPMenus.UserEnteringNumber = 1;
2622 KeyboardEntryQueue_Clear();
2623 }
2624 break;
2625 }
2626 case AVPMENU_ELEMENT_DUMMYTEXTFIELD:
2627 case AVPMENU_ELEMENT_DUMMYTEXTSLIDER:
2628 case AVPMENU_ELEMENT_DUMMYTEXTSLIDER_POINTER:
2629 case AVPMENU_ELEMENT_DUMMYNUMBERFIELD:
2630 case AVPMENU_ELEMENT_TOGGLE:
2631 {
2632 break;
2633 }
2634 case AVPMENU_ELEMENT_SLIDER:
2635 {
2636 if ((interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2637 ||(interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE))
2638 {
2639 if (*elementPtr->c.SliderValuePtr<elementPtr->b.MaxSliderValue)
2640 {
2641 *elementPtr->c.SliderValuePtr+=1;
2642 }
2643 }
2644 else
2645 {
2646 if (*elementPtr->c.SliderValuePtr>0)
2647 {
2648 *elementPtr->c.SliderValuePtr-=1;
2649 }
2650 }
2651 break;
2652 }
2653 case AVPMENU_ELEMENT_TEXTSLIDER:
2654 case AVPMENU_ELEMENT_TEXTSLIDER_POINTER:
2655 {
2656 if ((interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2657 ||(interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE))
2658 {
2659 *elementPtr->c.SliderValuePtr+=1;
2660 if (*elementPtr->c.SliderValuePtr>elementPtr->b.MaxSliderValue)
2661 {
2662 *elementPtr->c.SliderValuePtr=0;
2663 }
2664 }
2665 else
2666 {
2667 *elementPtr->c.SliderValuePtr-=1;
2668 if (*elementPtr->c.SliderValuePtr<0)
2669 {
2670 *elementPtr->c.SliderValuePtr=elementPtr->b.MaxSliderValue;
2671 }
2672 }
2673 break;
2674 }
2675 case AVPMENU_ELEMENT_SPECIES_TEXTSLIDER:
2676 {
2677 if ((interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2678 ||(interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE))
2679 {
2680 *elementPtr->c.SliderValuePtr+=1;
2681 if (*elementPtr->c.SliderValuePtr>elementPtr->b.MaxSliderValue)
2682 {
2683 *elementPtr->c.SliderValuePtr=0;
2684 }
2685 GetNextAllowedSpecies(elementPtr->c.SliderValuePtr,TRUE);
2686 }
2687 else
2688 {
2689 *elementPtr->c.SliderValuePtr-=1;
2690 if (*elementPtr->c.SliderValuePtr<0)
2691 {
2692 *elementPtr->c.SliderValuePtr=elementPtr->b.MaxSliderValue;
2693 }
2694 GetNextAllowedSpecies(elementPtr->c.SliderValuePtr,FALSE);
2695 }
2696 break;
2697 }
2698 case AVPMENU_ELEMENT_CHEATMODE_SPECIES_TEXTSLIDER:
2699 {
2700 if ((interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2701 ||(interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE))
2702 {
2703 *elementPtr->c.SliderValuePtr+=1;
2704 if (*elementPtr->c.SliderValuePtr>elementPtr->b.MaxSliderValue)
2705 {
2706 *elementPtr->c.SliderValuePtr=0;
2707 }
2708 CheatMode_GetNextAllowedSpecies(elementPtr->c.SliderValuePtr,TRUE);
2709 }
2710 else
2711 {
2712 *elementPtr->c.SliderValuePtr-=1;
2713 if (*elementPtr->c.SliderValuePtr<0)
2714 {
2715 *elementPtr->c.SliderValuePtr=elementPtr->b.MaxSliderValue;
2716 }
2717 CheatMode_GetNextAllowedSpecies(elementPtr->c.SliderValuePtr,FALSE);
2718 }
2719 break;
2720 }
2721 case AVPMENU_ELEMENT_CHEATMODE_TEXTSLIDER:
2722 {
2723 if ((interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2724 ||(interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE))
2725 {
2726 *elementPtr->c.SliderValuePtr+=1;
2727 if (*elementPtr->c.SliderValuePtr>elementPtr->b.MaxSliderValue)
2728 {
2729 *elementPtr->c.SliderValuePtr=0;
2730 }
2731 CheatMode_GetNextAllowedMode(elementPtr->c.SliderValuePtr,TRUE);
2732 }
2733 else
2734 {
2735 *elementPtr->c.SliderValuePtr-=1;
2736 if (*elementPtr->c.SliderValuePtr<0)
2737 {
2738 *elementPtr->c.SliderValuePtr=elementPtr->b.MaxSliderValue;
2739 }
2740 CheatMode_GetNextAllowedMode(elementPtr->c.SliderValuePtr,FALSE);
2741 }
2742 break;
2743 }
2744 case AVPMENU_ELEMENT_CHEATMODE_ENVIRONMENT_TEXTSLIDER:
2745 {
2746 if ((interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2747 ||(interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE))
2748 {
2749 *elementPtr->c.SliderValuePtr+=1;
2750 if (*elementPtr->c.SliderValuePtr>elementPtr->b.MaxSliderValue)
2751 {
2752 *elementPtr->c.SliderValuePtr=0;
2753 }
2754 CheatMode_GetNextAllowedEnvironment(elementPtr->c.SliderValuePtr,TRUE);
2755 }
2756 else
2757 {
2758 *elementPtr->c.SliderValuePtr-=1;
2759 if (*elementPtr->c.SliderValuePtr<0)
2760 {
2761 *elementPtr->c.SliderValuePtr=elementPtr->b.MaxSliderValue;
2762 }
2763 CheatMode_GetNextAllowedEnvironment(elementPtr->c.SliderValuePtr,FALSE);
2764 }
2765 break;
2766 }
2767
2768 case AVPMENU_ELEMENT_QUITGAME:
2769 {
2770 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2771 {
2772 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
2773 {
2774 AvP.MainLoopRunning = 0;
2775 }
2776 AvPMenus.MenusState = MENUSSTATE_OUTSIDEMENUS;
2777 }
2778 break;
2779 }
2780
2781 case AVPMENU_ELEMENT_USERPROFILE:
2782 {
2783 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2784 {
2785 /* a profile has been selected */
2786 int i;
2787 UserProfilePtr = GetFirstUserProfile();
2788 for (i=0; i<UserProfileNumber; i++)
2789 UserProfilePtr = GetNextUserProfile();
2790
2791 if (UserProfileNumber)
2792 {
2793 // Edmond too
2794 GetSettingsFromUserProfile();
2795 // Edmond
2796 if (LobbiedGame == LobbiedGame_Server)
2797 {
2798 SetupNewMenu(AVPMENU_MULTIPLAYER_CONFIG); // Edmond
2799 }
2800 else if (LobbiedGame == LobbiedGame_Client)
2801 {
2802 SetupNewMenu(AVPMENU_MULTIPLAYER_LOBBIEDCLIENT);
2803 }
2804 else
2805 SetupNewMenu(AVPMENU_MAIN);
2806 }
2807 else
2808 {
2809 SetupNewMenu(AVPMENU_USERPROFILEENTERNAME);
2810 }
2811 }
2812 else if (interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE)
2813 {
2814 if (*elementPtr->c.SliderValuePtr<elementPtr->b.MaxSliderValue)
2815 {
2816 *elementPtr->c.SliderValuePtr+=1;
2817 EpisodeSelectScrollOffset-=ONE_FIXED;
2818 }
2819 }
2820 else
2821 {
2822 if (*elementPtr->c.SliderValuePtr>0)
2823 {
2824 *elementPtr->c.SliderValuePtr-=1;
2825 EpisodeSelectScrollOffset+=ONE_FIXED;
2826 }
2827 }
2828 break;
2829 }
2830 case AVPMENU_ELEMENT_USERPROFILE_DELETE:
2831 {
2832 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2833 {
2834 DeleteUserProfile(UserProfileNumber);
2835 SetupNewMenu(AVPMENU_USERPROFILESELECT);
2836 }
2837 break;
2838 }
2839 case AVPMENU_ELEMENT_DELETEMPCONFIG:
2840 {
2841 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2842 {
2843 DeleteMultiplayerConfigurationByIndex(MultiplayerConfigurationIndex);
2844 //go back to the load config menu
2845 SetupNewMenu(AVPMENU_MULTIPLAYER_LOADCONFIG);
2846
2847 }
2848 break;
2849 }
2850 case AVPMENU_ELEMENT_DIFFICULTYLEVEL:
2851 {
2852 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2853 {
2854 if (AvPMenus.CurrentMenu == AVPMENU_LEVELBRIEFING_BASIC)
2855 {
2856 AvP.Difficulty = AvPMenus.CurrentlySelectedElement;
2857 }
2858 else
2859 {
2860 AvP.Difficulty = 1;
2861 }
2862 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
2863 }
2864 break;
2865 }
2866
2867 case AVPMENU_ELEMENT_ALIENEPISODE:
2868 {
2869 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT
2870 &&MaximumSelectableLevel>=*elementPtr->c.SliderValuePtr)
2871 {
2872 AvP.PlayerType = I_Alien;
2873 SetLevelToLoadForAlien(AlienEpisodeToPlay);
2874
2875 if (AlienEpisodeToPlay<MAX_NO_OF_BASIC_ALIEN_EPISODES)
2876 {
2877 SetupNewMenu(AVPMENU_LEVELBRIEFING_BASIC);
2878 }
2879 else
2880 {
2881 SetupNewMenu(AVPMENU_LEVELBRIEFING_BONUS);
2882 }
2883 AvPMenusData[AvPMenus.CurrentMenu].ParentMenu = AVPMENU_ALIENLEVELS;
2884 break;
2885 }
2886 /* else let it fall through */
2887
2888 }
2889 case AVPMENU_ELEMENT_MARINEEPISODE:
2890 {
2891 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT
2892 &&MaximumSelectableLevel>=*elementPtr->c.SliderValuePtr)
2893 {
2894 AvP.PlayerType = I_Marine;
2895 SetLevelToLoadForMarine(MarineEpisodeToPlay);
2896
2897 if (MarineEpisodeToPlay<MAX_NO_OF_BASIC_MARINE_EPISODES)
2898 {
2899 SetupNewMenu(AVPMENU_LEVELBRIEFING_BASIC);
2900 }
2901 else
2902 {
2903 SetupNewMenu(AVPMENU_LEVELBRIEFING_BONUS);
2904 }
2905 AvPMenusData[AvPMenus.CurrentMenu].ParentMenu = AVPMENU_MARINELEVELS;
2906 break;
2907 }
2908 /* else let it fall through */
2909 }
2910 case AVPMENU_ELEMENT_PREDATOREPISODE:
2911 {
2912 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT
2913 &&MaximumSelectableLevel>=*elementPtr->c.SliderValuePtr)
2914 {
2915 AvP.PlayerType = I_Predator;
2916 SetLevelToLoadForPredator(PredatorEpisodeToPlay);
2917
2918 if (PredatorEpisodeToPlay<MAX_NO_OF_BASIC_PREDATOR_EPISODES)
2919 {
2920 SetupNewMenu(AVPMENU_LEVELBRIEFING_BASIC);
2921 }
2922 else
2923 {
2924 SetupNewMenu(AVPMENU_LEVELBRIEFING_BONUS);
2925 }
2926 AvPMenusData[AvPMenus.CurrentMenu].ParentMenu = AVPMENU_PREDATORLEVELS;
2927 break;
2928 }
2929 /* else let it fall through */
2930 }
2931 {
2932 /* This code is reached when an EPISODE element has been
2933 activated but not "selected" i.e. the user wants to change
2934 the current episode, not start playing the current episode */
2935 if (interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE)
2936 {
2937 if (*elementPtr->c.SliderValuePtr<elementPtr->b.MaxSliderValue)
2938 {
2939 *elementPtr->c.SliderValuePtr+=1;
2940 EpisodeSelectScrollOffset-=ONE_FIXED;
2941 }
2942 }
2943 else
2944 {
2945 if (*elementPtr->c.SliderValuePtr>0)
2946 {
2947 *elementPtr->c.SliderValuePtr-=1;
2948 EpisodeSelectScrollOffset+=ONE_FIXED;
2949 }
2950 }
2951 break;
2952 }
2953 case AVPMENU_ELEMENT_BUTTONSETTING:
2954 {
2955
2956 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2957 {
2958 break;
2959 }
2960 /* else let it fall through */
2961
2962 if (interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE)
2963 {
2964 if (*elementPtr->c.SliderValuePtr<elementPtr->b.MaxSliderValue)
2965 {
2966 *elementPtr->c.SliderValuePtr+=1;
2967 EpisodeSelectScrollOffset-=ONE_FIXED;
2968 }
2969 }
2970 else
2971 {
2972 if (*elementPtr->c.SliderValuePtr>0)
2973 {
2974 *elementPtr->c.SliderValuePtr-=1;
2975 EpisodeSelectScrollOffset+=ONE_FIXED;
2976 }
2977 }
2978 break;
2979 }
2980
2981 case AVPMENU_ELEMENT_STARTMARINEDEMO:
2982 {
2983 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2984 {
2985 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
2986 AvP.PlayerType = I_Marine;
2987 AvP.Difficulty = 1;
2988 SetLevelToLoad(AVP_ENVIRONMENT_INVASION);
2989 }
2990 break;
2991 }
2992 case AVPMENU_ELEMENT_STARTPREDATORDEMO:
2993 {
2994 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
2995 {
2996 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
2997 AvP.PlayerType = I_Predator;
2998 AvP.Difficulty = 1;
2999 SetLevelToLoad(AVP_ENVIRONMENT_INVASION_P);
3000 }
3001 break;
3002 }
3003 case AVPMENU_ELEMENT_STARTALIENDEMO:
3004 {
3005 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3006 {
3007 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
3008 AvP.PlayerType = I_Alien;
3009 AvP.Difficulty = 1;
3010 SetLevelToLoad(AVP_ENVIRONMENT_INVASION_A);
3011 }
3012 break;
3013 }
3014 case AVPMENU_ELEMENT_STARTLEVELWITHCHEAT:
3015 {
3016 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3017 {
3018 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
3019 AvP.PlayerType = CheatMode_Species;
3020 AvP.Difficulty = 1;
3021 SetLevelToLoadForCheatMode(CheatMode_Environment);
3022 }
3023 break;
3024 }
3025 case AVPMENU_ELEMENT_STARTMPGAME:
3026 {
3027 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3028 {
3029 extern int DirectPlay_HostGame(char *playerName, char *sessionName,int species,int gamestyle,int level);
3030 extern char MP_PlayerName[];
3031 extern char MP_SessionName[];
3032 extern int MP_Species;
3033 extern char MP_Config_Description[];
3034 // extern int MP_GameStyle;
3035 // extern int MP_LevelNumber;
3036
3037 //save the 'Previous Game' multiplayer configuration
3038 strcpy(MP_Config_Description,GetTextString(TEXTSTRING_PREVIOUSGAME_FILENAME));
3039 SaveMultiplayerConfiguration(GetTextString(TEXTSTRING_PREVIOUSGAME_FILENAME));
3040
3041
3042 AvP.Difficulty = 1;
3043
3044 if (DirectPlay_HostGame(MP_PlayerName,MP_SessionName,MP_Species,netGameData.gameType,netGameData.levelNumber))
3045 {
3046 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
3047 if(netGameData.gameType==NGT_Coop)
3048 SetLevelToLoadForCooperative(netGameData.levelNumber);
3049 else
3050 SetLevelToLoadForMultiplayer(netGameData.levelNumber);
3051
3052
3053 SetBriefingTextForMultiplayer();
3054
3055 }
3056 }
3057 break;
3058 }
3059 case AVPMENU_ELEMENT_JOINMPGAME:
3060 {
3061 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3062 {
3063 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
3064 netGameData.myStartFlag = 1;
3065 // netGameData.myGameState = NGS_Playing;
3066 if(netGameData.gameType==NGT_Coop)
3067 SetLevelToLoadForCooperative(netGameData.levelNumber);
3068 else
3069 SetLevelToLoadForMultiplayer(netGameData.levelNumber);
3070 SetBriefingTextForMultiplayer();
3071 }
3072 break;
3073 }
3074 case AVPMENU_ELEMENT_LISTCHOICE:
3075 {
3076 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3077 {
3078 extern char MP_PlayerName[];
3079 extern char MP_SessionName[];
3080 int s = AvPMenus.CurrentlySelectedElement;
3081
3082 if(SessionData[s].AllowedToJoin)
3083 {
3084 //copy the session name , leaving of the player count information
3085 char * braket_pos;
3086 strcpy(MP_SessionName,SessionData[s].Name);
3087
3088 braket_pos=strrchr(MP_SessionName,'(');
3089 if(braket_pos) *braket_pos=0;
3090
3091 if(DirectPlay_ConnectToSession(s,MP_PlayerName))
3092 SetupNewMenu(elementPtr->b.MenuToGoTo);
3093 }
3094 }
3095 break;
3096 }
3097 case AVPMENU_ELEMENT_JOINLOBBIED :
3098 {
3099 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3100 {
3101 //save profile , so that multiplayer name is remembered
3102 SaveUserProfile(UserProfilePtr);
3103
3104 InitAVPNetGameForJoin();
3105 SetupNewMenu(elementPtr->b.MenuToGoTo);
3106 }
3107 break;
3108 }
3109
3110 case AVPMENU_ELEMENT_LOADMPCONFIG:
3111 {
3112 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3113 {
3114 LoadMultiplayerConfigurationByIndex(AvPMenus.CurrentlySelectedElement);
3115 SetupNewMenu(elementPtr->b.MenuToGoTo);
3116 }
3117 break;
3118 }
3119
3120 case AVPMENU_ELEMENT_LOADIPADDRESS:
3121 {
3122 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3123 {
3124 LoadIPAddress(elementPtr->c.TextPtr);
3125 SetupNewMenu(elementPtr->b.MenuToGoTo);
3126 }
3127 break;
3128 }
3129
3130 case AVPMENU_ELEMENT_CONNECTIONCHOICE :
3131 {
3132 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3133 {
3134 netGameData.connectionType=elementPtr->c.Value;
3135 if(netGameData.connectionType == CONN_Mplayer)
3136 {
3137 //exit the game and launch the mplayer stuff
3138 fprintf(stderr, "STUB: InteractWithMenuElement (launching mplayer...)\n");
3139 #if 0
3140 LaunchingMplayer=TRUE;
3141 LaunchMplayer();
3142 #endif
3143 AvP.MainLoopRunning = 0;
3144 AvPMenus.MenusState = MENUSSTATE_OUTSIDEMENUS;
3145 break;
3146 }
3147 else
3148 {
3149 SetupNewMenu(elementPtr->b.MenuToGoTo);
3150 }
3151
3152 }
3153 break;
3154 }
3155
3156 case AVPMENU_ELEMENT_VIDEOMODE:
3157 {
3158 if ((interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3159 ||(interactionID == AVPMENU_ELEMENT_INTERACTION_INCREASE))
3160 {
3161 NextVideoMode2();
3162 }
3163 else
3164 {
3165 PreviousVideoMode2();
3166 }
3167 break;
3168 }
3169 case AVPMENU_ELEMENT_VIDEOMODEOK:
3170 {
3171 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3172 {
3173 SaveDeviceAndVideoModePreferences();
3174 SetupNewMenu(elementPtr->b.MenuToGoTo);
3175 }
3176 break;
3177 }
3178 case AVPMENU_ELEMENT_RESUMEGAME:
3179 {
3180 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3181 {
3182 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
3183 }
3184 break;
3185 }
3186 case AVPMENU_ELEMENT_RESTARTGAME:
3187 {
3188 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3189 {
3190 AvP.RestartLevel=1;
3191 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
3192 }
3193 break;
3194 }
3195
3196 case AVPMENU_ELEMENT_KEYCONFIG:
3197 {
3198 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3199 {
3200 AvPMenus.UserChangingKeyConfig = 1;
3201 if (KeyConfigSelectionColumn)
3202 {
3203 AvPMenus.ChangingPrimaryConfig = 0;
3204 }
3205 else
3206 {
3207 AvPMenus.ChangingPrimaryConfig = 1;
3208 }
3209 }
3210 else
3211 {
3212 KeyConfigSelectionColumn=!KeyConfigSelectionColumn;
3213 }
3214 break;
3215 }
3216 case AVPMENU_ELEMENT_KEYCONFIGOK:
3217 {
3218 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3219 {
3220 switch (AvPMenus.CurrentMenu)
3221 {
3222 case AVPMENU_MARINEKEYCONFIG:
3223 {
3224 MarineInputPrimaryConfig = PlayerInputPrimaryConfig;
3225 MarineInputSecondaryConfig = PlayerInputSecondaryConfig;
3226 {
3227 extern int AutoWeaponChangeOn_Temp;
3228 extern int AutoWeaponChangeOn;
3229 AutoWeaponChangeOn = AutoWeaponChangeOn_Temp;
3230 }
3231 break;
3232 }
3233 case AVPMENU_PREDATORKEYCONFIG:
3234 {
3235 PredatorInputPrimaryConfig = PlayerInputPrimaryConfig;
3236 PredatorInputSecondaryConfig = PlayerInputSecondaryConfig;
3237 break;
3238 }
3239 case AVPMENU_ALIENKEYCONFIG:
3240 {
3241 AlienInputPrimaryConfig = PlayerInputPrimaryConfig;
3242 AlienInputSecondaryConfig = PlayerInputSecondaryConfig;
3243 break;
3244 }
3245 case AVPMENU_CONTROLS:
3246 {
3247 ControlMethods = PlayerControlMethods;
3248 break;
3249 }
3250 case AVPMENU_JOYSTICKCONTROLS:
3251 {
3252 JoystickControlMethods = PlayerJoystickControlMethods;
3253 break;
3254 }
3255
3256 default:
3257 break;
3258 }
3259
3260
3261 SaveUserProfile(UserProfilePtr);
3262
3263 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
3264 {
3265 SetupNewMenu(AVPMENU_INGAME);
3266 }
3267 else
3268 {
3269 SetupNewMenu(AVPMENU_OPTIONS);
3270 }
3271 }
3272 break;
3273 }
3274 case AVPMENU_ELEMENT_RESETKEYCONFIG:
3275 {
3276 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3277 {
3278 switch (AvPMenus.CurrentMenu)
3279 {
3280 case AVPMENU_MARINEKEYCONFIG:
3281 {
3282 PlayerInputPrimaryConfig = DefaultMarineInputPrimaryConfig;
3283 PlayerInputSecondaryConfig = DefaultMarineInputSecondaryConfig;
3284 break;
3285 }
3286 case AVPMENU_PREDATORKEYCONFIG:
3287 {
3288 PlayerInputPrimaryConfig = DefaultPredatorInputPrimaryConfig;
3289 PlayerInputSecondaryConfig = DefaultPredatorInputSecondaryConfig;
3290 break;
3291 }
3292 case AVPMENU_ALIENKEYCONFIG:
3293 {
3294 PlayerInputPrimaryConfig = DefaultAlienInputPrimaryConfig;
3295 PlayerInputSecondaryConfig = DefaultAlienInputSecondaryConfig;
3296 break;
3297 }
3298 case AVPMENU_CONTROLS:
3299 {
3300 PlayerControlMethods = DefaultControlMethods;
3301 break;
3302 }
3303 case AVPMENU_JOYSTICKCONTROLS:
3304 {
3305 PlayerJoystickControlMethods = DefaultJoystickControlMethods;
3306 break;
3307 }
3308
3309 default:
3310 break;
3311 }
3312 }
3313 break;
3314 }
3315
3316 case AVPMENU_ELEMENT_RESETMPCONFIG :
3317 {
3318 //reset the multiplayer configuration
3319 extern void SetDefaultMultiplayerConfig();
3320 SetDefaultMultiplayerConfig();
3321 break;
3322 }
3323
3324 case AVPMENU_ELEMENT_SAVESETTINGS:
3325 {
3326 if (interactionID == AVPMENU_ELEMENT_INTERACTION_SELECT)
3327 {
3328 SetDetailLevelsFromMenu();
3329 SaveUserProfile(UserProfilePtr);
3330
3331 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
3332 {
3333 if(AvPMenus.CurrentMenu == AVPMENU_DETAILLEVELS)
3334 {
3335 SetupNewMenu(AVPMENU_INGAMEAVOPTIONS);
3336 }
3337 else
3338 {
3339 SetupNewMenu(AVPMENU_INGAME);
3340 }
3341 }
3342 else
3343 {
3344 SetupNewMenu(AvPMenusData[AvPMenus.CurrentMenu].ParentMenu);
3345 }
3346 }
3347 break;
3348 }
3349
3350 case AVPMENU_ELEMENT_LOADGAME:
3351 {
3352 int slot = AvPMenus.CurrentlySelectedElement;
3353 if(slot>=0 && slot<NUMBER_OF_SAVE_SLOTS)
3354 {
3355 if(SaveGameSlot[slot].SlotUsed)
3356 {
3357 //set the request
3358 LoadGameRequest = slot;
3359 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
3360 {
3361 //leave the menus
3362 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
3363 }
3364 }
3365 }
3366 break;
3367 }
3368 case AVPMENU_ELEMENT_SAVEGAME:
3369 {
3370 int slot = AvPMenus.CurrentlySelectedElement;
3371 if(slot>=0 && slot<NUMBER_OF_SAVE_SLOTS)
3372 {
3373 //set the request
3374 SaveGameRequest = slot;
3375 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
3376 {
3377 //leave the menus
3378 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
3379 }
3380 }
3381 break;
3382 }
3383 }
3384 }
3385
3386
3387 int LengthOfMenuText(char *textPtr);
3388 int LengthOfSmallMenuText(char *textPtr);
3389
RenderMenuElement(AVPMENU_ELEMENT * elementPtr,int e,int y)3390 static void RenderMenuElement(AVPMENU_ELEMENT *elementPtr, int e, int y)
3391 {
3392 int (*RenderText)(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format);
3393 int (*RenderText_Coloured)(char *textPtr, int x, int y, int alpha, enum AVPMENUFORMAT_ID format, int r, int g, int b);
3394 int (*MenuTextLength)(char *textPtr);
3395
3396 if (AvPMenus.FontToUse==AVPMENU_FONT_BIG)
3397 {
3398 RenderText = RenderMenuText;
3399 MenuTextLength = LengthOfMenuText;
3400 }
3401 else
3402 {
3403 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
3404 {
3405 RenderText = Hardware_RenderSmallMenuText;
3406 RenderText_Coloured = Hardware_RenderSmallMenuText_Coloured;
3407
3408 }
3409 else
3410 {
3411 RenderText = RenderSmallMenuText;
3412 RenderText_Coloured = RenderSmallMenuText_Coloured;
3413 }
3414 MenuTextLength = LengthOfSmallMenuText;
3415 }
3416
3417 switch(elementPtr->ElementID)
3418 {
3419 default:
3420 GLOBALASSERT("UNKNOWN MENU ELEMENT"==0);
3421 case AVPMENU_ELEMENT_GOTOMENU:
3422 case AVPMENU_ELEMENT_QUITGAME:
3423 case AVPMENU_ELEMENT_STARTMPGAME:
3424 case AVPMENU_ELEMENT_JOINMPGAME:
3425 case AVPMENU_ELEMENT_VIDEOMODEOK:
3426 case AVPMENU_ELEMENT_RESUMEGAME:
3427 case AVPMENU_ELEMENT_RESTARTGAME:
3428 case AVPMENU_ELEMENT_KEYCONFIGOK:
3429 case AVPMENU_ELEMENT_RESETKEYCONFIG:
3430 case AVPMENU_ELEMENT_STARTMARINEDEMO:
3431 case AVPMENU_ELEMENT_STARTPREDATORDEMO:
3432 case AVPMENU_ELEMENT_STARTALIENDEMO:
3433 case AVPMENU_ELEMENT_STARTLEVELWITHCHEAT:
3434 case AVPMENU_ELEMENT_SAVEMPCONFIG:
3435 case AVPMENU_ELEMENT_DIFFICULTYLEVEL:
3436 case AVPMENU_ELEMENT_JOINLOBBIED:
3437 case AVPMENU_ELEMENT_CONNECTIONCHOICE :
3438 case AVPMENU_ELEMENT_USERPROFILE_DELETE:
3439 case AVPMENU_ELEMENT_RESETMPCONFIG:
3440 case AVPMENU_ELEMENT_DELETEMPCONFIG:
3441 case AVPMENU_ELEMENT_SAVESETTINGS:
3442 {
3443 char *textPtr = GetTextString(elementPtr->a.TextDescription);
3444 RenderText(textPtr,MENU_CENTREX,y,elementPtr->Brightness,AVPMENUFORMAT_CENTREJUSTIFIED);
3445 break;
3446 }
3447 #if 0
3448 case AVPMENU_ELEMENT_STARTALIENGAME:
3449 case AVPMENU_ELEMENT_STARTMARINEGAME:
3450 case AVPMENU_ELEMENT_STARTPREDATORGAME:
3451 {
3452 char *textPtr = GetTextString(elementPtr->a.TextDescription);
3453 RenderText(textPtr,MENU_LEFTXEDGE,MENU_BOTTOMYEDGE,elementPtr->Brightness,AVPMENUFORMAT_LEFTJUSTIFIED);
3454 break;
3455 }
3456
3457 case AVPMENU_ELEMENT_MARINEEPISODE:
3458 case AVPMENU_ELEMENT_ALIENEPISODE:
3459 case AVPMENU_ELEMENT_PREDATOREPISODE:
3460 {
3461 char *textPtr = GetTextString(elementPtr->a.TextDescription+*(elementPtr->SliderValuePtr));
3462 RenderText(textPtr,MENU_LEFTXEDGE,MENU_TOPYEDGE,elementPtr->Brightness,AVPMENUFORMAT_LEFTJUSTIFIED);
3463 break;
3464 }
3465 #endif
3466
3467 case AVPMENU_ELEMENT_DUMMYTEXTSLIDER:
3468 case AVPMENU_ELEMENT_DUMMYTEXTSLIDER_POINTER:
3469 case AVPMENU_ELEMENT_TEXTSLIDER:
3470 case AVPMENU_ELEMENT_TEXTSLIDER_POINTER:
3471 case AVPMENU_ELEMENT_SPECIES_TEXTSLIDER:
3472 case AVPMENU_ELEMENT_CHEATMODE_TEXTSLIDER:
3473 case AVPMENU_ELEMENT_CHEATMODE_SPECIES_TEXTSLIDER:
3474 case AVPMENU_ELEMENT_CHEATMODE_ENVIRONMENT_TEXTSLIDER:
3475 {
3476 char *textPtr = "";
3477 if(elementPtr->ElementID == AVPMENU_ELEMENT_TEXTSLIDER_POINTER ||
3478 elementPtr->ElementID == AVPMENU_ELEMENT_DUMMYTEXTSLIDER_POINTER)
3479 {
3480 //we have a pointer to the strings rather than the first string index
3481 if(elementPtr->d.TextSliderStringPointer)
3482 {
3483 textPtr = elementPtr->d.TextSliderStringPointer[*(elementPtr->c.SliderValuePtr)];
3484 }
3485 }
3486 else
3487 {
3488 //we have the index of the first string
3489 textPtr = GetTextString(elementPtr->d.FirstTextSliderString+*(elementPtr->c.SliderValuePtr));
3490 }
3491
3492 if(elementPtr->a.TextDescription!=TEXTSTRING_BLANK)
3493 {
3494
3495 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
3496 {
3497 RenderText
3498 (
3499 GetTextString(elementPtr->a.TextDescription),
3500 MENU_CENTREX-MENU_ELEMENT_SPACING,
3501 y,
3502 elementPtr->Brightness,
3503 AVPMENUFORMAT_RIGHTJUSTIFIED
3504 );
3505 RenderText
3506 (
3507 textPtr,
3508 MENU_CENTREX+MENU_ELEMENT_SPACING,
3509 y,
3510 elementPtr->Brightness,
3511 AVPMENUFORMAT_LEFTJUSTIFIED
3512 );
3513
3514 }
3515 else
3516 {
3517 int length = MenuTextLength(textPtr);
3518
3519 if (length>(ScreenDescriptorBlock.SDB_Width-MENU_CENTREX-MENU_ELEMENT_SPACING*2))
3520 {
3521 RenderText
3522 (
3523 GetTextString(elementPtr->a.TextDescription),
3524 ScreenDescriptorBlock.SDB_Width-MENU_ELEMENT_SPACING*2-length,
3525 y,
3526 elementPtr->Brightness,
3527 AVPMENUFORMAT_RIGHTJUSTIFIED
3528 );
3529 RenderText
3530 (
3531 textPtr,
3532 ScreenDescriptorBlock.SDB_Width-MENU_ELEMENT_SPACING,
3533 y,
3534 elementPtr->Brightness,
3535 AVPMENUFORMAT_RIGHTJUSTIFIED
3536 );
3537 }
3538 else
3539 {
3540
3541 RenderText
3542 (
3543 GetTextString(elementPtr->a.TextDescription),
3544 MENU_CENTREX-MENU_ELEMENT_SPACING,
3545 y,
3546 elementPtr->Brightness,
3547 AVPMENUFORMAT_RIGHTJUSTIFIED
3548 );
3549 RenderText
3550 (
3551 textPtr,
3552 MENU_CENTREX+MENU_ELEMENT_SPACING,
3553 y,
3554 elementPtr->Brightness,
3555 AVPMENUFORMAT_LEFTJUSTIFIED
3556 );
3557 }
3558 }
3559 }
3560 else
3561 {
3562 RenderText
3563 (
3564 textPtr,
3565 MENU_CENTREX,
3566 y,
3567 elementPtr->Brightness,
3568 AVPMENUFORMAT_CENTREJUSTIFIED
3569 );
3570 }
3571 break;
3572 }
3573 case AVPMENU_ELEMENT_DUMMYTEXTFIELD:
3574 case AVPMENU_ELEMENT_TEXTFIELD:
3575 {
3576 if (elementPtr->a.TextDescription==TEXTSTRING_BLANK)
3577 {
3578 if (AvPMenus.UserEnteringText && e==AvPMenus.CurrentlySelectedElement)
3579 {
3580 int b = GetSin(CloakingPhase&4095);
3581 int x = RenderText(elementPtr->c.TextPtr,MENU_CENTREX,y,elementPtr->Brightness/2,AVPMENUFORMAT_CENTREJUSTIFIED);
3582 x = RenderText("I",x,y,MUL_FIXED(b,b),AVPMENUFORMAT_CENTREJUSTIFIED);
3583
3584 //work out how much space was left over
3585 if(AvPMenus.PositionInTextField)
3586 AvPMenus.WidthLeftForText = MENU_RIGHTXEDGE -x;
3587 else
3588 AvPMenus.WidthLeftForText = MENU_RIGHTXEDGE -MENU_CENTREX;
3589 }
3590 else
3591 {
3592 RenderText(elementPtr->c.TextPtr,MENU_CENTREX,y,elementPtr->Brightness,AVPMENUFORMAT_CENTREJUSTIFIED);
3593 }
3594 }
3595 else
3596 {
3597 RenderText(GetTextString(elementPtr->a.TextDescription),MENU_CENTREX-MENU_ELEMENT_SPACING,y,elementPtr->Brightness,AVPMENUFORMAT_RIGHTJUSTIFIED);
3598
3599 if (AvPMenus.UserEnteringText && e==AvPMenus.CurrentlySelectedElement)
3600 {
3601 int b = GetSin(CloakingPhase&4095);
3602 int x = RenderText(elementPtr->c.TextPtr,MENU_CENTREX+MENU_ELEMENT_SPACING,y,elementPtr->Brightness/2,AVPMENUFORMAT_LEFTJUSTIFIED);
3603 x = RenderText("I",x,y,MUL_FIXED(b,b),AVPMENUFORMAT_LEFTJUSTIFIED);
3604
3605 //work out how much space was left over
3606 if(AvPMenus.PositionInTextField)
3607 AvPMenus.WidthLeftForText = MENU_RIGHTXEDGE -x;
3608 else
3609 AvPMenus.WidthLeftForText = MENU_RIGHTXEDGE -(MENU_CENTREX+MENU_ELEMENT_SPACING);
3610 }
3611 else
3612 {
3613 RenderText(elementPtr->c.TextPtr,MENU_CENTREX+MENU_ELEMENT_SPACING,y,elementPtr->Brightness,AVPMENUFORMAT_LEFTJUSTIFIED);
3614 }
3615 }
3616 break;
3617 }
3618
3619 case AVPMENU_ELEMENT_TEXTFIELD_SMALLWRAPPED:
3620 {
3621 if (elementPtr->a.TextDescription==TEXTSTRING_BLANK)
3622 {
3623 RECT area;
3624 area.left=MENU_LEFTXEDGE;
3625 area.right=MENU_RIGHTXEDGE;
3626 area.top=y;
3627 area.bottom=y+4*HUD_FONT_HEIGHT;
3628
3629 if (AvPMenus.UserEnteringText && e==AvPMenus.CurrentlySelectedElement)
3630 {
3631 int output_x,output_y;
3632 int b = GetSin(CloakingPhase&4095);
3633 RenderSmallFontString_Wrapped(elementPtr->c.TextPtr,&area,elementPtr->Brightness/2,&output_x,&output_y);
3634 output_x = RenderSmallMenuText("I",output_x,output_y,MUL_FIXED(b,b),AVPMENUFORMAT_LEFTJUSTIFIED);
3635
3636 //work out how much space was left over
3637 if(area.bottom - output_y < HUD_FONT_HEIGHT)
3638 {
3639 //no space left
3640 AvPMenus.WidthLeftForText= 0;
3641 }
3642 else if(area.bottom - output_y >= 2*HUD_FONT_HEIGHT)
3643 {
3644 //at least a whole line left
3645 AvPMenus.WidthLeftForText= area.right-area.left;
3646 }
3647 else
3648 {
3649 //on the last line
3650 AvPMenus.WidthLeftForText= area.right-output_x;
3651 }
3652 }
3653 else
3654 {
3655 RenderSmallFontString_Wrapped(elementPtr->c.TextPtr,&area,elementPtr->Brightness,0,0);
3656 }
3657 }
3658 else
3659 {
3660 RECT area;
3661 area.left=MENU_CENTREX+MENU_ELEMENT_SPACING;
3662 area.right=MENU_RIGHTXEDGE;
3663 area.top=y;
3664 area.bottom=y+4*HUD_FONT_HEIGHT;
3665
3666 RenderText(GetTextString(elementPtr->a.TextDescription),MENU_CENTREX-MENU_ELEMENT_SPACING,y+HUD_FONT_HEIGHT,elementPtr->Brightness,AVPMENUFORMAT_RIGHTJUSTIFIED);
3667
3668 if (AvPMenus.UserEnteringText && e==AvPMenus.CurrentlySelectedElement)
3669 {
3670 int output_x,output_y;
3671 int b = GetSin(CloakingPhase&4095);
3672 RenderSmallFontString_Wrapped(elementPtr->c.TextPtr,&area,elementPtr->Brightness/2,&output_x,&output_y);
3673 output_x = RenderSmallMenuText("I",output_x,output_y,MUL_FIXED(b,b),AVPMENUFORMAT_LEFTJUSTIFIED);
3674
3675 //work out how much space was left over
3676 if(area.bottom - output_y < HUD_FONT_HEIGHT)
3677 {
3678 //no space left
3679 AvPMenus.WidthLeftForText= 0;
3680 }
3681 else if(area.bottom - output_y >= 2*HUD_FONT_HEIGHT)
3682 {
3683 //at least a whole line left
3684 AvPMenus.WidthLeftForText= area.right-area.left;
3685 }
3686 else
3687 {
3688 //on the last line
3689 AvPMenus.WidthLeftForText= area.right-output_x;
3690 }
3691 }
3692 else
3693 {
3694 RenderSmallFontString_Wrapped(elementPtr->c.TextPtr,&area,elementPtr->Brightness,0,0);
3695 }
3696 }
3697 break;
3698 }
3699
3700 case AVPMENU_ELEMENT_DUMMYNUMBERFIELD:
3701 case AVPMENU_ELEMENT_NUMBERFIELD:
3702 {
3703 {
3704 static char NumberString[50];
3705 if(*elementPtr->c.NumberPtr!=0 || elementPtr->NumberFieldZeroString==TEXTSTRING_BLANK)
3706 {
3707 sprintf(NumberString,"%d",*elementPtr->c.NumberPtr);
3708 if(elementPtr->d.NumberFieldUnitsString!=TEXTSTRING_BLANK)
3709 {
3710 //add the text for the unit type
3711 strcat(NumberString," ");
3712 strcat(NumberString,GetTextString(elementPtr->d.NumberFieldUnitsString));
3713 }
3714 }
3715 else
3716 {
3717 //use the special string to represent 0
3718 sprintf(NumberString,"%s",GetTextString(elementPtr->NumberFieldZeroString));
3719 }
3720
3721 if (elementPtr->a.TextDescription==TEXTSTRING_BLANK)
3722 {
3723 if (AvPMenus.UserEnteringNumber && e==AvPMenus.CurrentlySelectedElement)
3724 {
3725 int b = GetSin(CloakingPhase&4095);
3726 int x = RenderText(NumberString,MENU_CENTREX,y,elementPtr->Brightness/2,AVPMENUFORMAT_CENTREJUSTIFIED);
3727 RenderText("I",x,y,MUL_FIXED(b,b),AVPMENUFORMAT_CENTREJUSTIFIED);
3728 }
3729 else
3730 {
3731 RenderText(NumberString,MENU_CENTREX,y,elementPtr->Brightness,AVPMENUFORMAT_CENTREJUSTIFIED);
3732 }
3733 }
3734 else
3735 {
3736 RenderText(GetTextString(elementPtr->a.TextDescription),MENU_CENTREX-MENU_ELEMENT_SPACING,y,elementPtr->Brightness,AVPMENUFORMAT_RIGHTJUSTIFIED);
3737
3738 if (AvPMenus.UserEnteringNumber && e==AvPMenus.CurrentlySelectedElement)
3739 {
3740 int b = GetSin(CloakingPhase&4095);
3741 int x = RenderText(NumberString,MENU_CENTREX+MENU_ELEMENT_SPACING,y,elementPtr->Brightness/2,AVPMENUFORMAT_LEFTJUSTIFIED);
3742 RenderText("I",x,y,MUL_FIXED(b,b),AVPMENUFORMAT_LEFTJUSTIFIED);
3743 }
3744 else
3745 {
3746 RenderText(NumberString,MENU_CENTREX+MENU_ELEMENT_SPACING,y,elementPtr->Brightness,AVPMENUFORMAT_LEFTJUSTIFIED);
3747 }
3748 }
3749 }
3750 break;
3751 }
3752
3753 case AVPMENU_ELEMENT_GOTOMENU_GFX:
3754 {
3755 DrawAvPMenuGfx(elementPtr->a.GfxID,MENU_CENTREX,y,elementPtr->Brightness,AVPMENUFORMAT_CENTREJUSTIFIED);
3756 break;
3757 }
3758 case AVPMENU_ELEMENT_LISTCHOICE:
3759 {
3760 RenderText(elementPtr->c.TextPtr,MENU_CENTREX,y,elementPtr->Brightness,AVPMENUFORMAT_CENTREJUSTIFIED);
3761 break;
3762 }
3763 case AVPMENU_ELEMENT_LOADMPCONFIG:
3764 {
3765 RenderText(elementPtr->c.TextPtr,MENU_CENTREX,y,elementPtr->Brightness,AVPMENUFORMAT_CENTREJUSTIFIED);
3766 break;
3767 }
3768 case AVPMENU_ELEMENT_LOADIPADDRESS:
3769 {
3770 RenderText(elementPtr->c.TextPtr,MENU_CENTREX,y,elementPtr->Brightness,AVPMENUFORMAT_CENTREJUSTIFIED);
3771 break;
3772 }
3773
3774 case AVPMENU_ELEMENT_TOGGLE:
3775 {
3776 break;
3777 }
3778 case AVPMENU_ELEMENT_SLIDER:
3779 {
3780 int x = MENU_CENTREX+MENU_ELEMENT_SPACING+3;
3781 x+=(201*(*elementPtr->c.SliderValuePtr))/elementPtr->b.MaxSliderValue;
3782 RenderText(GetTextString(elementPtr->a.TextDescription),MENU_CENTREX-MENU_ELEMENT_SPACING,y,elementPtr->Brightness,AVPMENUFORMAT_RIGHTJUSTIFIED);
3783 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
3784 {
3785 D3D_DrawSliderBar(MENU_CENTREX+MENU_ELEMENT_SPACING,y+1,elementPtr->Brightness);
3786 D3D_DrawSlider(x,y+4,elementPtr->Brightness);
3787 }
3788 else
3789 {
3790 DrawAvPMenuGfx(AVPMENUGFX_SLIDERBAR,MENU_CENTREX+MENU_ELEMENT_SPACING,y+1,elementPtr->Brightness,AVPMENUFORMAT_LEFTJUSTIFIED);
3791 DrawAvPMenuGfx(AVPMENUGFX_SLIDER,x,y+4,elementPtr->Brightness,AVPMENUFORMAT_LEFTJUSTIFIED);
3792 }
3793
3794
3795 break;
3796 }
3797 case AVPMENU_ELEMENT_VIDEOMODE:
3798 {
3799 /* RenderText
3800 (
3801 GetTextString(elementPtr->a.TextDescription),
3802 MENU_CENTREX-MENU_ELEMENT_SPACING,
3803 y,
3804 elementPtr->Brightness,
3805 AVPMENUFORMAT_RIGHTJUSTIFIED
3806 ); */
3807 RenderText
3808 (
3809 GetVideoModeDescription2(),
3810 MENU_CENTREX,
3811 y,
3812 elementPtr->Brightness,
3813 AVPMENUFORMAT_CENTREJUSTIFIED
3814 );
3815 RenderText
3816 (
3817 GetVideoModeDescription3(),
3818 MENU_CENTREX,
3819 y+MENU_FONT_HEIGHT+MENU_ELEMENT_SPACING,
3820 elementPtr->Brightness,
3821 AVPMENUFORMAT_CENTREJUSTIFIED
3822 );
3823 break;
3824 }
3825 case AVPMENU_ELEMENT_KEYCONFIG:
3826 {
3827 unsigned char *primaryKey = ((unsigned char*)&PlayerInputPrimaryConfig)+e-2;
3828 unsigned char *secondaryKey = ((unsigned char*)&PlayerInputSecondaryConfig)+e-2;
3829 if (e==AvPMenus.CurrentlySelectedElement)
3830 {
3831 int x,g;
3832 if (KeyConfigSelectionColumn)
3833 {
3834 x = MENU_RIGHTXEDGE;
3835 }
3836 else
3837 {
3838 x = MENU_CENTREX;
3839 }
3840 if (AvPMenus.UserChangingKeyConfig)
3841 {
3842 g = 255;
3843 }
3844 else
3845 {
3846 g = 128;
3847 }
3848
3849 if(AvPMenus.MenusState == MENUSSTATE_INGAMEMENUS)
3850 {
3851 Hardware_RenderHighlightRectangle(x-100,y-4,x+4,y+19,0,g,0);
3852 }
3853 else
3854 {
3855 RenderHighlightRectangle(x-100,y-4,x+4,y+19,0,g,0);
3856 }
3857 }
3858 if (AvPMenus.UserChangingKeyConfig && e==AvPMenus.CurrentlySelectedElement)
3859 {
3860 int b = GetSin(CloakingPhase&4095);
3861 if (AvPMenus.ChangingPrimaryConfig)
3862 {
3863 RenderText("_",MENU_CENTREX,y,MUL_FIXED(b,b),AVPMENUFORMAT_RIGHTJUSTIFIED);
3864 RenderText
3865 (
3866 GetDescriptionOfKey(*secondaryKey),
3867 MENU_RIGHTXEDGE,
3868 y,
3869 elementPtr->Brightness,
3870 AVPMENUFORMAT_RIGHTJUSTIFIED
3871 );
3872
3873 }
3874 else
3875 {
3876 RenderText
3877 (
3878 GetDescriptionOfKey(*primaryKey),
3879 MENU_CENTREX,
3880 y,
3881 elementPtr->Brightness,
3882 AVPMENUFORMAT_RIGHTJUSTIFIED
3883 );
3884 RenderText("_",MENU_RIGHTXEDGE,y,MUL_FIXED(b,b),AVPMENUFORMAT_RIGHTJUSTIFIED);
3885
3886 }
3887
3888 }
3889 else
3890 {
3891 if (MultipleAssignments[0][e-2])
3892 {
3893 RenderText_Coloured
3894 (
3895 GetDescriptionOfKey(*primaryKey),
3896 MENU_CENTREX,
3897 y,
3898 ONE_FIXED,
3899 AVPMENUFORMAT_RIGHTJUSTIFIED,
3900 ONE_FIXED,
3901 ONE_FIXED,
3902 0
3903 );
3904 }
3905 else
3906 {
3907 RenderText
3908 (
3909 GetDescriptionOfKey(*primaryKey),
3910 MENU_CENTREX,
3911 y,
3912 elementPtr->Brightness,
3913 AVPMENUFORMAT_RIGHTJUSTIFIED
3914 );
3915 }
3916 if (MultipleAssignments[1][e-2])
3917 {
3918 RenderText_Coloured
3919 (
3920 GetDescriptionOfKey(*secondaryKey),
3921 MENU_RIGHTXEDGE,
3922 y,
3923 ONE_FIXED,
3924 AVPMENUFORMAT_RIGHTJUSTIFIED,
3925 ONE_FIXED,
3926 ONE_FIXED,
3927 0
3928 );
3929 }
3930 else
3931 {
3932 RenderText
3933 (
3934 GetDescriptionOfKey(*secondaryKey),
3935 MENU_RIGHTXEDGE,
3936 y,
3937 elementPtr->Brightness,
3938 AVPMENUFORMAT_RIGHTJUSTIFIED
3939 );
3940 }
3941 }
3942
3943 RenderText
3944 (
3945 GetTextString(elementPtr->a.TextDescription),
3946 MENU_LEFTXEDGE,
3947 y,
3948 elementPtr->Brightness,
3949 AVPMENUFORMAT_LEFTJUSTIFIED
3950 );
3951
3952
3953 }
3954 }
3955 }
3956
HeightOfMenuElement(AVPMENU_ELEMENT * elementPtr)3957 static int HeightOfMenuElement(AVPMENU_ELEMENT *elementPtr)
3958 {
3959 int h = MENU_ELEMENT_SPACING;
3960
3961 switch(elementPtr->ElementID)
3962 {
3963 default:
3964 {
3965 if (AvPMenus.FontToUse==AVPMENU_FONT_BIG)
3966 {
3967 h += MENU_FONT_HEIGHT;
3968 }
3969 else
3970 {
3971 h = HUD_FONT_HEIGHT+4;
3972 }
3973 break;
3974 }
3975 case AVPMENU_ELEMENT_LOADGAME:
3976 case AVPMENU_ELEMENT_SAVEGAME:
3977 {
3978 h= HUD_FONT_HEIGHT*2+4;
3979 break;
3980 }
3981 case AVPMENU_ELEMENT_VIDEOMODE:
3982 {
3983 h += MENU_FONT_HEIGHT;
3984 h *=2;
3985 break;
3986 }
3987
3988 case AVPMENU_ELEMENT_TEXTFIELD_SMALLWRAPPED :
3989 {
3990 h+=HUD_FONT_HEIGHT*4;
3991 break;
3992 }
3993
3994 #if 0
3995 case AVPMENU_ELEMENT_STARTALIENGAME:
3996 case AVPMENU_ELEMENT_STARTMARINEGAME:
3997 case AVPMENU_ELEMENT_STARTPREDATORGAME:
3998 #endif
3999 /*
4000 case AVPMENU_ELEMENT_DUMMYTEXTFIELD:
4001 case AVPMENU_ELEMENT_TEXTFIELD:
4002 {
4003 h += MENU_FONT_HEIGHT*2;
4004 break;
4005 }
4006 */
4007
4008 case AVPMENU_ELEMENT_GOTOMENU_GFX:
4009 {
4010 h += HeightOfMenuGfx(elementPtr->a.GfxID);
4011 break;
4012 }
4013 #if 0
4014 case AVPMENU_ELEMENT_SLIDER:
4015 {
4016 h += HeightOfMenuGfx(AVPMENUGFX_SLIDER);
4017 break;
4018 }
4019 #endif
4020 }
4021 return h;
4022 }
4023
GetDescriptionOfKey(unsigned char key)4024 static char *GetDescriptionOfKey(unsigned char key)
4025 {
4026 static char KeyDescBuffer[2]="\0\0";
4027 char *textPtr;
4028
4029 switch (key)
4030 {
4031 case KEY_UP:
4032 textPtr = GetTextString(TEXTSTRING_KEYS_UP);
4033 break;
4034 case KEY_DOWN:
4035 textPtr = GetTextString(TEXTSTRING_KEYS_DOWN);
4036 break;
4037 case KEY_LEFT:
4038 textPtr = GetTextString(TEXTSTRING_KEYS_LEFT);
4039 break;
4040 case KEY_RIGHT:
4041 textPtr = GetTextString(TEXTSTRING_KEYS_RIGHT);
4042 break;
4043 case KEY_CR:
4044 textPtr = GetTextString(TEXTSTRING_KEYS_RETURN);
4045 break;
4046 case KEY_TAB:
4047 textPtr = GetTextString(TEXTSTRING_KEYS_TAB);
4048 break;
4049 case KEY_INS:
4050 textPtr = GetTextString(TEXTSTRING_KEYS_INSERT);
4051 break;
4052 case KEY_DEL:
4053 textPtr = GetTextString(TEXTSTRING_KEYS_DELETE);
4054 break;
4055 case KEY_END:
4056 textPtr = GetTextString(TEXTSTRING_KEYS_END);
4057 break;
4058 case KEY_HOME:
4059 textPtr = GetTextString(TEXTSTRING_KEYS_HOME);
4060 break;
4061 case KEY_PAGEUP:
4062 textPtr = GetTextString(TEXTSTRING_KEYS_PGUP);
4063 break;
4064 case KEY_PAGEDOWN:
4065 textPtr = GetTextString(TEXTSTRING_KEYS_PGDOWN);
4066 break;
4067 case KEY_BACKSPACE:
4068 textPtr = GetTextString(TEXTSTRING_KEYS_BACKSP);
4069 break;
4070 case KEY_COMMA:
4071 textPtr = GetTextString(TEXTSTRING_KEYS_COMMA);
4072 break;
4073 case KEY_FSTOP:
4074 textPtr = GetTextString(TEXTSTRING_KEYS_PERIOD);
4075 break;
4076 case KEY_SPACE:
4077 textPtr = GetTextString(TEXTSTRING_KEYS_SPACE);
4078 break;
4079 case KEY_LMOUSE:
4080 textPtr = GetTextString(TEXTSTRING_KEYS_LMOUSE);
4081 break;
4082 case KEY_RMOUSE:
4083 textPtr = GetTextString(TEXTSTRING_KEYS_RMOUSE);
4084 break;
4085 case KEY_MMOUSE:
4086 textPtr = GetTextString(TEXTSTRING_KEYS_MMOUSE);
4087 break;
4088 case KEY_MOUSEBUTTON4:
4089 textPtr = GetTextString(TEXTSTRING_KEYS_MOUSEBUTTON4);
4090 break;
4091 case KEY_MOUSEWHEELUP:
4092 textPtr = GetTextString(TEXTSTRING_KEYS_MOUSEWHEELUP);
4093 break;
4094 case KEY_MOUSEWHEELDOWN:
4095 textPtr = GetTextString(TEXTSTRING_KEYS_MOUSEWHEELDOWN);
4096 break;
4097 case KEY_LEFTALT:
4098 textPtr = GetTextString(TEXTSTRING_KEYS_LALT);
4099 break;
4100 case KEY_RIGHTALT:
4101 textPtr = GetTextString(TEXTSTRING_KEYS_RALT);
4102 break;
4103 case KEY_LEFTCTRL:
4104 textPtr = GetTextString(TEXTSTRING_KEYS_LCTRL);
4105 break;
4106 case KEY_RIGHTCTRL:
4107 textPtr = GetTextString(TEXTSTRING_KEYS_RCTRL);
4108 break;
4109 case KEY_LEFTSHIFT:
4110 textPtr = GetTextString(TEXTSTRING_KEYS_LSHIFT);
4111 break;
4112 case KEY_RIGHTSHIFT:
4113 textPtr = GetTextString(TEXTSTRING_KEYS_RSHIFT);
4114 break;
4115 case KEY_CAPS:
4116 textPtr = GetTextString(TEXTSTRING_KEYS_CAPS);
4117 break;
4118 case KEY_NUMLOCK:
4119 textPtr = GetTextString(TEXTSTRING_KEYS_NUMLOCK);
4120 break;
4121 case KEY_SCROLLOK:
4122 textPtr = GetTextString(TEXTSTRING_KEYS_SCRLOCK);
4123 break;
4124 case KEY_NUMPAD0:
4125 textPtr = GetTextString(TEXTSTRING_KEYS_PAD0);
4126 break;
4127 case KEY_NUMPAD1:
4128 textPtr = GetTextString(TEXTSTRING_KEYS_PAD1);
4129 break;
4130 case KEY_NUMPAD2:
4131 textPtr = GetTextString(TEXTSTRING_KEYS_PAD2);
4132 break;
4133 case KEY_NUMPAD3:
4134 textPtr = GetTextString(TEXTSTRING_KEYS_PAD3);
4135 break;
4136 case KEY_NUMPAD4:
4137 textPtr = GetTextString(TEXTSTRING_KEYS_PAD4);
4138 break;
4139 case KEY_NUMPAD5:
4140 textPtr = GetTextString(TEXTSTRING_KEYS_PAD5);
4141 break;
4142 case KEY_NUMPAD6:
4143 textPtr = GetTextString(TEXTSTRING_KEYS_PAD6);
4144 break;
4145 case KEY_NUMPAD7:
4146 textPtr = GetTextString(TEXTSTRING_KEYS_PAD7);
4147 break;
4148 case KEY_NUMPAD8:
4149 textPtr = GetTextString(TEXTSTRING_KEYS_PAD8);
4150 break;
4151 case KEY_NUMPAD9:
4152 textPtr = GetTextString(TEXTSTRING_KEYS_PAD9);
4153 break;
4154 case KEY_NUMPADSUB:
4155 textPtr = GetTextString(TEXTSTRING_KEYS_PADSUB);
4156 break;
4157 case KEY_NUMPADADD:
4158 textPtr = GetTextString(TEXTSTRING_KEYS_PADADD);
4159 break;
4160 case KEY_NUMPADDEL:
4161 textPtr = GetTextString(TEXTSTRING_KEYS_PADDEL);
4162 break;
4163 case KEY_JOYSTICK_BUTTON_1:
4164 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_1);
4165 break;
4166 case KEY_JOYSTICK_BUTTON_2:
4167 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_2);
4168 break;
4169 case KEY_JOYSTICK_BUTTON_3:
4170 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_3);
4171 break;
4172 case KEY_JOYSTICK_BUTTON_4:
4173 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_4);
4174 break;
4175 case KEY_JOYSTICK_BUTTON_5:
4176 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_5);
4177 break;
4178 case KEY_JOYSTICK_BUTTON_6:
4179 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_6);
4180 break;
4181 case KEY_JOYSTICK_BUTTON_7:
4182 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_7);
4183 break;
4184 case KEY_JOYSTICK_BUTTON_8:
4185 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_8);
4186 break;
4187 case KEY_JOYSTICK_BUTTON_9:
4188 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_9);
4189 break;
4190 case KEY_JOYSTICK_BUTTON_10:
4191 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_10);
4192 break;
4193 case KEY_JOYSTICK_BUTTON_11:
4194 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_11);
4195 break;
4196 case KEY_JOYSTICK_BUTTON_12:
4197 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_12);
4198 break;
4199 case KEY_JOYSTICK_BUTTON_13:
4200 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_13);
4201 break;
4202 case KEY_JOYSTICK_BUTTON_14:
4203 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_14);
4204 break;
4205 case KEY_JOYSTICK_BUTTON_15:
4206 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_15);
4207 break;
4208 case KEY_JOYSTICK_BUTTON_16:
4209 textPtr = GetTextString(TEXTSTRING_KEYS_JOYSTICKBUTTON_16);
4210 break;
4211 case KEY_LBRACKET:
4212 textPtr = GetTextString(TEXTSTRING_KEYS_LBRACKET);
4213 break;
4214 case KEY_RBRACKET:
4215 textPtr = GetTextString(TEXTSTRING_KEYS_RBRACKET);
4216 break;
4217 case KEY_SEMICOLON:
4218 textPtr = GetTextString(TEXTSTRING_KEYS_SEMICOLON);
4219 break;
4220 case KEY_APOSTROPHE:
4221 textPtr = GetTextString(TEXTSTRING_KEYS_APOSTROPHE);
4222 break;
4223 case KEY_GRAVE:
4224 textPtr = GetTextString(TEXTSTRING_KEYS_GRAVE);
4225 break;
4226 case KEY_BACKSLASH:
4227 textPtr = GetTextString(TEXTSTRING_KEYS_BACKSLASH);
4228 break;
4229 case KEY_SLASH:
4230 textPtr = GetTextString(TEXTSTRING_KEYS_SLASH);
4231 break;
4232 case KEY_NUMPADENTER:
4233 textPtr = GetTextString(TEXTSTRING_KEYS_NUMPADENTER);
4234 break;
4235 case KEY_NUMPADDIVIDE:
4236 textPtr = GetTextString(TEXTSTRING_KEYS_NUMPADDIVIDE);
4237 break;
4238 case KEY_NUMPADMULTIPLY:
4239 textPtr = GetTextString(TEXTSTRING_KEYS_NUMPADMULTIPLY);
4240 break;
4241 case KEY_CAPITAL:
4242 textPtr = GetTextString(TEXTSTRING_KEYS_CAPITAL);
4243 break;
4244 case KEY_MINUS:
4245 textPtr = GetTextString(TEXTSTRING_KEYS_MINUS);
4246 break;
4247 case KEY_EQUALS:
4248 textPtr = GetTextString(TEXTSTRING_KEYS_EQUALS);
4249 break;
4250 case KEY_LWIN:
4251 textPtr = GetTextString(TEXTSTRING_KEYS_LWIN);
4252 break;
4253 case KEY_RWIN:
4254 textPtr = GetTextString(TEXTSTRING_KEYS_RWIN);
4255 break;
4256 case KEY_APPS:
4257 textPtr = GetTextString(TEXTSTRING_KEYS_APPS);
4258 break;
4259 case KEY_F1:
4260 textPtr = GetTextString(TEXTSTRING_KEYS_F1);
4261 break;
4262 case KEY_F2:
4263 textPtr = GetTextString(TEXTSTRING_KEYS_F2);
4264 break;
4265 case KEY_F3:
4266 textPtr = GetTextString(TEXTSTRING_KEYS_F3);
4267 break;
4268 case KEY_F4:
4269 textPtr = GetTextString(TEXTSTRING_KEYS_F4);
4270 break;
4271 case KEY_F5:
4272 textPtr = GetTextString(TEXTSTRING_KEYS_F5);
4273 break;
4274 case KEY_F6:
4275 textPtr = GetTextString(TEXTSTRING_KEYS_F6);
4276 break;
4277 case KEY_F7:
4278 textPtr = GetTextString(TEXTSTRING_KEYS_F7);
4279 break;
4280 case KEY_F8:
4281 textPtr = GetTextString(TEXTSTRING_KEYS_F8);
4282 break;
4283 case KEY_F9:
4284 textPtr = GetTextString(TEXTSTRING_KEYS_F9);
4285 break;
4286 case KEY_F10:
4287 textPtr = GetTextString(TEXTSTRING_KEYS_F10);
4288 break;
4289 case KEY_F11:
4290 textPtr = GetTextString(TEXTSTRING_KEYS_F11);
4291 break;
4292 case KEY_F12:
4293 textPtr = GetTextString(TEXTSTRING_KEYS_F12);
4294 break;
4295
4296 case KEY_A_UMLAUT:
4297 KeyDescBuffer[0] = 196; // Windows Latin 1 (ANSI)
4298 textPtr = KeyDescBuffer;
4299 break;
4300 case KEY_O_UMLAUT:
4301 KeyDescBuffer[0] = 214; // Windows Latin 1 (ANSI)
4302 textPtr = KeyDescBuffer;
4303 break;
4304 case KEY_U_UMLAUT:
4305 KeyDescBuffer[0] = 220; // Windows Latin 1 (ANSI)
4306 textPtr = KeyDescBuffer;
4307 break;
4308 case KEY_BETA:
4309 KeyDescBuffer[0] = 223; // Windows Latin 1 (ANSI)
4310 textPtr = KeyDescBuffer;
4311 break;
4312 case KEY_PLUS:
4313 KeyDescBuffer[0] = '+'; // Windows Latin 1 (ANSI)
4314 textPtr = KeyDescBuffer;
4315 break;
4316 case KEY_HASH:
4317 KeyDescBuffer[0] = '#'; // Windows Latin 1 (ANSI)
4318 textPtr = KeyDescBuffer;
4319 break;
4320 case KEY_UPSIDEDOWNEXCLAMATION:
4321 KeyDescBuffer[0] = 161; // Windows Latin 1 (ANSI)
4322 textPtr = KeyDescBuffer;
4323 break;
4324 case KEY_C_CEDILLA:
4325 KeyDescBuffer[0] = 199; // Windows Latin 1 (ANSI)
4326 textPtr = KeyDescBuffer;
4327 break;
4328 case KEY_N_TILDE:
4329 KeyDescBuffer[0] = 209; // Windows Latin 1 (ANSI)
4330 textPtr = KeyDescBuffer;
4331 break;
4332 case KEY_RIGHTBRACKET:
4333 KeyDescBuffer[0] = ')'; // Windows Latin 1 (ANSI)
4334 textPtr = KeyDescBuffer;
4335 break;
4336 case KEY_ASTERISK:
4337 KeyDescBuffer[0] = '*'; // Windows Latin 1 (ANSI)
4338 textPtr = KeyDescBuffer;
4339 break;
4340 case KEY_DOLLAR:
4341 KeyDescBuffer[0] = '$'; // Windows Latin 1 (ANSI)
4342 textPtr = KeyDescBuffer;
4343 break;
4344 case KEY_U_GRAVE:
4345 KeyDescBuffer[0] = 217; // Windows Latin 1 (ANSI)
4346 textPtr = KeyDescBuffer;
4347 break;
4348 case KEY_EXCLAMATION:
4349 KeyDescBuffer[0] = '!'; // Windows Latin 1 (ANSI)
4350 textPtr = KeyDescBuffer;
4351 break;
4352 case KEY_COLON:
4353 KeyDescBuffer[0] = ':';
4354 textPtr = KeyDescBuffer;
4355 break;
4356 case KEY_DIACRITIC_GRAVE:
4357 KeyDescBuffer[0] = 96; // Windows Latin 1 (ANSI)
4358 textPtr = KeyDescBuffer;
4359 break;
4360 case KEY_DIACRITIC_ACUTE:
4361 KeyDescBuffer[0] = 180; // Windows Latin 1 (ANSI)
4362 textPtr = KeyDescBuffer;
4363 break;
4364 case KEY_DIACRITIC_CARET:
4365 KeyDescBuffer[0] = '^'; // Windows Latin 1 (ANSI)
4366 textPtr = KeyDescBuffer;
4367 break;
4368 case KEY_DIACRITIC_UMLAUT:
4369 KeyDescBuffer[0] = 168; // Windows Latin 1 (ANSI)
4370 textPtr = KeyDescBuffer;
4371 break;
4372 case KEY_ORDINAL:
4373 KeyDescBuffer[0] = 186; // Windows Latin 1 (ANSI)
4374 textPtr = KeyDescBuffer;
4375 break;
4376 case KEY_LESSTHAN:
4377 KeyDescBuffer[0] = '<'; // Windows Latin 1 (ANSI)
4378 textPtr = KeyDescBuffer;
4379 break;
4380
4381 case KEY_VOID:
4382 KeyDescBuffer[0] = 0;
4383 textPtr = KeyDescBuffer;
4384 break;
4385
4386
4387 default: // alpha-numeric case
4388 {
4389 if (key >= KEY_A && key <= KEY_Z)
4390 {
4391 KeyDescBuffer[0] = key - KEY_A + 'A';
4392 }
4393 else if (key >= KEY_0 && key <= KEY_9)
4394 {
4395 KeyDescBuffer[0] = key - KEY_0 + '0';
4396 }
4397 else // um, no idea - send blank
4398 {
4399 KeyDescBuffer[0] = 0;
4400 }
4401 textPtr = KeyDescBuffer;
4402 break;
4403 }
4404
4405 }
4406 return textPtr;
4407 }
4408
OkayToPlayNextEpisode(void)4409 static int OkayToPlayNextEpisode(void)
4410 {
4411 switch(AvP.PlayerType)
4412 {
4413 default:
4414 GLOBALASSERT(0);
4415 case I_Marine:
4416 {
4417 if (UserProfilePtr->LevelCompleted[AvP.PlayerType][MarineEpisodeToPlay] < AvP.Difficulty+1)
4418 {
4419 UserProfilePtr->LevelCompleted[AvP.PlayerType][MarineEpisodeToPlay]=AvP.Difficulty+1;
4420 }
4421 SaveUserProfile(UserProfilePtr);
4422 SetupNewMenu(AVPMENU_MARINELEVELS);
4423 return 1;
4424 #if 0
4425 if (MarineEpisodeToPlay<MAX_NO_OF_BASIC_MARINE_EPISODES-1)
4426 {
4427 MarineEpisodeToPlay++;
4428 SetLevelToLoadForMarine(MarineEpisodeToPlay);
4429 return 1;
4430 }
4431 #endif
4432 break;
4433 }
4434 case I_Predator:
4435 {
4436 if (UserProfilePtr->LevelCompleted[AvP.PlayerType][PredatorEpisodeToPlay] < AvP.Difficulty+1)
4437 {
4438 UserProfilePtr->LevelCompleted[AvP.PlayerType][PredatorEpisodeToPlay]=AvP.Difficulty+1;
4439 }
4440 SaveUserProfile(UserProfilePtr);
4441 SetupNewMenu(AVPMENU_PREDATORLEVELS);
4442 return 1;
4443 #if 0
4444 if (PredatorEpisodeToPlay<MAX_NO_OF_BASIC_PREDATOR_EPISODES-1)
4445 {
4446 PredatorEpisodeToPlay++;
4447 SetLevelToLoadForPredator(PredatorEpisodeToPlay);
4448 return 1;
4449 }
4450 #endif
4451 break;
4452 }
4453 case I_Alien:
4454 {
4455 if (UserProfilePtr->LevelCompleted[AvP.PlayerType][AlienEpisodeToPlay] < AvP.Difficulty+1)
4456 {
4457 UserProfilePtr->LevelCompleted[AvP.PlayerType][AlienEpisodeToPlay]=AvP.Difficulty+1;
4458 }
4459 SaveUserProfile(UserProfilePtr);
4460 SetupNewMenu(AVPMENU_ALIENLEVELS);
4461 return 1;
4462 #if 0
4463 if (AlienEpisodeToPlay<MAX_NO_OF_BASIC_ALIEN_EPISODES-1)
4464 {
4465 AlienEpisodeToPlay++;
4466 SetLevelToLoadForAlien(AlienEpisodeToPlay);
4467 return 1;
4468 }
4469 #endif
4470 break;
4471 }
4472 }
4473 return 0;
4474
4475 }
4476
4477
4478
NumberOfAvailableLevels(I_PLAYER_TYPE playerID)4479 int NumberOfAvailableLevels(I_PLAYER_TYPE playerID)
4480 {
4481 int i=0;
4482 int maximumLevel;
4483 int numberOfBasicLevels;
4484 int maxDifficulty=0x7fffffff;
4485
4486 switch(playerID)
4487 {
4488 case I_Marine:
4489 {
4490 maximumLevel = MAX_NO_OF_MARINE_EPISODES-1;
4491 numberOfBasicLevels = MAX_NO_OF_BASIC_MARINE_EPISODES-1;
4492 break;
4493 }
4494 case I_Predator:
4495 {
4496 maximumLevel = MAX_NO_OF_PREDATOR_EPISODES-1;
4497 numberOfBasicLevels = MAX_NO_OF_BASIC_PREDATOR_EPISODES-1;
4498 break;
4499 }
4500 case I_Alien:
4501 {
4502 maximumLevel = MAX_NO_OF_ALIEN_EPISODES-1;
4503 numberOfBasicLevels = MAX_NO_OF_BASIC_ALIEN_EPISODES-1;
4504 break;
4505 }
4506 }
4507
4508 #if 0 // force all level access
4509 while (i<maximumLevel && (UserProfilePtr->LevelCompleted[playerID][i]=3))
4510 i++;
4511 UserProfilePtr->LevelCompleted[playerID][i]=3;
4512 #else
4513
4514 while (i<numberOfBasicLevels && UserProfilePtr->LevelCompleted[playerID][i])
4515 i++;
4516
4517 MaximumSelectableLevel = i;
4518 {
4519 int l;
4520 for (l=0; l<=numberOfBasicLevels; l++)
4521 {
4522 if (UserProfilePtr->LevelCompleted[playerID][l]<maxDifficulty)
4523 {
4524 maxDifficulty = UserProfilePtr->LevelCompleted[playerID][l];
4525 }
4526 }
4527 switch(maxDifficulty)
4528 {
4529 case AVP_DIFFICULTY_LEVEL_EASY:
4530 {
4531 MaximumSelectableLevel = maximumLevel-3;
4532 i = maximumLevel;
4533 break;
4534 }
4535 case AVP_DIFFICULTY_LEVEL_MEDIUM:
4536 {
4537 MaximumSelectableLevel = maximumLevel-1;
4538 i = maximumLevel;
4539 break;
4540 }
4541 case AVP_DIFFICULTY_LEVEL_HARD:
4542 {
4543 MaximumSelectableLevel = maximumLevel;
4544 i = maximumLevel;
4545 break;
4546 }
4547 default:
4548 break;
4549 }
4550 }
4551 //while (i<maximumLevel && (UserProfilePtr->LevelCompleted[playerID][i]!=0))
4552 // i++;
4553 #endif
4554
4555 return i;
4556 }
LevelMostLikelyToPlay(I_PLAYER_TYPE playerID)4557 int LevelMostLikelyToPlay(I_PLAYER_TYPE playerID)
4558 {
4559 int i=0;
4560 int maximumLevel;
4561
4562 switch(playerID)
4563 {
4564 case I_Marine:
4565 {
4566 maximumLevel = MAX_NO_OF_MARINE_EPISODES-1;
4567 break;
4568 }
4569 case I_Predator:
4570 {
4571 maximumLevel = MAX_NO_OF_PREDATOR_EPISODES-1;
4572 break;
4573 }
4574 case I_Alien:
4575 {
4576 maximumLevel = MAX_NO_OF_ALIEN_EPISODES-1;
4577 break;
4578 }
4579 }
4580
4581 while (i<maximumLevel && (UserProfilePtr->LevelCompleted[playerID][i]!=0))
4582 i++;
4583
4584 return i;
4585 }
4586
MaxDifficultyLevelAllowed(I_PLAYER_TYPE playerID,int level)4587 int MaxDifficultyLevelAllowed(I_PLAYER_TYPE playerID, int level)
4588 {
4589 if (level == 0) return 3;
4590 else return UserProfilePtr->LevelCompleted[playerID][level-1];
4591 }
DisplayVideoModeUnavailableScreen(void)4592 void DisplayVideoModeUnavailableScreen(void)
4593 {
4594 do
4595 {
4596 CheckForWindowsMessages();
4597 DrawMainMenusBackdrop();
4598 ReadUserInput();
4599 {
4600 RECT area;
4601 //draw the attached string at the bottom of the screen
4602
4603 area.left=MENU_LEFTXEDGE;
4604 area.right=MENU_RIGHTXEDGE;
4605 area.top=0;
4606 area.bottom=ScreenDescriptorBlock.SDB_Height;
4607
4608 RenderSmallFontString_Wrapped(GetTextString(TEXTSTRING_NOTENOUGHMEMORY),&area,BRIGHTNESS_OF_HIGHLIGHTED_ELEMENT,0,0);
4609
4610 }
4611
4612 ShowMenuFrameRate();
4613
4614 FlipBuffers();
4615 FrameCounterHandler();
4616 PlayMenuMusic();
4617 }
4618 while(!DebouncedGotAnyKey);
4619 }
4620
4621
CheckForCredits(void)4622 void CheckForCredits(void)
4623 {
4624 #if 0
4625 FILE *fp = OpenGameFile("credits.txt", FILEMODE_READONLY, FILETYPE_PERM);
4626
4627 if (!fp)
4628 {
4629 char message[100];
4630 sprintf(message,"Unable to access credits.txt\n");
4631 MessageBox(NULL,message,"AvP Error",MB_OK+MB_SYSTEMMODAL);
4632 exit(0x111);
4633 return;
4634 }
4635 else
4636 {
4637 fclose(fp);
4638 }
4639 #endif
4640 }
4641
DoCredits(void)4642 void DoCredits(void)
4643 {
4644 int position = 300*2048;
4645 BOOL FinishedCredits = FALSE;
4646
4647 char *creditsBufferPtr = LoadTextFile("credits.txt");
4648 char *creditsPtr;
4649
4650 if (!creditsBufferPtr) return;
4651
4652 if (!strncmp (creditsBufferPtr, "REBCRIF1", 8))
4653 {
4654 creditsPtr = (char*)HuffmanDecompress((HuffmanPackage*)(creditsBufferPtr));
4655 DeallocateMem(creditsBufferPtr);
4656 creditsBufferPtr=creditsPtr;
4657 }
4658 else
4659 {
4660 creditsPtr = creditsBufferPtr;
4661 }
4662
4663
4664 do
4665 {
4666 CheckForWindowsMessages();
4667 DrawMainMenusBackdrop();
4668 ReadUserInput();
4669
4670 FinishedCredits = !RollCreditsText(position,creditsPtr+4);
4671 ShowMenuFrameRate();
4672
4673 FlipBuffers();
4674 FrameCounterHandler();
4675 PlayMenuMusic();
4676 position -= RealFrameTime;
4677 }
4678 while(!DebouncedGotAnyKey && !FinishedCredits);
4679
4680 UnloadTextFile("credits.txt",creditsPtr);
4681 }
4682
RollCreditsText(int position,unsigned char * textPtr)4683 BOOL RollCreditsText(int position, unsigned char *textPtr)
4684 {
4685 int y=0;
4686
4687 while(*textPtr!='#')
4688 {
4689 char buffer1[96];
4690 char buffer2[96];
4691 int i;
4692 int centredText,splitText;
4693
4694
4695 {
4696 int yy = 60+y+position/2048;
4697
4698 if (yy >= 60 && yy <= 400)
4699 {
4700 int b;
4701 {
4702 if (*textPtr=='}')
4703 {
4704 textPtr++;
4705 centredText = 1;
4706 }
4707 else
4708 {
4709 centredText = 0;
4710 }
4711
4712 for (i=0; i<80 && (*textPtr!='\r')&&(*textPtr!='\n')&&(*textPtr!='\0')&&(*textPtr!='|'); i++)
4713 {
4714 buffer1[i] = *textPtr++;
4715 // if (buffer1[i]>='a' && buffer1[i]<='z') buffer1[i] += 'A' - 'a';
4716 }
4717 buffer1[i]=0;
4718
4719 if (*textPtr=='|')
4720 {
4721 textPtr++;
4722 for (i=0; i<80 && (*textPtr!='\r')&&(*textPtr!='\n')&&(*textPtr!='\0'); i++)
4723 {
4724 buffer2[i] = *textPtr++;
4725 }
4726 buffer2[i]=0;
4727 splitText = 1;
4728 }
4729 else
4730 {
4731 splitText = 0;
4732 }
4733
4734 textPtr++;
4735 while(*textPtr=='\n') textPtr++;
4736
4737 }
4738
4739 if (yy<92)
4740 {
4741 b = (yy-60)*2048;
4742 }
4743 else if (yy>400-32)
4744 {
4745 b = (400-yy)*2048;
4746 }
4747 else
4748 {
4749 b = ONE_FIXED;
4750 }
4751
4752 if (splitText)
4753 {
4754 RenderSmallMenuText(buffer1,MENU_CENTREX-MENU_ELEMENT_SPACING,yy,b,AVPMENUFORMAT_RIGHTJUSTIFIED);
4755 RenderSmallMenuText(buffer2,MENU_CENTREX+MENU_ELEMENT_SPACING,yy,b,AVPMENUFORMAT_LEFTJUSTIFIED);
4756 }
4757 else
4758 {
4759 if (centredText)
4760 {
4761 RenderSmallMenuText(buffer1,MENU_CENTREX,yy,b,AVPMENUFORMAT_CENTREJUSTIFIED);
4762 }
4763 else
4764 {
4765 RenderSmallMenuText(buffer1,MENU_LEFTXEDGE,yy,b,AVPMENUFORMAT_LEFTJUSTIFIED);
4766 }
4767 }
4768
4769 }
4770 else
4771 {
4772 while(*textPtr++!='\n');
4773 }
4774 }
4775 y+=15;
4776 }
4777
4778 if(y+(position/2048)<0)
4779 {
4780 //finished
4781 return FALSE;
4782 }
4783 return TRUE;
4784 }
4785 /* KJL 17:50:06 24/06/98 - setup video mode for Menus */
4786
4787 extern int VideoModeTypeScreen;
4788 extern int RasterisationRequestMode;
4789 extern int VideoMode;
4790 extern int WindowMode;
4791 extern int WindowRequestMode;
4792
4793 extern int DXMemoryMode;
4794 extern int DXMemoryRequestMode;
4795
SelectMenuDisplayMode(void)4796 extern void SelectMenuDisplayMode(void)
4797 {
4798 MinimizeAllImages();
4799 TimeStampedMessage("after MinimizeAllImages");
4800 MinimizeAllDDGraphics();
4801 TimeStampedMessage("after MinimizeAllDDGraphics");
4802
4803 ReleaseDirect3DNotDDOrImages();
4804 TimeStampedMessage("after ReleaseDirect3DNotDDOrImages");
4805
4806 finiObjectsExceptDD();
4807 TimeStampedMessage("after finiObjectsExceptDD");
4808
4809 finiObjects();
4810 SelectDirectDrawObject(NULL);
4811
4812 DXMemoryRequestMode = RequestSystemMemoryAlways;
4813 DXMemoryMode = SystemMemoryPreferred;
4814
4815 RasterisationRequestMode = RequestSoftwareRasterisation;
4816 VideoMode = VideoMode_DX_640x480x15;
4817 VideoModeTypeScreen = VideoModeType_15;
4818 WindowMode = WindowRequestMode;
4819 ScreenDescriptorBlock.SDB_Width = 640;
4820 ScreenDescriptorBlock.SDB_Height = 480;
4821 ScreenDescriptorBlock.SDB_ScreenDepth = VideoModeType_15;
4822
4823 #if !(PREDATOR_DEMO||MARINE_DEMO||ALIEN_DEMO)
4824 ChangeDirectDrawObject();
4825 #endif
4826 TimeStampedMessage("after ChangeDirectDrawObject");
4827
4828 GenerateDirectDrawSurface();
4829 TimeStampedMessage("after GenerateDirectDrawSurface");
4830
4831 {
4832 extern VIEWDESCRIPTORBLOCK *Global_VDB_Ptr;
4833 Global_VDB_Ptr = 0;
4834 }
4835 }
4836
4837
4838
4839
4840
4841
4842
4843
4844
4845
4846
4847
4848
4849
4850
4851
4852
4853
4854
4855
4856
4857
4858 #if 0
4859
4860
4861
4862 struct STARDESC
4863 {
4864 int X;
4865 int Y;
4866 int Chasing;
4867 int Fleeing;
4868 };
4869 #define NUMBER_OF_STARS 128
4870
4871 struct STARDESC Star[NUMBER_OF_STARS];
4872
4873 static void DrawStar(int x, int y)
4874 {
4875 extern unsigned char *ScreenBuffer;
4876 extern long BackBufferPitch;
4877
4878 int xi,xf,xfm,yi,yf,yfm;
4879
4880 xi=x/65536;
4881 yi=y/65536;
4882 xf = x - xi*65536;
4883 yf = y - yi*65536;
4884 xfm = ONE_FIXED - xf;
4885 yfm = ONE_FIXED - yf;
4886
4887 *(unsigned short*)(ScreenBuffer + ((xi+0)*2 + (yi+0)*BackBufferPitch)) = (unsigned short)WhiteOfBrightness(MUL_FIXED(xfm,yfm));
4888 *(unsigned short*)(ScreenBuffer + ((xi+0)*2 + (yi+1)*BackBufferPitch)) = (unsigned short)WhiteOfBrightness(MUL_FIXED(xfm,yf));
4889 *(unsigned short*)(ScreenBuffer + ((xi+1)*2 + (yi+0)*BackBufferPitch)) = (unsigned short)WhiteOfBrightness(MUL_FIXED(xf,yfm));
4890 *(unsigned short*)(ScreenBuffer + ((xi+1)*2 + (yi+1)*BackBufferPitch)) = (unsigned short)WhiteOfBrightness(MUL_FIXED(xf,yf));
4891
4892 }
4893 #endif
4894
InitMainMenusBackdrop(void)4895 static void InitMainMenusBackdrop(void)
4896 {
4897 #if 0
4898 int i;
4899 for(i=0; i<NUMBER_OF_STARS; i++)
4900 {
4901 Star[i].X = (FastRandom()&65535)*640;
4902 Star[i].Y = (FastRandom()&65535)*480;
4903 Star[i].Chasing = (FastRandom()&127);
4904 Star[i].Fleeing = (FastRandom()&127);
4905 }
4906 #endif
4907 #if 0
4908 {
4909 int x,y;
4910 for (x=0; x<128; x++)
4911 for (y=0; y<128; y++)
4912 CloudTable[x][y]=(FastRandom()&32767)+32768;
4913 }
4914 #endif
4915 StartMenuBackgroundBink();
4916 }
4917
4918
4919
DrawMainMenusBackdrop(void)4920 extern void DrawMainMenusBackdrop(void)
4921 {
4922 #if 1
4923 if (!PlayMenuBackgroundBink())
4924 {
4925 DrawAvPMenuGfx(AVPMENUGFX_BACKDROP,0,0,ONE_FIXED+1,AVPMENUFORMAT_LEFTJUSTIFIED);
4926 }
4927 else
4928 {
4929 extern unsigned char *ScreenBuffer;
4930 unsigned int *screenPtr = (unsigned int*)ScreenBuffer;
4931 int i;
4932
4933 i = ScreenDescriptorBlock.SDB_Width * 60 /2;
4934 do
4935 {
4936 *screenPtr++=0;
4937 }
4938 while(--i);
4939
4940 screenPtr+=ScreenDescriptorBlock.SDB_Width * 360/2;
4941
4942 i = ScreenDescriptorBlock.SDB_Width * 60 /2;
4943 do
4944 {
4945 *screenPtr++=0;
4946 }
4947 while(--i);
4948 }
4949
4950
4951
4952 #else
4953 extern DDPIXELFORMAT DisplayPixelFormat;
4954 extern unsigned char *ScreenBuffer;
4955 extern long BackBufferPitch;
4956 // LockSurfaceAndGetBufferPointer();
4957 {
4958 unsigned int *screenPtr;
4959 int i;
4960 int blue = (DisplayPixelFormat.dwBBitMask/4) & DisplayPixelFormat.dwBBitMask;
4961
4962 blue = blue | (blue<<16);
4963 screenPtr = (unsigned int *)ScreenBuffer;
4964 i = ScreenDescriptorBlock.SDB_Width * 60 /2;
4965 do
4966 {
4967 *screenPtr++=0;
4968 }
4969 while(--i);
4970 #if 1
4971 #if 1
4972 i = ScreenDescriptorBlock.SDB_Width * 360/2;
4973 do
4974 {
4975 *screenPtr=0;
4976 screenPtr++;
4977 }
4978 while(--i);
4979 #else
4980 {
4981 unsigned short *s=(unsigned short*)screenPtr;
4982 i = ScreenDescriptorBlock.SDB_Width * 360;
4983 do
4984 {
4985 unsigned short a;
4986 a = MUL_FIXED(((*s)&DisplayPixelFormat.dwRBitMask),50000) & DisplayPixelFormat.dwRBitMask;
4987 a |= MUL_FIXED(((*s)&DisplayPixelFormat.dwGBitMask),50000) & DisplayPixelFormat.dwGBitMask;
4988 a |= MUL_FIXED(((*s)&DisplayPixelFormat.dwBBitMask),50000) & DisplayPixelFormat.dwBBitMask;
4989 *s++=a;
4990 }
4991 while(--i);
4992 }
4993 #endif
4994 #else
4995
4996 #if 0
4997 if (AvPMenus.CurrentMenu == AVPMENU_MARINELEVELS)
4998 {
4999 DrawAvPMenuGfx(AVPMENUGFX_MARINE_EPISODE1+MarineEpisodeToPlay,0,60,ONE_FIXED+1,AVPMENUFORMAT_LEFTJUSTIFIED);
5000 }
5001 else if (AvPMenus.CurrentMenu == AVPMENU_PREDATORLEVELS)
5002 {
5003 DrawAvPMenuGfx(AVPMENUGFX_PREDATOR_EPISODE1+PredatorEpisodeToPlay,0,60,ONE_FIXED+1,AVPMENUFORMAT_LEFTJUSTIFIED);
5004 }
5005 else if (AvPMenus.CurrentMenu == AVPMENU_ALIENLEVELS)
5006 {
5007 DrawAvPMenuGfx(AVPMENUGFX_ALIEN_EPISODE1+AlienEpisodeToPlay,0,60,ONE_FIXED+1,AVPMENUFORMAT_LEFTJUSTIFIED);
5008 }
5009 else
5010 #endif
5011 {
5012 DrawAvPMenuGfx(AVPMENUGFX_BACKDROP,0,0,ONE_FIXED+1,AVPMENUFORMAT_LEFTJUSTIFIED);
5013 }
5014 screenPtr+=ScreenDescriptorBlock.SDB_Width * 360/2;
5015 #endif
5016 i = ScreenDescriptorBlock.SDB_Width * 60 /2;
5017 do
5018 {
5019 *screenPtr++=0;
5020 }
5021 while(--i);
5022
5023 }
5024 #if 0
5025 {
5026 int i;
5027
5028 for(i=0; i<NUMBER_OF_STARS; i++)
5029 {
5030 int x,y;
5031
5032 x = Star[i].X;
5033 y = Star[i].Y;
5034 if ( (x<ONE_FIXED || x>638*ONE_FIXED)
5035 ||(y<61*ONE_FIXED || y>418*ONE_FIXED))
5036 {
5037 Star[i].X = (FastRandom()&65535)*640;
5038 Star[i].Y = ((FastRandom()&65535)*360)+60;
5039 Star[i].Chasing = (FastRandom()&127);
5040 Star[i].Fleeing = (FastRandom()&127);
5041 }
5042 else
5043 {
5044 int s = Star[i].Chasing;
5045 int f = Star[i].Fleeing;
5046 DrawStar(x,y);
5047 // Star[i].X -= MUL_FIXED(Star[i].X - 320*ONE_FIXED,RealFrameTime*4);
5048 // Star[i].Y -= MUL_FIXED(Star[i].Y - 240*ONE_FIXED,RealFrameTime*4);
5049
5050 if ((Star[i].X/131072 == Star[f].X/131072)
5051 &&(Star[i].Y/131072 == Star[f].Y/131072))
5052 {
5053 Star[i].X = (FastRandom()&65535)*640;
5054 Star[i].Y = ((FastRandom()&65535)*360)+60;
5055 }
5056 else
5057 {
5058 Star[i].X -= MUL_FIXED(Star[i].X - Star[s].X,RealFrameTime*4);
5059 Star[i].Y -= MUL_FIXED(Star[i].Y - Star[s].Y,RealFrameTime*4);
5060 Star[i].X += MUL_FIXED(Star[i].X - Star[f].X,RealFrameTime);
5061 Star[i].Y += MUL_FIXED(Star[i].Y - Star[f].Y,RealFrameTime);
5062 }
5063
5064
5065 }
5066 }
5067
5068 }
5069 #endif
5070 //UnlockSurface();
5071 #endif
5072 }
5073
WhiteOfBrightness(int brightness)5074 int WhiteOfBrightness(int brightness)
5075 {
5076 fprintf(stderr, "WhiteOfBrightness(%d)\n", brightness);
5077
5078 return 0;
5079 #if 0
5080 extern DDPIXELFORMAT DisplayPixelFormat;
5081 int a;
5082
5083 a = MUL_FIXED(DisplayPixelFormat.dwRBitMask,brightness) & DisplayPixelFormat.dwRBitMask;
5084 a |= MUL_FIXED(DisplayPixelFormat.dwGBitMask,brightness) & DisplayPixelFormat.dwGBitMask;
5085 a |= MUL_FIXED(DisplayPixelFormat.dwBBitMask,brightness) & DisplayPixelFormat.dwBBitMask;
5086
5087 return a;
5088 #endif
5089 }
5090
RenderPixel(int x,int y,int r,int g,int b)5091 void RenderPixel(int x,int y,int r,int g,int b)
5092 {
5093 fprintf(stderr, "RenderPixel(%d, %d, %d, %d, %d)\n", x, y, r, g, b);
5094 #if 0
5095 extern DDPIXELFORMAT DisplayPixelFormat;
5096 extern unsigned char *ScreenBuffer;
5097 extern long BackBufferPitch;
5098
5099 unsigned short colour;
5100
5101 colour = MUL_FIXED(DisplayPixelFormat.dwRBitMask,r<<8) & DisplayPixelFormat.dwRBitMask;
5102 colour |= MUL_FIXED(DisplayPixelFormat.dwGBitMask,g<<8) & DisplayPixelFormat.dwGBitMask;
5103 colour |= MUL_FIXED(DisplayPixelFormat.dwBBitMask,b<<8) & DisplayPixelFormat.dwBBitMask;
5104
5105
5106 *(unsigned short*) (ScreenBuffer + (x)*2 + (y)*BackBufferPitch) = colour;
5107 #endif
5108 }
5109 #if 0
5110 void BezierCurve(void)
5111 {
5112 int i;
5113 extern unsigned char *ScreenBuffer;
5114 extern long BackBufferPitch;
5115 static b=0;
5116 for (i=0; i<=255; i++)
5117 {
5118 int u = ((i*65536)/255);
5119 int m = MUL_FIXED(u,u);
5120 int l = MUL_FIXED(2*u,ONE_FIXED-u);
5121
5122 int a;
5123
5124 a = MUL_FIXED(255,m)+MUL_FIXED(b,l);
5125 if (a<0) a=0;
5126 if (a>255) a=255;
5127
5128 m = MUL_FIXED(a*256,a*256);
5129 l = MUL_FIXED(2*a*256,ONE_FIXED-a*256);
5130
5131 a;
5132
5133 a = MUL_FIXED(255,m)+MUL_FIXED(b,l);
5134 if (a<0) a=0;
5135 if (a>255) a=255;
5136
5137 *(unsigned short*)(ScreenBuffer + ((i+0)*2 + (400-a)*BackBufferPitch)) = 0xffff;
5138 //*(unsigned short*)(ScreenBuffer + ((i+0)*2 + (400-i)*BackBufferPitch)) = 0xff;
5139
5140 *(unsigned short*)(ScreenBuffer + ((i+0)*2 + (400-i)*BackBufferPitch)) = 0xffff;
5141 *(unsigned short*)(ScreenBuffer + ((i+50)*2 + (400-i)*BackBufferPitch)) = 0xffff;
5142 *(unsigned short*)(ScreenBuffer + ((i+100)*2 + (400-i)*BackBufferPitch)) = 0xffff;
5143
5144
5145 }
5146 // PlayWithGammaSettings(b);
5147 b++;
5148 if (b>=255) b=0;
5149 }
5150 #endif
5151
5152
5153
UpdateMultiplayerConfigurationMenu()5154 static void UpdateMultiplayerConfigurationMenu()
5155 {
5156 /*update the displayed levels according to the cuurent game type*/
5157
5158 AVPMENU_ELEMENT *elementPtr = AvPMenus.MenuElements;
5159
5160 //search for the level name element
5161 do
5162 {
5163 GLOBALASSERT(elementPtr->ElementID!=AVPMENU_ELEMENT_ENDOFMENU);
5164 elementPtr++;
5165
5166 }while(elementPtr->a.TextDescription!=TEXTSTRING_MULTIPLAYER_ENVIRONMENT);
5167
5168
5169 if(netGameData.skirmishMode)
5170 {
5171 //force 'cooperative' game if using skirmish mode
5172 netGameData.gameType=NGT_Coop;
5173 }
5174
5175 if(netGameData.gameType!=NGT_Coop)
5176 {
5177 elementPtr->b.MaxSliderValue = NumMultiplayerLevels-1;
5178 elementPtr->d.TextSliderStringPointer = MultiplayerLevelNames;
5179
5180 //make sure the level number is within bounds
5181 netGameData.levelNumber%=NumMultiplayerLevels;
5182 }
5183 else
5184 {
5185 elementPtr->b.MaxSliderValue = NumCoopLevels-1;
5186 elementPtr->d.TextSliderStringPointer = CoopLevelNames;
5187
5188 //make sure the level number is within bounds
5189 netGameData.levelNumber%=NumCoopLevels;
5190 }
5191
5192
5193 //see if selected element is the gamestyle element
5194 elementPtr = &AvPMenus.MenuElements[AvPMenus.CurrentlySelectedElement];
5195
5196 if(elementPtr->a.TextDescription==TEXTSTRING_MULTIPLAYER_GAMESTYLE)
5197 {
5198 //change the helpstring according to the game style
5199 switch(netGameData.gameType)
5200 {
5201 case NGT_Individual :
5202 elementPtr->HelpString=TEXTSTRING_MPHELP_GAMESTYLE_DEATHMATCH;
5203 break;
5204
5205 case NGT_CoopDeathmatch :
5206 elementPtr->HelpString=TEXTSTRING_MPHELP_GAMESTYLE_DEATHMATCHTEAM;
5207 break;
5208
5209 case NGT_LastManStanding :
5210 elementPtr->HelpString=TEXTSTRING_MPHELP_GAMESTYLE_LASTMANSTANDING;
5211 break;
5212
5213 case NGT_PredatorTag :
5214 elementPtr->HelpString=TEXTSTRING_MPHELP_GAMESTYLE_PREDATORTAG;
5215 break;
5216
5217 case NGT_Coop :
5218 elementPtr->HelpString=TEXTSTRING_MPHELP_GAMESTYLE_COOPERATIVE;
5219 break;
5220
5221 case NGT_AlienTag :
5222 elementPtr->HelpString=TEXTSTRING_MPHELP_GAMESTYLE_ALIENTAG;
5223 break;
5224 }
5225 }
5226
5227 //also need to fill in customLevelName
5228 strcpy(netGameData.customLevelName,GetCustomMultiplayerLevelName(netGameData.levelNumber,netGameData.gameType));
5229
5230 }
5231
TestValidityOfCheatMenu(void)5232 static void TestValidityOfCheatMenu(void)
5233 {
5234 CheatMode_GetNextAllowedMode(AvPMenus.MenuElements[0].c.SliderValuePtr,TRUE);
5235 CheatMode_GetNextAllowedSpecies(AvPMenus.MenuElements[1].c.SliderValuePtr,TRUE);
5236 CheatMode_GetNextAllowedEnvironment(AvPMenus.MenuElements[2].c.SliderValuePtr,TRUE);
5237 }
5238
5239 static unsigned char *BriefingTextString[5];
5240 static unsigned char BlankLine[]="";
5241
SetBriefingTextForEpisode(int episode,I_PLAYER_TYPE playerID)5242 void SetBriefingTextForEpisode(int episode, I_PLAYER_TYPE playerID)
5243 {
5244 int i,s;
5245
5246 switch(playerID)
5247 {
5248 default:
5249 case I_Marine:
5250 {
5251 s = TEXTSTRING_MARINELEVELSBRIEFING_1;
5252 break;
5253 }
5254 case I_Predator:
5255 {
5256 s = TEXTSTRING_PREDATORLEVELSBRIEFING_1;
5257 break;
5258 }
5259 case I_Alien:
5260 {
5261 s = TEXTSTRING_ALIENLEVELSBRIEFING_1;
5262 break;
5263 }
5264 }
5265
5266 for(i=0; i<5; i++)
5267 {
5268 BriefingTextString[i] = GetTextString(s+i+ episode*5);
5269 }
5270 }
5271
5272 static char MultiplayerBriefing[3][100];
5273
AddMultiplayerBriefingString(const char * text)5274 static void AddMultiplayerBriefingString(const char* text)
5275 {
5276 int shortest = 0;
5277 int shortest_length =1000;
5278 int i;
5279
5280 for(i=0;i<3;i++)
5281 {
5282 int length = strlen(MultiplayerBriefing[i]);
5283 if(length<shortest_length)
5284 {
5285 shortest = i;
5286 shortest_length = length;
5287 }
5288 }
5289
5290 if(shortest_length + 3 + strlen(text)>=100) return;
5291
5292 if(shortest_length>0)
5293 {
5294 strcat(MultiplayerBriefing[shortest]," , ");
5295 }
5296 strcat(MultiplayerBriefing[shortest],text);
5297 }
5298
IsFlamerInLevel(int level)5299 static BOOL IsFlamerInLevel(int level)
5300 {
5301 if(level == AVP_ENVIRONMENT_SUBWAY_MP ||
5302 level == AVP_ENVIRONMENT_SUBWAY_COOP)
5303 {
5304 return FALSE;
5305 }
5306 return TRUE;
5307 }
5308
IsMinigunInLevel(int level)5309 static BOOL IsMinigunInLevel(int level)
5310 {
5311 if(level == AVP_ENVIRONMENT_SEWER)
5312 {
5313 return FALSE;
5314 }
5315 return TRUE;
5316 }
5317
IsSadarInLevel(int level)5318 static BOOL IsSadarInLevel(int level)
5319 {
5320 if(level == AVP_ENVIRONMENT_MASSACRE ||
5321 level == AVP_ENVIRONMENT_MEATFACTORY_MP ||
5322 level == AVP_ENVIRONMENT_MEATFACTORY_COOP ||
5323 level == AVP_ENVIRONMENT_HADLEYSHOPE_MP ||
5324 level == AVP_ENVIRONMENT_HADLEYSHOPE_COOP ||
5325 level == AVP_ENVIRONMENT_HIVE ||
5326 level == AVP_ENVIRONMENT_HIVE_COOP ||
5327 level == AVP_ENVIRONMENT_KENS_COOP ||
5328 level == AVP_ENVIRONMENT_LEADWORKS_MP ||
5329 level == AVP_ENVIRONMENT_LEADWORKS_COOP)
5330 {
5331 return FALSE;
5332 }
5333 return TRUE;
5334 }
5335
IsSkeeterInLevel(int level)5336 static BOOL IsSkeeterInLevel(int level)
5337 {
5338 if(level == AVP_ENVIRONMENT_LEADWORKS_MP ||
5339 level == AVP_ENVIRONMENT_LEADWORKS_COOP)
5340 {
5341 return FALSE;
5342 }
5343 return TRUE;
5344 }
5345
IsSmartgunInLevel(int level)5346 static BOOL IsSmartgunInLevel(int level)
5347 {
5348 if(level == AVP_ENVIRONMENT_NOSTROMO_MP) return FALSE;
5349 return TRUE;
5350 }
5351
5352
SetBriefingTextForMultiplayer()5353 static void SetBriefingTextForMultiplayer()
5354 {
5355 int level = NumberForCurrentLevel();
5356
5357 int num_not_available = 0;
5358
5359 if(netGameData.customLevelName[0] != 0)
5360 {
5361 //custom level
5362 BriefingTextString[0] = netGameData.customLevelName;
5363 return;
5364 }
5365
5366 MultiplayerBriefing[0][0] = 0;
5367 MultiplayerBriefing[1][0] = 0;
5368 MultiplayerBriefing[2][0] = 0;
5369
5370 if(!netGameData.allowSmartgun || !IsSmartgunInLevel(level))
5371 {
5372 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_SMARTGUN));
5373 num_not_available++;
5374 }
5375 if(!netGameData.allowFlamer || !IsFlamerInLevel(level))
5376 {
5377 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_FLAMETHROWER));
5378 num_not_available++;
5379 }
5380 if(!netGameData.allowSadar || !IsSadarInLevel(level))
5381 {
5382 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_SADAR));
5383 num_not_available++;
5384 }
5385 if(!netGameData.allowGrenadeLauncher)
5386 {
5387 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_GRENADELAUNCHER));
5388 num_not_available++;
5389 }
5390 if(!netGameData.allowMinigun || !IsMinigunInLevel(level))
5391 {
5392 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_MINIGUN));
5393 num_not_available++;
5394 }
5395 if(!netGameData.allowSmartDisc || !IsSkeeterInLevel(level))
5396 {
5397 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_SKEETER));
5398 num_not_available++;
5399 }
5400 if(!netGameData.allowPistols)
5401 {
5402 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_MARINE_PISTOL));
5403 num_not_available++;
5404 }
5405 if(!netGameData.allowDisc)
5406 {
5407 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_DISC));
5408 num_not_available++;
5409 }
5410 if(!netGameData.allowPistol)
5411 {
5412 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_BRIEFING_PREDATOR_PISTOL));
5413 num_not_available++;
5414 }
5415 if(!netGameData.allowPlasmaCaster)
5416 {
5417 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_SHOULDERCANNON));
5418 num_not_available++;
5419 }
5420 if(!netGameData.allowSpeargun)
5421 {
5422 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_RIFLE));
5423 num_not_available++;
5424 }
5425 if(!netGameData.allowMedicomp)
5426 {
5427 AddMultiplayerBriefingString(GetTextString(TEXTSTRING_INGAME_MEDICOMP));
5428 num_not_available++;
5429 }
5430
5431 if(netGameData.gameType!=NGT_Coop)
5432 {
5433 BriefingTextString[0] = GetTextString(netGameData.levelNumber + TEXTSTRING_MULTIPLAYERLEVELS_1);
5434
5435 }
5436 else
5437 {
5438 BriefingTextString[0] = GetTextString(netGameData.levelNumber + TEXTSTRING_COOPLEVEL_1);
5439 }
5440
5441 if(num_not_available)
5442 {
5443 BriefingTextString[1] = GetTextString(TEXTSTRING_BRIEFING_UNAVAILABLE_WEAPONS);
5444 BriefingTextString[2] = MultiplayerBriefing[0];
5445 BriefingTextString[3] = MultiplayerBriefing[1];
5446 BriefingTextString[4] = MultiplayerBriefing[2];
5447 }
5448 }
5449
SetBriefingTextToBlank(void)5450 void SetBriefingTextToBlank(void)
5451 {
5452 int i;
5453
5454 for(i=0; i<5; i++)
5455 {
5456 BriefingTextString[i] = BlankLine;
5457 }
5458 }
5459
RenderBriefingText(int centreY,int brightness)5460 void RenderBriefingText(int centreY, int brightness)
5461 {
5462 int lengthOfLongestLine=-1;
5463 int x,y,i;
5464
5465 for(i=0; i<5; i++)
5466 {
5467 int length = 0;
5468 {
5469 char *ptr = BriefingTextString[i];
5470
5471 while(*ptr)
5472 {
5473 length+=AAFontWidths[(unsigned char)(*ptr++)];
5474 }
5475 }
5476
5477 if (lengthOfLongestLine < length)
5478 {
5479 lengthOfLongestLine = length;
5480 }
5481 }
5482
5483 x = (ScreenDescriptorBlock.SDB_Width-lengthOfLongestLine)/2;
5484 y = centreY - 3*HUD_FONT_HEIGHT;
5485 for(i=0; i<5; i++)
5486 {
5487 if (AvPMenus.MenusState != MENUSSTATE_MAINMENUS)
5488 {
5489 Hardware_RenderSmallMenuText(BriefingTextString[i], x, y, brightness, AVPMENUFORMAT_LEFTJUSTIFIED/*,MENU_CENTREY-60-100,MENU_CENTREY-60+180*/);
5490 }
5491 else
5492 {
5493 RenderSmallMenuText(BriefingTextString[i], x, y, brightness, AVPMENUFORMAT_LEFTJUSTIFIED);
5494 }
5495 if (i) y+=HUD_FONT_HEIGHT;
5496 else y+=HUD_FONT_HEIGHT*2;
5497 }
5498 }
5499
5500
CheckForKeysWithMultipleAssignments(void)5501 void CheckForKeysWithMultipleAssignments(void)
5502 {
5503 unsigned char *configPtr[2];
5504 int column,row;
5505
5506 configPtr[0] = (unsigned char*)&PlayerInputPrimaryConfig;
5507 configPtr[1] = (unsigned char*)&PlayerInputSecondaryConfig;
5508
5509 for (column=0; column<=1; column++)
5510 {
5511 for (row=0; row<32; row++)
5512 {
5513 int innerColumn,innerRow;
5514
5515 MultipleAssignments[column][row] = 0;
5516
5517 for (innerColumn=0; innerColumn<=1; innerColumn++)
5518 for (innerRow=0; innerRow<32; innerRow++)
5519 {
5520 if (innerRow==row) continue;
5521 // && innerColumn==column) continue;
5522 if ( (configPtr[column])[row]==(configPtr[innerColumn])[innerRow] )
5523 {
5524 MultipleAssignments[column][row] = 1;
5525 }
5526 }
5527 }
5528 }
5529 }
5530
HandleCheatModeFeatures(void)5531 void HandleCheatModeFeatures(void)
5532 {
5533 switch(CheatMode_Active)
5534 {
5535 case CHEATMODE_WARPSPEED:
5536 {
5537 TimeScale = 2*ONE_FIXED;
5538 AvP.Difficulty = 0;
5539 break;
5540 }
5541 case CHEATMODE_LANDOFTHEGIANTS:
5542 {
5543 TimeScale =ONE_FIXED/2;
5544 break;
5545 }
5546 case CHEATMODE_IMPOSSIBLEMISSION:
5547 {
5548 AvP.Difficulty = 3;
5549 break;
5550 }
5551 case CHEATMODE_UNDERWATER:
5552 {
5553 TimeScale = (ONE_FIXED*7)/10;
5554 break;
5555 }
5556 default:
5557 break;
5558 }
5559 }
5560
ShowMenuFrameRate(void)5561 void ShowMenuFrameRate(void)
5562 {
5563 #if 0
5564 extern NormalFrameTime;
5565 char buffer[8];
5566
5567 sprintf(buffer,"%d fps",65536/NormalFrameTime);
5568 RenderSmallMenuText(buffer,20,20,ONE_FIXED, AVPMENUFORMAT_LEFTJUSTIFIED);
5569 #endif
5570 }
5571
5572 #define MAX_ITEMS_IN_KEYBOARDENTRYQUEUE 8
5573 static char KeyboardEntryQueue[MAX_ITEMS_IN_KEYBOARDENTRYQUEUE];
5574 static int NumberOfItemsInKeyboardEntryQueue;
5575 static int KeyboardEntryQueue_ProcessingIndex;
5576
KeyboardEntryQueue_Add(char c)5577 void KeyboardEntryQueue_Add(char c)
5578 {
5579 if (c<32) return;
5580
5581 if (NumberOfItemsInKeyboardEntryQueue<MAX_ITEMS_IN_KEYBOARDENTRYQUEUE)
5582 {
5583 KeyboardEntryQueue[NumberOfItemsInKeyboardEntryQueue++] = c;
5584 }
5585 }
5586
KeyboardEntryQueue_Clear(void)5587 static void KeyboardEntryQueue_Clear(void)
5588 {
5589 int i;
5590 for (i=0; i<MAX_ITEMS_IN_KEYBOARDENTRYQUEUE; i++)
5591 {
5592 KeyboardEntryQueue[i] = 0;
5593 }
5594 NumberOfItemsInKeyboardEntryQueue = 0;
5595 }
5596
KeyboardEntryQueue_StartProcessing(void)5597 static void KeyboardEntryQueue_StartProcessing(void)
5598 {
5599 KeyboardEntryQueue_ProcessingIndex = 0;
5600 }
5601
KeyboardEntryQueue_ProcessCharacter(void)5602 static char KeyboardEntryQueue_ProcessCharacter(void)
5603 {
5604 if (KeyboardEntryQueue_ProcessingIndex==MAX_ITEMS_IN_KEYBOARDENTRYQUEUE) return 0;
5605
5606 return KeyboardEntryQueue[KeyboardEntryQueue_ProcessingIndex++];
5607 }
5608
5609
5610
5611 /*------------------------------------**
5612 ** Loading and saving main level info **
5613 **------------------------------------*/
5614
5615
5616 extern int AlienEpisodeToPlay;
5617 extern int MarineEpisodeToPlay;
5618 extern int PredatorEpisodeToPlay;
5619
SaveLevelHeader()5620 void SaveLevelHeader()
5621 {
5622 LEVEL_SAVE_BLOCK* block = (LEVEL_SAVE_BLOCK*) GetPointerForSaveBlock(sizeof(LEVEL_SAVE_BLOCK));
5623
5624 //fill in the header
5625 block->header.type = SaveBlock_MainHeader;
5626 block->header.size = sizeof(*block);
5627
5628 //fill in the main block
5629 strncpy(block->AvP_Save_String,"AVPSAVE0",8);
5630
5631 block->Species = AvP.PlayerType;
5632
5633 switch(block->Species)
5634 {
5635 case I_Marine :
5636 block->Episode = MarineEpisodeToPlay;
5637 break;
5638
5639 case I_Alien :
5640 block->Episode = AlienEpisodeToPlay;
5641 break;
5642
5643 case I_Predator :
5644 block->Episode = PredatorEpisodeToPlay;
5645 break;
5646 }
5647
5648 block->ElapsedTime_Hours =(unsigned char) AvP.ElapsedHours;
5649 block->ElapsedTime_Minutes =(unsigned char) AvP.ElapsedMinutes;
5650 block->ElapsedTime_Seconds = AvP.ElapsedSeconds;
5651
5652 block->Difficulty = AvP.Difficulty;
5653 block->NumberOfSavesLeft = (unsigned char) NumberOfSavesLeft;
5654 }
5655
LoadLevelHeader(SAVE_BLOCK_HEADER * header)5656 void LoadLevelHeader(SAVE_BLOCK_HEADER* header)
5657 {
5658 LEVEL_SAVE_BLOCK* block =(LEVEL_SAVE_BLOCK*) header;
5659
5660 if(block->header.size!=sizeof(*block)) return;
5661
5662 AvP.ElapsedHours = block->ElapsedTime_Hours;
5663 AvP.ElapsedMinutes = block->ElapsedTime_Minutes;
5664 AvP.ElapsedSeconds = block->ElapsedTime_Seconds;
5665 }
5666
GetHeaderInfoForSaveSlot(SAVE_SLOT_HEADER * save_slot,const GameDirectoryFile * gdf)5667 static void GetHeaderInfoForSaveSlot(SAVE_SLOT_HEADER* save_slot, const GameDirectoryFile *gdf)
5668 {
5669 LEVEL_SAVE_BLOCK block;
5670 unsigned int file_size;
5671 unsigned char filename[100];
5672 FILE *file;
5673
5674 save_slot->SlotUsed = 0;
5675
5676 sprintf(filename, "%s%s", USER_PROFILES_PATH, gdf->filename);
5677 file = OpenGameFile(filename, FILEMODE_READONLY, FILETYPE_CONFIG);
5678
5679 if (file==NULL)
5680 {
5681 //failed to load (probably doesn't exist)
5682 return;
5683 }
5684
5685 fseek(file, 0, SEEK_END);
5686 file_size = ftell(file);
5687 rewind(file);
5688
5689 if(file_size < sizeof(LEVEL_SAVE_BLOCK))
5690 {
5691 //obviously not much of a save file then...
5692 fclose(file);
5693 return;
5694
5695 }
5696
5697 save_slot->TimeStamp = gdf->timestamp;
5698
5699 //load the level header
5700 fread(&block, sizeof(block), 1, file);
5701 fclose(file);
5702
5703 //a few checks
5704 if(block.header.type != SaveBlock_MainHeader ||
5705 block.header.size != sizeof(block) ||
5706 strncmp(block.AvP_Save_String,"AVPSAVE0",8))
5707 {
5708 //no good.
5709 return;
5710 }
5711
5712 //appears to be a reasonable file
5713 save_slot->SlotUsed = TRUE;
5714
5715 //copy stuff from the block
5716
5717 save_slot->Species = block.Species;
5718 save_slot->Episode = block.Episode;
5719 save_slot->ElapsedTime_Hours = block.ElapsedTime_Hours;
5720 save_slot->ElapsedTime_Minutes = block.ElapsedTime_Minutes;
5721 save_slot->ElapsedTime_Seconds = (block.ElapsedTime_Seconds >> 16);
5722 save_slot->Difficulty = block.Difficulty;
5723 save_slot->SavesLeft = block.NumberOfSavesLeft;
5724 }
5725
ScanSaveSlots(void)5726 void ScanSaveSlots(void)
5727 {
5728 unsigned char pattern[100], *ptr;
5729 int i;
5730 void *gd;
5731 GameDirectoryFile *gdf;
5732
5733 sprintf(pattern, "%s_?.sav", UserProfilePtr->Name);
5734 gd = OpenGameDirectory(USER_PROFILES_PATH, pattern, FILETYPE_CONFIG);
5735 if (gd == NULL)
5736 return;
5737
5738 while ((gdf = ScanGameDirectory(gd)) != NULL) {
5739 if ((gdf->attr & FILEATTR_DIRECTORY) != 0)
5740 continue;
5741 if ((gdf->attr & FILEATTR_READABLE) == 0)
5742 continue;
5743
5744 ptr = strrchr(gdf->filename, '.');
5745 if (ptr == NULL)
5746 continue;
5747 ptr--;
5748
5749 i = *ptr - '1';
5750 if (i >= 0 && (i < NUMBER_OF_SAVE_SLOTS)) {
5751 GetHeaderInfoForSaveSlot(&SaveGameSlot[i], gdf);
5752 }
5753 }
5754 }
5755
GetFilenameForSaveSlot(int i,unsigned char * filenamePtr)5756 extern void GetFilenameForSaveSlot(int i, unsigned char *filenamePtr)
5757 {
5758 sprintf(filenamePtr,"%s%s_%d.sav",USER_PROFILES_PATH,UserProfilePtr->Name,i+1);
5759 }
5760
CheckForLoadGame()5761 static void CheckForLoadGame()
5762 {
5763 if(LoadGameRequest >=0 && LoadGameRequest<NUMBER_OF_SAVE_SLOTS)
5764 {
5765 SAVE_SLOT_HEADER* save_slot = &SaveGameSlot[LoadGameRequest];
5766 if(save_slot->SlotUsed)
5767 {
5768 AvP.PlayerType = save_slot->Species;
5769 AvP.Difficulty = save_slot->Difficulty;
5770
5771 switch(AvP.PlayerType)
5772 {
5773 case I_Marine :
5774 MarineEpisodeToPlay = save_slot->Episode;
5775 SetLevelToLoadForMarine(MarineEpisodeToPlay);
5776 break;
5777
5778 case I_Alien :
5779 AlienEpisodeToPlay = save_slot->Episode;
5780 SetLevelToLoadForAlien(AlienEpisodeToPlay);
5781
5782 break;
5783
5784 case I_Predator :
5785 PredatorEpisodeToPlay = save_slot->Episode;
5786 SetLevelToLoadForPredator(PredatorEpisodeToPlay);
5787 break;
5788
5789 }
5790 SetBriefingTextForEpisode(save_slot->Episode, AvP.PlayerType);
5791 AvPMenus.MenusState = MENUSSTATE_STARTGAME;
5792 }
5793 else
5794 {
5795 //cancel request
5796 LoadGameRequest = SAVELOAD_REQUEST_NONE;
5797 }
5798 }
5799 }
5800
5801
PasteFromClipboard(char * Text,int MaxTextLength)5802 static void PasteFromClipboard(char* Text,int MaxTextLength)
5803 {
5804 fprintf(stderr, "PasteFromClipboard(%p, %d)\n", Text, MaxTextLength);
5805 #if 0
5806 HANDLE hGlobal;
5807 if(!Text)
5808 {
5809 return;
5810 }
5811
5812 if(IsClipboardFormatAvailable(CF_TEXT))
5813 {
5814 OpenClipboard(0);
5815 hGlobal = GetClipboardData(CF_TEXT);
5816 if(hGlobal)
5817 {
5818 char* pGlobal = GlobalLock(hGlobal);
5819 if(pGlobal)
5820 {
5821 strncpy(Text,pGlobal,MaxTextLength-1);
5822 Text[MaxTextLength-1] = 0;
5823 GlobalUnlock(hGlobal);
5824 }
5825 }
5826 CloseClipboard();
5827 }
5828 #endif
5829 }
5830