CnC_Remastered_Collection

MAPEDIT.CPP (63555B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header: /CounterStrike/MAPEDIT.CPP 2     3/13/97 2:05p Steve_tall $ */
 /***************************************************************************
  **   C O N F I D E N T I A L --- W E S T W O O D    S T U D I O S        **
  ***************************************************************************
  *                                                                         *
  *                 Project Name : Command & Conquer                        *
  *                                                                         *
  *                    File Name : MAPEDIT.CPP                              *
  *                                                                         *
  *                   Programmer : Bill Randolph                            *
  *                                                                         *
  *                   Start Date : October 20, 1994                         *
  *                                                                         *
  *                  Last Update : February 2, 1995   [BR]                  *
  *                                                                         *
  *-------------------------------------------------------------------------*
  *   Map Editor overloaded routines & utility routines                     *
  *-------------------------------------------------------------------------*
  * Map Editor modules:                                                     *
  * (Yes, they're all one huge class.)                                      *
  *      mapedit.cpp:   overloaded routines, utility routines               *
  *      mapeddlg.cpp:   map editor dialogs, most of the main menu options  *
  *      mapedplc.cpp:   object-placing routines                            *
  *      mapedsel.cpp:   object-selection & manipulation routines           *
  *      mapedtm.cpp:   team-editing routines                               *
  *-------------------------------------------------------------------------*
  * Functions:                                                              *
  *   MapEditClass::AI -- The map editor's main logic                       *
  *   MapEditClass::Read_INI -- overloaded Read_INI function                *
  *   MapEditClass::AI_Menu -- menu of AI options                           *
  *   MapEditClass::Add_To_List -- adds a TypeClass to the chooseable list  *
  *   MapEditClass::Clear_List -- clears the internal chooseable object list*
  *   MapEditClass::Cycle_House -- finds next valid house for object type   *
  *   MapEditClass::Draw_It -- overloaded Redraw routine                    *
  *   MapEditClass::Fatal -- exits with error message                       *
  *   MapEditClass::Main_Menu -- main menu processor for map editor         *
  *   MapEditClass::MapEditClass -- class constructor                       *
  *   MapEditClass::Mouse_Moved -- checks for mouse motion                  *
  *   MapEditClass::One_Time -- one-time initialization                     *
  *   MapEditClass::Verify_House -- sees if given house can own given obj   *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #include	"function.h"
 
 #ifdef SCENARIO_EDITOR
 
 /*
 **	Array of all missions supported by the map editor
 */
 MissionType MapEditClass::MapEditMissions[] = {
 	MISSION_GUARD,
 	MISSION_STICKY,
 	MISSION_HARMLESS,
 	MISSION_HARVEST,
 	MISSION_GUARD_AREA,
 	MISSION_RETURN,
 	MISSION_AMBUSH,
 	MISSION_HUNT,
 	MISSION_SLEEP,
 };
 #define NUM_EDIT_MISSIONS (sizeof(MapEditClass::MapEditMissions) / sizeof(MapEditClass::MapEditMissions[0]))
 
 
 /*
 **	For menu processing
 */
 extern int UnknownKey;					// in menus.cpp
 
 char MapEditClass::HealthBuf[20];
 
 
 /***************************************************************************
  * MapEditClass::MapEditClass -- class constructor                         *
  *                                                                         *
  * INPUT:                                                                  *
  *      none.                                                              *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      none.                                                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   10/20/1994 BR : Created.                                              *
  *=========================================================================*/
 MapEditClass::MapEditClass(void)
 {
 	/*
 	**	Init data members.
 	*/
 //	ScenVar = SCEN_VAR_A;
 	ObjCount = 0;
 	LastChoice = 0;
 	LastHouse = HOUSE_GOOD;
 	GrabbedObject = 0;
 	for (int i=0; i < NUM_EDIT_CLASSES; i++) {
 		NumType[i] = 0;
 		TypeOffset[i] = 0;
 	}
 	Scen.Waypoint[WAYPT_HOME] = 0;
 	CurrentCell = 0;
 	CurTeam = NULL;
 	CurTrigger = NULL;
 	Changed = 0;
 	LMouseDown = 0;
 	BaseBuilding = false;
 //	BasePercent = 100;
 }
 
 
 /***************************************************************************
  * MapEditClass::One_Time -- one-time initialization                       *
  *                                                                         *
  * INPUT:                                                                  *
  *      none.                                                              *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      none.                                                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   02/02/1995 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::One_Time(void)
 {
 	MouseClass::One_Time();
 
 	/*
 	**	The map: a single large "button"
 	*/
 #ifdef WIN32
 	MapArea = new ControlClass(MAP_AREA, 0, 8, 640-8, 400-8, GadgetClass::LEFTPRESS | GadgetClass::LEFTRELEASE, false);
 #else
 	MapArea = new ControlClass(MAP_AREA, 0, 8, 312, 192, GadgetClass::LEFTPRESS | GadgetClass::LEFTRELEASE, false);
 #endif
 
 	/*
 	**	House buttons
 	*/
 	HouseList = new ListClass(POPUP_HOUSELIST, POPUP_HOUSE_X, POPUP_HOUSE_Y, POPUP_HOUSE_W, POPUP_HOUSE_H,
 		TPF_EFNT|TPF_NOSHADOW,
 		MFCD::Retrieve("EBTN-UP.SHP"),
 		MFCD::Retrieve("EBTN-DN.SHP"));
 	for (HousesType house = HOUSE_FIRST; house < HOUSE_COUNT; house++) {
 		HouseList->Add_Item(HouseTypeClass::As_Reference(house).IniName);
 	}
 
 	/*
 	**	The mission list box
 	*/
 	MissionList = new ListClass(POPUP_MISSIONLIST,
 		POPUP_MISSION_X, POPUP_MISSION_Y, POPUP_MISSION_W, POPUP_MISSION_H,
 		TPF_EFNT|TPF_NOSHADOW,
 		MFCD::Retrieve("EBTN-UP.SHP"),
 		MFCD::Retrieve("EBTN-DN.SHP"));
 
 	for (int i = 0; i < NUM_EDIT_MISSIONS; i++) {
 		MissionList->Add_Item(MissionClass::Mission_Name(MapEditMissions[i]));
 	}
 
 	/*
 	**	The health bar
 	*/
 	HealthGauge = new TriColorGaugeClass(POPUP_HEALTHGAUGE,
 		POPUP_HEALTH_X, POPUP_HEALTH_Y, POPUP_HEALTH_W, POPUP_HEALTH_H);
 	HealthGauge->Use_Thumb(true);
 	HealthGauge->Set_Maximum(0x100);
 	HealthGauge->Set_Red_Limit(0x3f - 1);
 	HealthGauge->Set_Yellow_Limit(0x7f - 1);
 
 	/*
 	**	The health text label
 	*/
 	HealthBuf[0] = 0;
 	HealthText = new TextLabelClass(HealthBuf,
 		POPUP_HEALTH_X + POPUP_HEALTH_W / 2,
 		POPUP_HEALTH_Y + POPUP_HEALTH_H + 1,
 		GadgetClass::Get_Color_Scheme(),
 		TPF_CENTER | TPF_FULLSHADOW | TPF_EFNT);
 
 	/*
 	**	Building attribute buttons.
 	*/
 	Sellable = new TextButtonClass(POPUP_SELLABLE, TXT_SELLABLE, TPF_EBUTTON, 320-65, 200-25, 60);
 	Rebuildable = new TextButtonClass(POPUP_REBUILDABLE, TXT_REBUILD, TPF_EBUTTON, 320-65, 200-15, 60);
 
 	/*
 	**	The facing dial
 	*/
 	FacingDial = new Dial8Class(POPUP_FACINGDIAL, POPUP_FACEBOX_X,
 		POPUP_FACEBOX_Y, POPUP_FACEBOX_W, POPUP_FACEBOX_H, (DirType)0);
 
 	/*
 	**	The base percent-built slider & its label
 	*/
 	BaseGauge = new GaugeClass(POPUP_BASEPERCENT, POPUP_BASE_X, POPUP_BASE_Y, POPUP_BASE_W, POPUP_BASE_H);
 	BaseLabel = new TextLabelClass ("Base:", POPUP_BASE_X - 3, POPUP_BASE_Y, GadgetClass::Get_Color_Scheme(),
 		TPF_RIGHT | TPF_NOSHADOW | TPF_EFNT);
 	BaseGauge->Set_Maximum(100);
 	BaseGauge->Set_Value(Scen.Percent);
 }
 
 
 /***********************************************************************************************
  * MapeditClass::Init_IO -- Reinitializes the radar map at scenario start.                     *
  *                                                                                             *
  * INPUT:   none                                                                               *
  *                                                                                             *
  * OUTPUT:  none                                                                               *
  *                                                                                             *
  * WARNINGS:   none                                                                            *
  *                                                                                             *
  * HISTORY:                                                                                    *
  *   12/22/1994 JLB : Created.                                                                 *
  *=============================================================================================*/
 void MapEditClass::Init_IO(void)
 {
 	/*
 	**	For normal game mode, jump to the parent's Init routine.
 	*/
 	if (!Debug_Map) {
 
 		MouseClass::Init_IO();
 
 	} else {
 
 		/*
 		**	For editor mode, add the map area to the button input list
 		*/
 		Buttons = 0;
 		Add_A_Button(*BaseGauge);
 		Add_A_Button(*BaseLabel);
 		Add_A_Button(*MapArea);
 	}
 }
 
 
 /***************************************************************************
  * MapEditClass::Clear_List -- clears the internal chooseable object list   *
  *                                                                         *
  * INPUT:                                                                  *
  *      none.                                                              *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      none.                                                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   10/20/1994 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::Clear_List(void)
 {
 	/*
 	**	Set # object type ptrs to 0, set NumType for each type to 0
 	*/
 	ObjCount = 0;
 	for (int i = 0; i < NUM_EDIT_CLASSES; i++) {
 		NumType[i] = 0;
 	}
 }
 
 
 /***************************************************************************
  * MapEditClass::Add_To_List -- adds a TypeClass to the chooseable list     *
  *                                                                         *
  * Use this routine to add an object to the game object selection list.    *
  * This list is used by the Add_Object function. All items located in the  *
  * list will appear and be chooseable by that function. Make sure to       *
  * clear the list before adding a sequence of items to it. Clearing        *
  * the list is accomplished by the Clear_List() function.                  *
  *                                                                         *
  * INPUT:                                                                  *
  *      object      ptr to ObjectTypeClass to add                          *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      bool: was the object added to the list?  A failure could occur if  *
  *      NULL were passed in or the list is full.                           *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   06/04/1994 JLB : Created.                                             *
  *=========================================================================*/
 bool MapEditClass::Add_To_List(ObjectTypeClass const * object)
 {
 	/*
 	**	Add the object if there's room.
 	*/
 	if (object && ObjCount < MAX_EDIT_OBJECTS) {
 		Objects[ObjCount++] = object;
 
 		/*
 		**	Update type counters.
 		*/
 		switch (object->What_Am_I()) {
 			case RTTI_TEMPLATETYPE:
 				NumType[0]++;
 				break;
 
 			case RTTI_OVERLAYTYPE:
 				NumType[1]++;
 				break;
 
 			case RTTI_SMUDGETYPE:
 				NumType[2]++;
 				break;
 
 			case RTTI_TERRAINTYPE:
 				NumType[3]++;
 				break;
 
 			case RTTI_UNITTYPE:
 				NumType[4]++;
 				break;
 
 			case RTTI_INFANTRYTYPE:
 				NumType[5]++;
 				break;
 
 			case RTTI_VESSELTYPE:
 				NumType[6]++;
 				break;
 
 			case RTTI_BUILDINGTYPE:
 				NumType[7]++;
 				break;
 
 			case RTTI_AIRCRAFTTYPE:
 				NumType[8]++;
 				break;
 		}
 		return(true);
 	}
 
 	return(false);
 }
 
 
 /***************************************************************************
  * MapEditClass::AI -- The map editor's main logic                         *
  *                                                                         *
  * This routine overloads the parent's (DisplayClass) AI function.         *
  * It checks for any input specific to map editing, and calls the parent   *
  * AI routine to handle scrolling and other mainstream map stuff.          *
  *                                                                         *
  * If this detects one of its special input keys, it sets 'input' to 0     *
  * before calling the parent AI routine; this prevents input conflict.     *
  *                                                                         *
  * SUPPORTED INPUT:                                                        *
  * General:                                                                *
  *      F2/RMOUSE:            main menu                                    *
  *      F6:                  toggles show-passable mode                    *
  *      HOME:                  go to the Home Cell (scenario's start position)*
  *      SHIFT-HOME:            set the Home Cell to the current TacticalCell*
  *      ESC:                  exits to DOS                                 *
  * Object Placement:                                                       *
  *      INSERT:               go into placement mode                       *
  *      ESC:                  exit placement mode                          *
  *      LEFT/RIGHT:          prev/next placement object                    *
  *      PGUP/PGDN:            prev/next placement category                 *
  *      HOME:                  1st placement object (clear template)       *
  *      h/H:                  toggle house of placement object             *
  *      LMOUSE:               place the placement object                   *
  *      MOUSE MOTION:         "paint" with the placement object            *
  * Object selection:                                                       *
  *      LMOUSE:               select & "grab" current object               *
  *                           If no object is present where the mouse is    *
  *                           clicked, the current object is de-selected    *
  *                           If the same object is clicked on, it stays    *
  *                           selected. Also displays the object-editing    *
  *                           gadgets.                                      *
  *      LMOUSE RLSE:         release currently-grabbed object              *
  *      MOUSE MOTION:         if an object is grabbed, moves the object    *
  *      SHIFT|ALT|ARROW:      moves object in that direction               *
  *      DELETE               deletes currently-selected object             *
  * Object-editing controls:                                                *
  *      POPUP_GDI:            makes GDI the owner of this object           *
  *      POPUP_NOD:            makes NOD the owner of this object           *
  *      POPUP_MISSIONLIST:   sets that mission for this object             *
  *      POPUP_HEALTHGAUGE:   sets that health value for this object        *
  *      POPUP_FACINGDIAL:      sets the object's facing                    *
  *                                                                         *
  * Changed is set when you:                                                *
  *      - place an object                                                  *
  *      - move a grabbed object                                            *
  *      - delete an object                                                 *
  *      - size the map                                                     *
  *      - create a new scenario                                            *
  *   Changed is cleared when you:                                          *
  *      - Save the scenario                                                *
  *      - Load a scenario                                                  *
  *      - Play the scenario                                                *
  *                                                                         *
  * INPUT:                                                                  *
  *      input      KN_ value, 0 if none                                    *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      none.                                                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   10/20/1994 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::AI(KeyNumType & input, int x, int y)
 {
 	int rc;
 	MissionType mission;
 	int strength;
 	CELL cell;
 	int i;
 	int found;									// for removing a waypoint label
 	int waypt_idx;								// for labelling a waypoint
 	BaseNodeClass * node;						// for removing from an AI Base
 	HousesType house;
 	char wayname[4];
 
 	/*
 	**	Trap 'F2' regardless of whether we're in game or editor mode
 	*/
 	if (Debug_Flag) {
 		if ((input == KN_F2 && Session.Type == GAME_NORMAL) || input == (KN_F2 | KN_CTRL_BIT)) {
 			ScenarioInit = 0;
 
 			/*
 			** If we're in editor mode & Changed is set, prompt for saving changes
 			*/
 			if (Debug_Map && Changed) {
 				rc = WWMessageBox().Process("Save Changes?", TXT_YES, TXT_NO);
 				HidPage.Clear();
 				Flag_To_Redraw(true);
 				Render();
 
 				/*
 				**	User wants to save
 				*/
 				if (rc == 0) {
 
 					/*
 					**	If save cancelled, abort game
 					*/
 					if (Save_Scenario()!=0) {
 						input = KN_NONE;
 					} else {
 						Changed = 0;
 						Go_Editor(!Debug_Map);
 					}
 				} else {
 
 					/*
 					**	User doesn't want to save
 					*/
 					Go_Editor(!Debug_Map);
 				}
 			} else {
 				/*
 				** If we're in game mode, set Changed to 0 (so if we didn't save our
 				** changes above, they won't keep coming back to haunt us with continual
 				** Save Changes? prompts!)
 				*/
 				if (!Debug_Map) {
 					Changed = 0;
 				}
 				BaseGauge->Set_Value(Scen.Percent);
 				Go_Editor(!Debug_Map);
 			}
 		}
 	}
 
 	/*
 	**	For normal game mode, jump to the parent's AI routine.
 	*/
 	if (!Debug_Map) {
 		MouseClass::AI(input, x, y);
 		return;
 	}
 
 	::Frame++;
 
 	/*
 	**	Do special mouse processing if the mouse is over the map
 	*/
 	if (Get_Mouse_X() > TacPixelX && Get_Mouse_X() <
 		TacPixelX + Lepton_To_Pixel(TacLeptonWidth) &&
 		Get_Mouse_Y() > TacPixelY && Get_Mouse_Y() <
 		TacPixelY + Lepton_To_Pixel(TacLeptonHeight)) {
 
 		/*
 		**	When the mouse moves over a scrolling edge, ScrollClass changes its
 		**	shape to the appropriate arrow or NO symbol; it's our job to change it
 		**	back to normal (or whatever the shape is set to by Set_Default_Mouse())
 		**	when it re-enters the map area.
 		*/
 		if (CurTrigger) {
 			Override_Mouse_Shape(MOUSE_CAN_MOVE);
 		} else {
 			Override_Mouse_Shape(MOUSE_NORMAL);
 		}
 	}
 
 	/*
 	**	Set 'ZoneCell' to track the mouse cursor around over the map.  Do this
 	**	even if the map is scrolling.
 	*/
 	if (Get_Mouse_X() >= TacPixelX && Get_Mouse_X() <=
 		TacPixelX + Lepton_To_Pixel(TacLeptonWidth) &&
 		Get_Mouse_Y() >= TacPixelY && Get_Mouse_Y() <=
 		TacPixelY + Lepton_To_Pixel(TacLeptonHeight)) {
 
 		cell = Click_Cell_Calc(Get_Mouse_X(), Get_Mouse_Y());
 		if (cell != -1) {
 			Set_Cursor_Pos(cell);
 			if (PendingObject) {
 				Flag_To_Redraw(true);
 			}
 		}
 	}
 
 	/*
 	**	Check for mouse motion while left button is down.
 	*/
 	rc = Mouse_Moved();
 	if (LMouseDown && rc) {
 
 		/*
 		**	"Paint" mode: place current object, and restart placement
 		*/
 		if (PendingObject) {
 			Flag_To_Redraw(true);
 			if (Place_Object() == 0) {
 				Changed = 1;
 				Start_Placement();
 			}
 		} else {
 
 			/*
 			**	Move the currently-grabbed object
 			*/
 			if (GrabbedObject) {
 				GrabbedObject->Mark(MARK_CHANGE);
 				if (Move_Grabbed_Object() == 0) {
 					Changed = 1;
 				}
 			}
 		}
 	}
 
 	/*
 	**	Trap special editing keys; if one is detected, set 'input' to 0 to
 	**	prevent a conflict with parent's AI().
 	*/
 	switch (input) {
 		/*
 		** F2/RMOUSE = pop up main menu
 		*/
 		case KN_RMOUSE:
 
 			/*
 			**	Turn off placement mode
 			*/
 			if (PendingObject) {
 				if (BaseBuilding) {
 					Cancel_Base_Building();
 				} else {
 					Cancel_Placement();
 				}
 			}
 
 			/*
 			**	Turn off trigger placement mode
 			*/
 			if (CurTrigger) {
 				Stop_Trigger_Placement();
 			}
 
 			/*
 			**	Unselect object & hide popup controls
 			*/
 			if (CurrentObject.Count()) {
 				CurrentObject[0]->Unselect();
 				Popup_Controls();
 			}
 			Main_Menu();
 			input = KN_NONE;
 			break;
 
 		/*
 		**	F6 = toggle passable/impassable display
 		*/
 		case KN_F6:
 			Debug_Passable = (Debug_Passable == false);
 			HidPage.Clear();
 			Flag_To_Redraw(true);
 			input = KN_NONE;
 			break;
 
 		/*
 		**	INSERT = go into object-placement mode
 		*/
 		case KN_INSERT:
 			if (!PendingObject) {
 				/*
 				**	Unselect current object, hide popup controls
 				*/
 				if (CurrentObject.Count()) {
 					CurrentObject[0]->Unselect();
 					Popup_Controls();
 				}
 
 				/*
 				**	Go into placement mode
 				*/
 				Start_Placement();
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	ESC = exit placement mode, or exit to DOS
 		*/
 		case KN_ESC:
 
 			/*
 			**	Exit object placement mode
 			*/
 			if (PendingObject) {
 				if (BaseBuilding) {
 					Cancel_Base_Building();
 				} else {
 					Cancel_Placement();
 				}
 				input = KN_NONE;
 				break;
 			} else {
 
 				/*
 				**	Exit trigger placement mode
 				*/
 				if (CurTrigger) {
 					Stop_Trigger_Placement();
 					input = KN_NONE;
 					break;
 				} else {
 					rc = WWMessageBox().Process("Exit Scenario Editor?", TXT_YES, TXT_NO);
 					HidPage.Clear();
 					Flag_To_Redraw(true);
 					Render();
 
 					/*
 					**	User doesn't want to exit; return to editor
 					*/
 					if (rc==1) {
 						input = KN_NONE;
 						break;
 					}
 
 					/*
 					**	If changed, prompt for saving
 					*/
 					if (Changed) {
 						rc = WWMessageBox().Process("Save Changes?", TXT_YES, TXT_NO);
 						HidPage.Clear();
 						Flag_To_Redraw(true);
 						Render();
 
 						/*
 						**	User wants to save
 						*/
 						if (rc == 0) {
 
 							/*
 							**	If save cancelled, abort exit
 							*/
 							if (Save_Scenario()!=0) {
 								input = KN_NONE;
 								break;
 							} else {
 								Changed = 0;
 							}
 						}
 					}
 				}
 			}
 			//Prog_End();
 			Emergency_Exit(0);
 			break;
 
 		/*
 		**	LEFT = go to previous placement object
 		*/
 		case KN_LEFT:
 			if (PendingObject) {
 				Place_Prev();
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	RIGHT = go to next placement object
 		*/
 		case KN_RIGHT:
 			if (PendingObject) {
 				Place_Next();
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	PGUP = go to previous placement category
 		*/
 		case KN_PGUP:
 			if (PendingObject) {
 				Place_Prev_Category();
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	PGDN = go to next placement category
 		*/
 		case KN_PGDN:
 			if (PendingObject) {
 				Place_Next_Category();
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	HOME = jump to first placement object, or go to Home Cell
 		*/
 		case KN_HOME:
 			if (PendingObject) {
 				Place_Home();
 			} else {
 
 				/*
 				**	Set map position
 				*/
 				ScenarioInit++;
 				Set_Tactical_Position(Scen.Waypoint[WAYPT_HOME]);
 				ScenarioInit--;
 
 				/*
 				**	Force map to redraw
 				*/
 				HidPage.Clear();
 				Flag_To_Redraw(true);
 				Render();
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	SHIFT-HOME: set new Home Cell position
 		*/
 		case ((int)KN_HOME | (int)KN_SHIFT_BIT):
 			if (CurrentCell != 0) {
 
 			/*
 			** Unflag the old Home Cell, if there are no other waypoints
 			** pointing to it
 			*/
 			cell = Scen.Waypoint[WAYPT_HOME];
 
 			if (cell != -1) {
 				found = 0;
 				for (i = 0; i < WAYPT_COUNT; i++) {
 					if (i != WAYPT_HOME && Scen.Waypoint[i]==cell) {
 						found = 1;
 					}
 				}
 
 				if (found==0) {
 					(*this)[cell].IsWaypoint = 0;
 					Flag_Cell(cell);
 				}
 
 			}
 
 			/*
 			** Now set the new Home cell
 			*/
 //			Scen.Waypoint[WAYPT_HOME] = Coord_Cell(TacticalCoord);
 //			(*this)[TacticalCoord].IsWaypoint = 1;
 //			Flag_Cell(Coord_Cell(TacticalCoord));
 			Scen.Waypoint[WAYPT_HOME] = CurrentCell;
 			(*this)[CurrentCell].IsWaypoint = 1;
 			Flag_Cell(CurrentCell);
 
 			Changed = 1;
 			input = KN_NONE;
 }
 			break;
 
 		/*
 		**	SHIFT-R: set new Reinforcement Cell position.  Don't allow setting
 		**	the Reinf. Cell to the same as the Home Cell (for display purposes.)
 		*/
 		case ((int)KN_R | (int)KN_SHIFT_BIT):
 			if (CurrentCell==0 || CurrentCell==Scen.Waypoint[WAYPT_HOME]) {
 				break;
 			}
 
 			/*
 			** Unflag the old Reinforcement Cell, if there are no other waypoints
 			** pointing to it
 			*/
 			cell = Scen.Waypoint[WAYPT_REINF];
 
 			if (cell != -1) {
 				found = 0;
 				for (i = 0; i < WAYPT_COUNT; i++) {
 					if (i != WAYPT_REINF && Scen.Waypoint[i]==cell) {
 						found = 1;
 					}
 				}
 
 				if (found==0) {
 					(*this)[cell].IsWaypoint = 0;
 					Flag_Cell(cell);
 				}
 
 			}
 			/*
 			** Now set the new Reinforcement cell
 			*/
 			Scen.Waypoint[WAYPT_REINF] = CurrentCell;
 			(*this)[CurrentCell].IsWaypoint = 1;
 			Flag_Cell(CurrentCell);
 			Changed = 1;
 			input = KN_NONE;
 			break;
 
 		/*
 		**	ALT-Letter: Label a waypoint cell
 		*/
 		case ((int)KN_A | (int)KN_ALT_BIT):
 		case ((int)KN_B | (int)KN_ALT_BIT):
 		case ((int)KN_C | (int)KN_ALT_BIT):
 		case ((int)KN_D | (int)KN_ALT_BIT):
 		case ((int)KN_E | (int)KN_ALT_BIT):
 		case ((int)KN_F | (int)KN_ALT_BIT):
 		case ((int)KN_G | (int)KN_ALT_BIT):
 		case ((int)KN_H | (int)KN_ALT_BIT):
 		case ((int)KN_I | (int)KN_ALT_BIT):
 		case ((int)KN_J | (int)KN_ALT_BIT):
 		case ((int)KN_K | (int)KN_ALT_BIT):
 		case ((int)KN_L | (int)KN_ALT_BIT):
 		case ((int)KN_M | (int)KN_ALT_BIT):
 		case ((int)KN_N | (int)KN_ALT_BIT):
 		case ((int)KN_O | (int)KN_ALT_BIT):
 		case ((int)KN_P | (int)KN_ALT_BIT):
 		case ((int)KN_Q | (int)KN_ALT_BIT):
 		case ((int)KN_R | (int)KN_ALT_BIT):
 		case ((int)KN_S | (int)KN_ALT_BIT):
 		case ((int)KN_T | (int)KN_ALT_BIT):
 		case ((int)KN_U | (int)KN_ALT_BIT):
 		case ((int)KN_V | (int)KN_ALT_BIT):
 		case ((int)KN_W | (int)KN_ALT_BIT):
 		case ((int)KN_X | (int)KN_ALT_BIT):
 		case ((int)KN_Y | (int)KN_ALT_BIT):
 		case ((int)KN_Z | (int)KN_ALT_BIT):
 			if (CurrentCell != 0) {
 #ifdef WIN32
 				waypt_idx = (input & ~KN_ALT_BIT) - KN_A;
 #else
 				waypt_idx = KN_To_KA(input & 0x00ff) - KA_a;
 #endif
 				Update_Waypoint(waypt_idx);
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		** ALT-. : Designate an extended (2-letter) waypoint name
 		*/
 		case KN_PERIOD:
 		case ((int)KN_PERIOD | (int)KN_ALT_BIT):
 			if (CurrentCell != 0 && Get_Waypoint_Name(wayname)) {
 				int waynm = 0;
 				if (strlen(wayname)) {
 					wayname[0] = toupper(wayname[0]);
 					wayname[1] = toupper(wayname[1]);
 					if (wayname[0] >= 'A' && wayname[0] <= 'Z') {
 						waynm = wayname[0] - 'A';
 						if (wayname[1] >= 'A' && wayname[1] <= 'Z') {
 							waynm = (waynm+1)*26 + (wayname[1] - 'A');
 						}
 						if (waynm < WAYPT_HOME) Update_Waypoint(waynm);
 					}
 				}
 			}
 			input = KN_NONE;
 			break;
 
 #ifdef OBSOLETE
 		/*
 		**	ALT-1-4: Designate a cell as a capture-the-flag cell.
 		*/
 		case ((int)KN_1 | (int)KN_ALT_BIT):
 		case ((int)KN_2 | (int)KN_ALT_BIT):
 		case ((int)KN_3 | (int)KN_ALT_BIT):
 		case ((int)KN_4 | (int)KN_ALT_BIT):
 
 			/*
 			**	If there's a current cell, place the flag & waypoint there.
 			*/
 			if (CurrentCell != 0) {
 				waypt_idx = (Keyboard->To_ASCII((KeyNumType)(input & 0xff)) - KA_1);
 //				waypt_idx = (KN_To_KA(input & 0xff) - KA_1);
 				house = (HousesType)(HOUSE_MULTI1 + waypt_idx);
 				if (HouseClass::As_Pointer(house)) {
 					HouseClass::As_Pointer(house)->Flag_Attach(CurrentCell, true);
 				}
 			} else {
 
 				/*
 				**	If there's a current object, attach the flag to it and clear the
 				**	waypoint.
 				*/
 				if (CurrentObject[0] != 0) {
 					waypt_idx = (Keyboard->To_ASCII((KeyNumType)(input & 0xff)) - KA_1);
 					house = (HousesType)(HOUSE_MULTI1 + waypt_idx);
 					if (HouseClass::As_Pointer(house) && CurrentObject[0]->What_Am_I() == RTTI_UNIT) {
 						HouseClass::As_Pointer(house)->Flag_Attach((UnitClass *)CurrentObject[0], true);
 					}
 				}
 			}
 			input = KN_NONE;
 			break;
 #endif
 
 		/*
 		**	ALT-Space: Remove a waypoint designation
 		*/
 		case ((int)KN_SPACE | (int)KN_ALT_BIT):
 			if (CurrentCell != 0) {
 
 				/*
 				**	Loop through letter waypoints; if this cell is one of them,
 				**	clear that waypoint.
 				*/
 				for (i = 0 ; i < WAYPT_HOME; i++) {
 					if (Scen.Waypoint[i]==CurrentCell)
 						Scen.Waypoint[i] = -1;
 				}
 
 				/*
 				**	Loop through flag home values; if this cell is one of them, clear
 				**	that waypoint.
 				*/
 				for (i = 0; i < MAX_PLAYERS; i++) {
 					house = (HousesType)(HOUSE_MULTI1 + i);
 					if (HouseClass::As_Pointer(house) &&
 						CurrentCell == HouseClass::As_Pointer(house)->FlagHome)
 					HouseClass::As_Pointer(house)->Flag_Remove(As_Target(CurrentCell), true);
 				}
 
 				/*
 				**	If there are no more waypoints on this cell, clear the cell's
 				**	waypoint designation.
 				*/
 				if (Scen.Waypoint[WAYPT_HOME]!=CurrentCell &&
 					Scen.Waypoint[WAYPT_REINF]!=CurrentCell)
 					(*this)[CurrentCell].IsWaypoint = 0;
 				Changed = 1;
 				Flag_Cell(CurrentCell);
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	'H' = toggle current placement object's house
 		*/
 		case KN_H:
 		case ((int)KN_H | (int)KN_SHIFT_BIT):
 			if (PendingObject) {
 				Toggle_House();
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	Left-mouse click:
 		**	Button DOWN:
 		**	- Toggle LMouseDown
 		**	- If we're in placement mode, try to place the current object
 		**	- If success, re-enter placement mode
 		**	- Otherwise, try to select an object, and "grab" it if there is one
 		**	- If no object, then select that cell as the "current" cell
 		**	Button UP:
 		**	- Toggle LMouseDown
 		**	- release any grabbed object
 		*/
 		case ((int)MAP_AREA | (int)KN_BUTTON):
 
 			/*
 			**	Left Button DOWN
 			*/
 			if (Keyboard->Down(KN_LMOUSE)) {
 				LMouseDown = 1;
 
 				/*
 				**	Placement mode: place an object
 				*/
 				if (PendingObject) {
 					if (Place_Object()==0) {
 						Changed = 1;
 						Start_Placement();
 					}
 				} else {
 
 					/*
 					**	Place a trigger
 					*/
 					if (CurTrigger) {
 						Place_Trigger();
 						Changed = 1;
 					} else {
 
 						/*
 						**	Select an object or a cell
 						**	Check for double-click
 						*/
 						if (CurrentObject.Count() &&
 							((TickCount - LastClickTime) < 15)) {
 						;	// stub
 
 						} else {
 							/*
 							**	Single-click: select object
 							*/
 							if (Select_Object()==0) {
 								CurrentCell = 0;
 								Grab_Object();
 							} else {
 
 								/*
 								**	No object: select the cell
 								*/
 								CurrentCell = Click_Cell_Calc(Keyboard->MouseQX, Keyboard->MouseQY);
 								HidPage.Clear();
 								Flag_To_Redraw(true);
 								Render();
 							}
 						}
 					}
 				}
 				LastClickTime = TickCount();
 				input = KN_NONE;
 			} else {
 
 				/*
 				**	Left Button UP
 				*/
 				LMouseDown = 0;
 				GrabbedObject = 0;
 				input = KN_NONE;
 			}
 			break;
 
 		/*
 		**	SHIFT-ALT-Arrow: move the current object
 		*/
 		case (int)KN_UP | (int)KN_ALT_BIT | (int)KN_SHIFT_BIT:
 		case (int)KN_DOWN | (int)KN_ALT_BIT | (int)KN_SHIFT_BIT:
 		case (int)KN_LEFT | (int)KN_ALT_BIT | (int)KN_SHIFT_BIT:
 		case (int)KN_RIGHT | (int)KN_ALT_BIT | (int)KN_SHIFT_BIT:
 			if (CurrentObject.Count()) {
 				CurrentObject[0]->Move(KN_To_Facing(input));
 				Changed = 1;
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	DELETE: delete currently-selected object
 		*/
 		case KN_DELETE:
 
 			/*
 			**	Delete currently-selected object's trigger, or the object
 			*/
 			if (CurrentObject.Count()) {
 
 				/*
 				**	Delete trigger
 				*/
 				if (CurrentObject[0]->Trigger.Is_Valid()) {
 					CurrentObject[0]->Trigger = NULL;
 				} else {
 					/*
 					** If the current object is part of the AI's Base, remove it
 					** from the Base's Node list.
 					*/
 					if (CurrentObject[0]->What_Am_I()==RTTI_BUILDING &&
 						Base.Is_Node((BuildingClass *)CurrentObject[0])) {
 						node = Base.Get_Node((BuildingClass *)CurrentObject[0]);
 						Base.Nodes.Delete(*node);
 					}
 
 					/*
 					**	Delete current object
 					*/
 					delete CurrentObject[0];
 
 					/*
 					**	Hide the popup controls
 					*/
 					Popup_Controls();
 				}
 
 				/*
 				**	Force a redraw
 				*/
 				HidPage.Clear();
 				Flag_To_Redraw(true);
 				Changed = 1;
 			} else {
 
 				/*
 				**	Remove trigger from current cell
 				*/
 				if (CurrentCell) {
 					if ((*this)[CurrentCell].Trigger.Is_Valid()) {
 						(*this)[CurrentCell].Trigger = NULL;
 //						CellTriggers[CurrentCell] = NULL;
 
 						/*
 						**	Force a redraw
 						*/
 						HidPage.Clear();
 						Flag_To_Redraw(true);
 						Changed = 1;
 					}
 				}
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	TAB: select next object on the map
 		*/
 		case KN_TAB:
 			Select_Next();
 			input = KN_NONE;
 			break;
 
 		/*
 		**	Object-Editing button: House Button
 		*/
 		case POPUP_HOUSELIST|KN_BUTTON:
 			/*
 			**	Determine the house desired by examining the currently
 			**	selected index in the house list gadget.
 			*/
 			house = HousesType(((ListClass *)Buttons->Extract_Gadget(POPUP_HOUSELIST))->Current_Index());
 
 			/*
 			**	If that house doesn't own this object, try to transfer it
 			*/
 			if (CurrentObject[0]->Owner() != house) {
 				if (Change_House(house)) {
 					Changed = 1;
 				}
 			}
 //			Set_House_Buttons(CurrentObject[0]->Owner(), Buttons, POPUP_FIRST);
 			HidPage.Clear();
 			Buttons->Flag_List_To_Redraw();
 			Flag_To_Redraw(true);
 			input = KN_NONE;
 			break;
 
 //		case (POPUP_GDI | KN_BUTTON):
 //		case (POPUP_NOD | KN_BUTTON):
 //		case (POPUP_NEUTRAL | KN_BUTTON):
 //		case (POPUP_MULTI1 | KN_BUTTON):
 //		case (POPUP_MULTI2 | KN_BUTTON):
 //		case (POPUP_MULTI3 | KN_BUTTON):
 //		case (POPUP_MULTI4 | KN_BUTTON):
 //
 //			/*
 //			**	Convert input value into a house value; assume HOUSE_GOOD is 0
 //			*/
 //			house = (HousesType)( (input & (~KN_BUTTON)) - POPUP_FIRST);
 //
 //			/*
 //			**	If that house doesn't own this object, try to transfer it
 //			*/
 //			if (CurrentObject[0]->Owner()!=house) {
 //				if (Change_House(house)) {
 //					Changed = 1;
 //				}
 //			}
 //			Set_House_Buttons(CurrentObject[0]->Owner(), Buttons, POPUP_FIRST);
 //			HidPage.Clear();
 //			Flag_To_Redraw(true);
 //			input = KN_NONE;
 //			break;
 
 		case POPUP_SELLABLE|KN_BUTTON:
 			if (CurrentObject[0]->What_Am_I() == RTTI_BUILDING) {
 				BuildingClass * building = (BuildingClass *)CurrentObject[0];
 
 				if (building->Class->Level != -1) {
 //				if (building->Class->IsBuildable) {
 					building->IsAllowedToSell = (building->IsAllowedToSell == false);
 					building->Mark(MARK_CHANGE);
 				}
 				if (building->IsAllowedToSell) {
 					Sellable->Turn_On();
 				} else {
 					Sellable->Turn_Off();
 				}
 			}
 			break;
 
 		case POPUP_REBUILDABLE|KN_BUTTON:
 			if (CurrentObject[0]->What_Am_I() == RTTI_BUILDING) {
 				BuildingClass * building = (BuildingClass *)CurrentObject[0];
 
 				if (building->Class->Level != -1) {
 //				if (building->Class->IsBuildable) {
 					building->IsToRebuild = (building->IsToRebuild == false);
 					building->Mark(MARK_CHANGE);
 				}
 				if (building->IsToRebuild) {
 					Rebuildable->Turn_On();
 				} else {
 					Rebuildable->Turn_Off();
 				}
 			}
 			break;
 
 		/*
 		**	Object-Editing button: Mission
 		*/
 		case (POPUP_MISSIONLIST | KN_BUTTON):
 			if (CurrentObject[0]->Is_Techno()) {
 				/*
 				**	Set new mission
 				*/
 				mission = MapEditMissions[MissionList->Current_Index()];
 				if (CurrentObject[0]->Get_Mission() != mission) {
 					((TechnoClass *)CurrentObject[0])->Set_Mission(mission);
 					Changed = 1;
 					Buttons->Flag_List_To_Redraw();
 					Flag_To_Redraw(true);
 				}
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	Object-Editing button: Health
 		*/
 		case (POPUP_HEALTHGAUGE | KN_BUTTON):
 			if (CurrentObject[0]->Is_Techno()) {
 
 				/*
 				**	Derive strength from current gauge reading
 				*/
 				strength = CurrentObject[0]->Class_Of().MaxStrength * fixed(HealthGauge->Get_Value(), 256);
 //				strength = Fixed_To_Cardinal((unsigned)CurrentObject[0]->Class_Of().MaxStrength, (unsigned)HealthGauge->Get_Value());
 
 				/*
 				**	Clip to 1
 				*/
 				if (strength <= 0) {
 					strength = 1;
 				}
 
 				/*
 				**	Set new strength
 				*/
 				if (strength != CurrentObject[0]->Strength) {
 					CurrentObject[0]->Strength = strength;
 					HidPage.Clear();
 					Flag_To_Redraw(true);
 					Changed = 1;
 				}
 
 				/*
 				**	Update text label
 				*/
 				sprintf(HealthBuf, "%d", strength);
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	Object-Editing button: Facing
 		*/
 		case (POPUP_FACINGDIAL | KN_BUTTON):
 			if (CurrentObject[0]->Is_Techno()) {
 
 				/*
 				**	Set new facing
 				*/
 				if (FacingDial->Get_Direction() !=
 					((TechnoClass *)CurrentObject[0])->PrimaryFacing.Get()) {
 
 					/*
 					**	Set body's facing
 					*/
 					((TechnoClass *)CurrentObject[0])->PrimaryFacing.Set(FacingDial->Get_Direction());
 
 					/*
 					**	Set turret facing, if there is one
 					*/
 					if (CurrentObject[0]->What_Am_I()==RTTI_UNIT) {
 						((UnitClass *)CurrentObject[0])->SecondaryFacing.Set(FacingDial->Get_Direction());
 					}
 
 					HidPage.Clear();
 					Flag_To_Redraw(true);
 					Changed = 1;
 				}
 			}
 			input = KN_NONE;
 			break;
 
 		/*
 		**	Object-Editing button: Facing
 		*/
 		case (POPUP_BASEPERCENT | KN_BUTTON):
 			if (BaseGauge->Get_Value() != Scen.Percent) {
 				Scen.Percent = BaseGauge->Get_Value();
 				Build_Base_To(Scen.Percent);
 				HidPage.Clear();
 				Flag_To_Redraw(true);
 			}
 			input = KN_NONE;
 			break;
 
 		default:
 			break;
 	}
 
 	/*
 	**	Call parent's AI routine
 	*/
 	MouseClass::AI(input, x, y);
 }
 
 
 /***************************************************************************
  * MapEditClass::Draw_It -- overloaded Redraw routine                      *
  *                                                                         *
  * INPUT:                                                                  *
  *                                                                         *
  * OUTPUT:                                                                 *
  *                                                                         *
  * WARNINGS:                                                               *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/17/1994 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::Draw_It(bool forced)
 {
 	char const * label;
 	char buf[40];
 	char const * tptr;
 
 	MouseClass::Draw_It(forced);
 
 	if (!Debug_Map) {
 		return;
 	}
 
 	/*
 	**	Display the total value of all Tiberium on the map.
 	*/
 	Fancy_Text_Print("Tiberium=%ld   ", 0, 0, GadgetClass::Get_Color_Scheme(),
 		BLACK, TPF_EFNT | TPF_NOSHADOW, TotalValue);
 
 	/*
 	**	If there are no object controls displayed, just invoke parent's Redraw
 	**	and return.
 	*/
 	if (!Buttons) {
 		return;
 	}
 
 	/*
 	**	Otherwise, if 'display' is set, invoke the parent's Redraw to refresh
 	**	the HIDPAGE; then, update the buttons & text labels onto HIDPAGE;
 	**	then invoke the parent's Redraw to blit the HIDPAGE to SEENPAGE.
 	*/
 	if (forced) {
 
 		/*
 		**	Update the text labels
 		*/
 		if (CurrentObject.Count()) {
 			/*
 			**	Display the object's name & ID
 			*/
 			label = Text_String(CurrentObject[0]->Full_Name());
 			tptr = label;
 			sprintf(buf, "%s (%d)", tptr, CurrentObject[0]->As_Target());
 
 			/*
 			**	print the label
 			*/
 			Fancy_Text_Print (buf, 160, 0,
 				&ColorRemaps[PCOLOR_BROWN], TBLACK,
 				TPF_CENTER | TPF_NOSHADOW | TPF_EFNT);
 		}
 	}
 }
 
 
 /***************************************************************************
  * MapEditClass::Mouse_Moved -- checks for mouse motion                    *
  *                                                                         *
  * Reports whether the mouse has moved or not. This varies based on the    *
  * type of object currently selected. If there's an infantry object        *
  *   selected, mouse motion counts even within a cell; for all other types,*
  *   mouse motion counts only if the mouse changes cells.                  *
  *                                                                         *
  *   The reason this routine is needed is to prevent Paint-Mode from putting*
  *   gobs of trees and such into the same cell if the mouse moves just     *
  *   a little bit.                                                         *
  *                                                                         *
  * INPUT:                                                                  *
  *                                                                         *
  * OUTPUT:                                                                 *
  *                                                                         *
  * WARNINGS:                                                               *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/08/1994 BR : Created.                                              *
  *=========================================================================*/
 bool MapEditClass::Mouse_Moved(void)
 {
 	static int old_mx = 0;
 	static int old_my = 0;
 	static CELL old_zonecell = 0;
 	const ObjectTypeClass * objtype = NULL;
 	bool retcode = false;
 
 	/*
 	**	Return if no motion
 	*/
 	if (old_mx == Get_Mouse_X() && old_my == Get_Mouse_Y()) {
 		return(false);
 	}
 
 	/*
 	**	Get a ptr to ObjectTypeClass
 	*/
 	if (PendingObject) {
 		objtype = PendingObject;
 	} else {
 		if (GrabbedObject) {
 			objtype = &GrabbedObject->Class_Of();
 		} else {
 			old_mx = Get_Mouse_X();
 			old_my = Get_Mouse_Y();
 			old_zonecell = ZoneCell;
 			return(false);
 		}
 	}
 
 	/*
 	**	Infantry: mouse moved if any motion at all
 	*/
 	if (objtype->What_Am_I() == RTTI_INFANTRYTYPE) {
 		retcode = true;
 	} else {
 		/*
 		**	Others: mouse moved only if cell changed
 		*/
 		if (old_zonecell!=ZoneCell) {
 			retcode = true;
 		} else {
 			retcode = false;
 		}
 	}
 
 	old_mx = Get_Mouse_X();
 	old_my = Get_Mouse_Y();
 	old_zonecell = ZoneCell;
 	return(retcode);
 }
 
 
 /***************************************************************************
  * MapEditClass::Main_Menu -- main menu processor for map editor           *
  *                                                                         *
  * INPUT:                                                                  *
  *      none.                                                              *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      none.                                                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   10/20/1994 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::Main_Menu(void)
 {
 	char const * _menus[MAX_MAIN_MENU_NUM + 1];
 	int selection;						// option the user picks
 	bool process;						// menu stays up while true
 	int rc;
 
 	/*
 	**	Fill in menu items
 	*/
 	_menus[0] = "New Scenario";
 	_menus[1] = "Load Scenario";
 	_menus[2] = "Save Scenario";
 	_menus[3] = "Size Map";
 	_menus[4] = "Add Game Object";
 	_menus[5] = "Scenario Options";
 	_menus[6] = "AI Options";
 	_menus[7] = "Play Scenario";
 	_menus[8] = NULL;
 
 	/*
 	**	Main Menu loop
 	*/
 	Override_Mouse_Shape(MOUSE_NORMAL);	// display default mouse cursor
 	process = true;
 	while (process) {
 
 		/*
 		**	Invoke game callback, to update music
 		*/
 		Call_Back();
 
 		/*
 		**	Invoke menu
 		*/
 		Hide_Mouse();		// Do_Menu assumes the mouse is already hidden
 		selection = Do_Menu(&_menus[0], true);
 		Show_Mouse();
 		if (UnknownKey==KN_ESC || UnknownKey==KN_LMOUSE || UnknownKey==KN_RMOUSE) {
 			break;
 		}
 
 		/*
 		**	Process selection
 		*/
 		switch (selection) {
 
 			/*
 			**	New scenario
 			*/
 			case 0:
 				if (Changed) {
 					rc = WWMessageBox().Process("Save Changes?", TXT_YES, TXT_NO);
 					HidPage.Clear();
 					Flag_To_Redraw(true);
 					Render();
 					if (rc==0) {
 						if (Save_Scenario()!=0) {
 							break;
 						} else {
 							Changed = 0;
 						}
 					}
 				}
 				if (New_Scenario()==0) {
 					Scen.CarryOverMoney = 0;
 					Changed = 1;
 				}
 				process = false;
 				break;
 
 			/*
 			**	Load scenario
 			*/
 			case 1:
 				if (Changed) {
 					rc = WWMessageBox().Process("Save Changes?", TXT_YES, TXT_NO);
 					HidPage.Clear();
 					Flag_To_Redraw(true);
 					Render();
 					if (rc==0) {
 						if (Save_Scenario()!=0) {
 							break;
 						} else {
 							Changed = 0;
 						}
 					}
 				}
 				if (Load_Scenario()==0) {
 					Scen.CarryOverMoney = 0;
 					Changed = 0;
 				}
 				process = false;
 				break;
 
 			/*
 			**	Save scenario
 			*/
 			case 2:
 				if (Save_Scenario() == 0) {
 					Changed = 0;
 				}
 				process = false;
 				break;
 
 			/*
 			**	Edit map size
 			*/
 			case 3:
 				if (Size_Map(MapCellX, MapCellY, MapCellWidth, MapCellHeight)==0) {
 					process = false;
 					Changed = 1;
 				}
 				break;
 
 			/*
 			**	Add an object
 			*/
 			case 4:
 				if (Placement_Dialog() == 0) {
 					Start_Placement();
 					process = false;
 				}
 				break;
 
 			/*
 			**	Scenario options
 			*/
 			case 5:
 				if (Scenario_Dialog() == 0) {
 					Changed = 1;
 					process = false;
 				}
 				break;
 
 			/*
 			**	Other options
 			*/
 			case 6:
 				AI_Menu();
 				process = false;
 				break;
 
 			/*
 			**	Test-drive this scenario
 			*/
 			case 7:
 				if (Changed) {
 					rc = WWMessageBox().Process("Save Changes?", TXT_YES, TXT_NO, TXT_CANCEL);
 					HidPage.Clear();
 					Flag_To_Redraw(true);
 					Render();
 					if (rc == 2) return;
 					if (rc==0) {
 						if (Save_Scenario()!=0) {
 							break;
 						} else {
 							Changed = 0;
 						}
 					}
 				}
 				Changed = 0;
 				Debug_Map = false;
 				Start_Scenario(Scen.ScenarioName);
 				return;
 		}
 	}
 
 	/*
 	**	Restore the display:
 	**	- Clear HIDPAGE to erase any spurious drawing done by the menu system
 	**	- Invoke Flag_To_Redraw to tell DisplayClass to re-render the whole screen
 	**	- Invoke Redraw() to update the display
 	*/
 	HidPage.Clear();
 	Flag_To_Redraw(true);
 	Render();
 }
 
 
 /***************************************************************************
  * MapEditClass::AI_Menu -- menu of AI options                             *
  *                                                                         *
  * INPUT:                                                                  *
  *                                                                         *
  * OUTPUT:                                                                 *
  *                                                                         *
  * WARNINGS:                                                               *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/29/1994 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::AI_Menu(void)
 {
 	int selection;						// option the user picks
 	bool process;						// menu stays up while true
 	char const * _menus[MAX_AI_MENU_NUM + 1];
 
 	/*
 	**	Fill in menu strings
 	*/
 	_menus[0] = "Pre-Build a Base";
 	_menus[1] = "Edit Triggers";
 	_menus[2] = "Edit Teams";
 	_menus[3] = NULL;
 
 	/*
 	**	Main Menu loop
 	*/
 	Override_Mouse_Shape(MOUSE_NORMAL);		// display default mouse cursor
 	process = true;
 	while (process) {
 
 		/*
 		**	Invoke game callback, to update music
 		*/
 		Call_Back();
 
 		/*
 		**	Invoke menu
 		*/
 		Hide_Mouse();		// Do_Menu assumes the mouse is already hidden
 		selection = Do_Menu(&_menus[0], true);
 		Show_Mouse();
 		if (UnknownKey==KN_ESC || UnknownKey==KN_LMOUSE || UnknownKey==KN_RMOUSE) {
 			break;
 		}
 
 		/*
 		**	Process selection
 		*/
 		switch (selection) {
 			/*
 			**	Pre-Build a Base
 			*/
 			case 0:
 				Start_Base_Building();
 				process = false;
 				break;
 
 			/*
 			**	Trigger Editing
 			*/
 			case 1:
 				Handle_Triggers();
 				/*
 				**	Go into trigger placement mode
 				*/
 				if (CurTrigger) {
 					Start_Trigger_Placement();
 				}
 				process = false;
 				break;
 
 			/*
 			**	Team Editing
 			*/
 			case 2:
 				Handle_Teams("Teams");
 				process = false;
 				break;
 		}
 	}
 }
 
 
 /***************************************************************************
  * MapEditClass::Verify_House -- is this objtype ownable by this house?    *
  *                                                                         *
  * INPUT:                                                                  *
  *      house         house to check                                       *
  *      objtype      ObjectTypeClass to check                              *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      0 = isn't ownable, 1 = it is                                       *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/16/1994 BR : Created.                                              *
  *=========================================================================*/
 bool MapEditClass::Verify_House(HousesType house, ObjectTypeClass const * objtype)
 {
 	/*
 	**	Verify that new house can own this object
 	*/
 	return((objtype->Get_Ownable() & (1 << house)) != 0);
 }
 
 
 /***************************************************************************
  * MapEditClass::Cycle_House -- finds next valid house for object type     *
  *                                                                         *
  * INPUT:                                                                  *
  *      objtype      ObjectTypeClass ptr to get house for                  *
  *      curhouse      current house value to start with                    *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      HousesType that's valid for this object type                       *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/23/1994 BR : Created.                                              *
  *=========================================================================*/
 HousesType MapEditClass::Cycle_House(HousesType curhouse, ObjectTypeClass const *)
 {
 	HousesType count;			// prevents an infinite loop
 
 	/*
 	**	Loop through all house types, starting with the one after 'curhouse';
 	**	return the first one that's valid
 	*/
 	count = HOUSE_NONE;
 	while (1) {
 
 		/*
 		**	Go to next house
 		*/
 		curhouse++;
 		if (curhouse == HOUSE_COUNT) {
 			curhouse = HOUSE_FIRST;
 		}
 
 		/*
 		**	Count # iterations; don't go forever
 		*/
 		count++;
 		if (count == HOUSE_COUNT) {
 			curhouse = HOUSE_NONE;
 			break;
 		}
 
 		/*
 		**	Break if this is a valid house
 		*/
 //		if (HouseClass::As_Pointer(curhouse) && Verify_House(curhouse, objtype)) {
 			break;
 //		}
 	}
 
 	return(curhouse);
 }
 
 
 /***************************************************************************
  * MapEditClass::Fatal -- exits with error message                         *
  *                                                                         *
  * INPUT:                                                                  *
  *      code      tells which message to display; this minimizes the       *
  *               use of character strings in the code.                     *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      none.                                                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   12/12/1994 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::Fatal(int txt)
 {
 	//Prog_End();
 	printf("%s\n", txt);
 	Emergency_Exit(EXIT_FAILURE);
 }
 
 
 bool MapEditClass::Scroll_Map(DirType facing, int & distance, bool really)
 {
 	if (Debug_Map) {
 		/*
 		** The popup gadgets require the entire map to be redrawn if we scroll.
 		*/
 		if (really) {
 			Flag_To_Redraw(true);
 		}
 	}
 	return(MouseClass::Scroll_Map(facing, distance, really));
 }
 
 
 #ifdef OBSOLETE
 void MapEditClass::Flag_To_Redraw(bool complete)
 {
 	MouseClass::Flag_To_Redraw(complete);
 }
 #endif
 
 
 void MapEditClass::Detach(ObjectClass * object)
 {
 	if (GrabbedObject == object) {
 		GrabbedObject = 0;
 	}
 }
 
 bool MapEditClass::Get_Waypoint_Name(char wayptname[])
 {
 	/*
 	**	Dialog & button dimensions
 	*/
 	enum {
 		D_DIALOG_W = 100,											// dialog width
 		D_DIALOG_H = 56,											// dialog height
 		D_DIALOG_X = ((320 - D_DIALOG_W) / 2),				// centered x-coord
 		D_DIALOG_Y = ((200 - D_DIALOG_H) / 2),				// centered y-coord
 		D_DIALOG_CX = D_DIALOG_X + (D_DIALOG_W / 2),		// coord of x-center
 
 		D_TXT8_H = 11,												// ht of 8-pt text
 		D_MARGIN = 7,												// margin width/height
 
 		D_EDIT_W = D_DIALOG_W - (D_MARGIN * 2),
 		D_EDIT_H = 13,
 		D_EDIT_X = D_DIALOG_X + D_MARGIN,
 		D_EDIT_Y = D_DIALOG_Y + 20,
 
 		D_BUTTON_X = D_DIALOG_X + D_MARGIN,
 		D_BUTTON_Y = D_DIALOG_Y + 40,
 		D_BUTTON_W = 40,
 		D_BUTTON_H = 13,
 
 		D_CANCEL_X = D_DIALOG_X + 53,
 		D_CANCEL_Y = D_DIALOG_Y + 40,
 		D_CANCEL_W = 40,
 		D_CANCEL_H = 13,
 
 	};
 
 	/*
 	**	Button enumerations
 	*/
 	enum {
 		BUTTON_OK = 100,
 		BUTTON_CANCEL,
 		BUTTON_EDIT,
 	};
 
 	/*
 	**	Dialog variables
 	*/
 	bool cancel = false;						// true = user cancels
 	wayptname[0] = 0;
 
 	/*
 	**	Buttons
 	*/
 	ControlClass * commands = NULL;		// the button list
 
 	TextButtonClass button (BUTTON_OK, TXT_OK, TPF_EBUTTON, D_BUTTON_X, D_BUTTON_Y, D_BUTTON_W);
 	TextButtonClass cancelbtn (BUTTON_CANCEL, TXT_CANCEL, TPF_EBUTTON, D_CANCEL_X, D_CANCEL_Y, D_CANCEL_W);
 	EditClass editbtn (BUTTON_EDIT, wayptname, 3, TPF_EFNT|TPF_NOSHADOW, D_EDIT_X, D_EDIT_Y, D_EDIT_W, -1, EditClass::ALPHANUMERIC);
 
 	/*
 	**	Initialize.
 	*/
 	Set_Logic_Page(SeenBuff);
 
 	/*
 	**	Create the button list.
 	*/
 	commands = &button;
 	cancelbtn.Add_Tail(*commands);
 	editbtn.Add_Tail(*commands);
 	editbtn.Set_Focus();
 
 	/*
 	**	Main Processing Loop.
 	*/
 	bool firsttime = true;
 	bool display = true;
 	bool process = true;
 	while (process) {
 
 		/*
 		**	Invoke game callback.
 		*/
 		if (Session.Type == GAME_NORMAL) {
 			Call_Back();
 		} else if (Main_Loop()) {
 			process = false;
 			cancel = true;
 		}
 
 		/*
 		**	Refresh display if needed.
 		*/
 		if (display) {
 
 			/*
 			**	Display the dialog box.
 			*/
 			Hide_Mouse();
 			if (display) {
 				Dialog_Box(D_DIALOG_X, D_DIALOG_Y, D_DIALOG_W, D_DIALOG_H);
 //				Draw_Caption(caption, D_DIALOG_X, D_DIALOG_Y, D_DIALOG_W);
 
 			}
 
 			/*
 			**	Redraw the buttons.
 			*/
 			if (display) {
 				commands->Flag_List_To_Redraw();
 			}
 			Show_Mouse();
 			display = false;
 		}
 
 		/*
 		**	Get user input.
 		*/
 		KeyNumType input = commands->Input();
 
 		/*
 		**	The first time through the processing loop, set the edit
 		**	gadget to have the focus. The
 		**	focus must be set here since the gadget list has changed
 		**	and this change will cause any previous focus setting to be
 		**	cleared by the input processing routine.
 		*/
 		if (firsttime) {
 			firsttime = false;
 			editbtn.Set_Focus();
 			editbtn.Flag_To_Redraw();
 		}
 
 		/*
 		**	If the <RETURN> key was pressed, then default to the appropriate
 		**	action button according to the style of this dialog box.
 		*/
 		if (input == KN_RETURN) {
 			input = (KeyNumType)(BUTTON_OK|KN_BUTTON);
 		}
 
 		/*
 		**	Process input.
 		*/
 		switch (input) {
 			/*
 			** Load: if load fails, present a message, and stay in the dialog
 			** to allow the user to try another game
 			*/
 			case (BUTTON_OK | KN_BUTTON):
 				Hide_Mouse();
 				SeenPage.Clear();
 				GamePalette.Set();
 				Show_Mouse();
 				process = false;
 				cancel = false;
 				break;
 
 			/*
 			** ESC/Cancel: break
 			*/
 			case (KN_ESC):
 			case (BUTTON_CANCEL | KN_BUTTON):
 				Hide_Mouse();
 				SeenPage.Clear();
 				GamePalette.Set();
 				Show_Mouse();
 				cancel = true;
 				process = false;
 				break;
 
 			default:
 				break;
 		}
 	}
 
 	Map.Flag_To_Redraw(true);
 	if (cancel) return(false);
 
 	return(true);
 }
 
 void MapEditClass::Update_Waypoint(int waypt_idx)
 {
 	CELL cell;
 
 	/*
 	**	Unflag cell for this waypoint if there is one
 	*/
 	cell = Scen.Waypoint[waypt_idx];
 	if (cell != -1) {
 		if (Scen.Waypoint[WAYPT_HOME] != cell && Scen.Waypoint[WAYPT_REINF] != cell) {
 			(*this)[cell].IsWaypoint = 0;
 		}
 		Flag_Cell(cell);
 	}
 	Scen.Waypoint[waypt_idx] = CurrentCell;
 	(*this)[CurrentCell].IsWaypoint = 1;
 	Changed = 1;
 	Flag_Cell(CurrentCell);
 }
 
 
 /***************************************************************************
  * MapEditClass::Read_INI -- overloaded Read_INI function                  *
  *                                                                         *
  * Overloading this function gives the map editor a chance to initialize   *
  * certain values every time a new INI is read.                            *
  *                                                                         *
  * INPUT:                                                                  *
  *      buffer      INI staging area                                       *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      none.                                                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/16/1994 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::Read_INI(CCINIClass & ini)
 {
 	/*
 	**	Invoke parent's Read_INI
 	*/
 	Mono_Printf("We are in Read_INI\n");
 
 	MouseClass::Read_INI(ini);
 	BaseGauge->Set_Value(Scen.Percent);
 
 	Mono_Clear_Screen();
 	Mono_Printf("Scen.Percent = %d", Scen.Percent);
 
 //	BaseGauge->Set_Value(Scen.Percent);
 }
 
 
 void MapEditClass::Write_INI(CCINIClass & ini)
 {
 	MouseClass::Write_INI(ini);
 //	ini.Put_Int("Basic", "Percent", Scen.Percent);
 }
 
 #endif
 
 #include	"mapedsel.cpp"