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