CnC_Remastered_Collection

MAPEDSEL.CPP (19526B)

---

 //
 // 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/MAPEDSEL.CPP 1     3/03/97 10:25a Joe_bostic $ */
 /***************************************************************************
  **   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 : MAPEDSEL.CPP                             *
  *                                                                         *
  *                   Programmer : Bill Randolph                            *
  *                                                                         *
  *                   Start Date : November 18, 1994                        *
  *                                                                         *
  *                  Last Update : April 30, 1996 [JLB]                     *
  *                                                                         *
  *-------------------------------------------------------------------------*
  * Object-selection & manipulation routines                                *
  *-------------------------------------------------------------------------*
  * Functions:                                                              *
  *   MapEditClass::Change_House -- changes CurrentObject's house           *
  *   MapEditClass::Grab_Object -- grabs the current object                 *
  *   MapEditClass::Move_Grabbed_Object -- moves the grabbed object         *
  *   MapEditClass::Popup_Controls -- shows/hides the pop-up object controls*
  *   MapEditClass::Select_Next -- selects next object on the map           *
  *   MapEditClass::Select_Object -- selects an object for processing       *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #include	"function.h"
 
 #ifdef SCENARIO_EDITOR
 
 
 /***************************************************************************
  * Select_Object -- selects an object for processing                       *
  *                                                                         *
  * INPUT:                                                                  *
  *   none.                                                                 *
  *                                                                         *
  * OUTPUT:                                                                 *
  *   0 = object selected, -1 = none                                        *
  *                                                                         *
  * WARNINGS:                                                               *
  *   none.                                                                 *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/04/1994 BR : Created.                                              *
  *=========================================================================*/
 int MapEditClass::Select_Object(void)
 {
 	ObjectClass	* object=NULL;		// Generic object clicked on.
 	int			x,y;
 	CELL			cell;					// Cell that was selected.
 	int			rc=0;
 
 	/*
 	**	See if an object was clicked on
 	*/
 	x = Keyboard->MouseQX;
 	y = Keyboard->MouseQY;
 
 	/*
 	**	Get cell for x,y
 	*/
 	cell = Click_Cell_Calc(x, y);
 
 	/*
 	**	Convert x,y to offset from cell upper-left
 	*/
 	x = (x-TacPixelX) % ICON_PIXEL_W;
 	y = (y-TacPixelY) % ICON_PIXEL_H;
 
 	/*
 	**	Get object at that x,y
 	*/
 	object = Cell_Object(cell, x, y);
 
 	/*
 	**	If no object, unselect the current one
 	*/
 	if (!object) {
 		if (CurrentObject.Count()) {
 
 			/*
 			**	Unselect all current objects
 			*/
 			Unselect_All();
 
 			/*
 			**	Turn off object controls
 			*/
 			Popup_Controls();
 		}
 		rc = -1;
 	} else {
 
 		/*
 		**	Select object only if it's different
 		*/
 		if (!CurrentObject.Count() || (CurrentObject.Count() && object != CurrentObject[0])) {
 
 			/*
 			**	Unselect all current objects
 			*/
 			Unselect_All();
 			object->Select();
 
 			/*
 			**	Set mouse shape back to normal
 			*/
 			Set_Default_Mouse(MOUSE_NORMAL);
 			Override_Mouse_Shape(MOUSE_NORMAL);
 
 			/*
 			**	Show the popup controls
 			*/
 			Popup_Controls();
 		}
 	}
 
 	/*
 	**	Force map to redraw
 	*/
 	HidPage.Clear();
 	Flag_To_Redraw(true);
 
 	return(rc);
 }
 
 
 /***************************************************************************
  * MapEditClass::Select_Next -- selects next object on the map             *
  *                                                                         *
  * INPUT:                                                                  *
  *   none.                                                                 *
  *                                                                         *
  * OUTPUT:                                                                 *
  *   none                                                                  *
  *                                                                         *
  * WARNINGS:                                                               *
  *   none.                                                                 *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/22/1994 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::Select_Next(void)
 {
 	ObjectClass * obj;
 	CELL obj_cell;
 	int smap_w;						// screen map width in icons
 	int smap_h;						// screen map height in icons
 	int cell_x;						// cell-x of next object
 	int cell_y;						// cell-y of next object
 	int tcell_x;					// cell-x of TacticalCell
 	int tcell_y;					// cell-y of TacticalCell
 
 	/*
 	**	Get next object on the map
 	*/
 	obj = Map.Next_Object(CurrentObject[0]);
 
 	if (obj) {
 		/*
 		**	Unselect current object if there is one
 		*/
 		Unselect_All();
 
 	 	/*
 		**	Select this object
 		*/
 		obj->Select();
 	}
 
 	/*
 	**	Restore mouse shape to normal
 	*/
 	Set_Default_Mouse(MOUSE_NORMAL);
 	Override_Mouse_Shape(MOUSE_NORMAL);
 
 	/*
 	**	Show pop-up controls
 	*/
 	Popup_Controls();
 
 	/*
 	**	Make sure object is shown on the screen
 	*/
 	/*
 	**	compute screen map dimensions
 	*/
 	smap_w = Lepton_To_Cell(TacLeptonWidth);
 	smap_h = Lepton_To_Cell(TacLeptonHeight);
 
 	/*
 	**	compute x,y of object's cell
 	*/
 	obj_cell = Coord_Cell(CurrentObject[0]->Coord);
 	cell_x = Cell_X(obj_cell);
 	cell_y = Cell_Y(obj_cell);
 	tcell_x = Coord_XCell(TacticalCoord);
 	tcell_y = Coord_YCell(TacticalCoord);
 
 	/*
 	**	If object is off-screen, move map
 	*/
 	if (cell_x < tcell_x) {
 		tcell_x = cell_x;
 	} else {
 		if (cell_x >= tcell_x + smap_w) {
 			tcell_x = cell_x - smap_w + 1;
 		}
 	}
 
 	if (cell_y < tcell_y) {
 		tcell_y = cell_y;
 	} else {
 		if (cell_y >= tcell_y + smap_h) {
 			tcell_y = cell_y - smap_h + 1;
 		}
 	}
 
 	ScenarioInit++;
 	Set_Tactical_Position(XY_Coord(Cell_To_Lepton(tcell_x), Cell_To_Lepton(tcell_y)));
 	ScenarioInit--;
 
 	/*
 	**	Force map to redraw
 	*/
 	HidPage.Clear();
 	Flag_To_Redraw(true);
 }
 
 
 /***************************************************************************
  * MapEditClass::Popup_Controls -- shows/hides the pop-up object controls  *
  *                                                                         *
  * Call this routine whenever the CurrentObject changes. The routine will  *
  * selectively enable or disable the popup controls based on whether       *
  * CurrentObject is NULL, or if it's a Techno object, or what type of      *
  * Techno object it is.                                                    *
  *                                                                         *
  * INPUT:                                                                  *
  *      none.                                                              *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      none.                                                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/22/1994 BR : Created.                                              *
  *   04/30/1996 JLB : Revamped for new buttons and stuff.                  *
  *=========================================================================*/
 void MapEditClass::Popup_Controls(void)
 {
 	const TechnoTypeClass * objtype = NULL;
 	HousesType owner;							// object's current owner
 	int mission_index;						// object's current mission
 	int strength;								// object's 0-255 strength value
 	int i;
 
 	/*
 	**	Remove all buttons from GScreen's button list (so none of them provide
 	**	input any more); then, destroy the list by Zapping each button.  Then,
 	**	we'll have to add at least the MapArea button back to the Input button
 	**	list before we return, plus any other buttons to process input for.  We
 	**	always must add MapArea LAST in the list, so it doesn't intercept the
 	**	other buttons' input.
 	*/
 	Remove_A_Button(*HouseList);
 	Remove_A_Button(*MissionList);
 	Remove_A_Button(*HealthGauge);
 	Remove_A_Button(*HealthText);
 	Remove_A_Button(*FacingDial);
 	Remove_A_Button(*BaseGauge);
 	Remove_A_Button(*BaseLabel);
 	Remove_A_Button(*MapArea);
 
 	Remove_A_Button(*Sellable);
 	Remove_A_Button(*Rebuildable);
 
 	/*
 	**	If no current object, hide the list
 	*/
 	if (!CurrentObject.Count()) {
 		Add_A_Button(*BaseGauge);
 		Add_A_Button(*BaseLabel);
 		Add_A_Button(*MapArea);
 		return;
 	}
 
 	/*
 	**	If not Techno, no need for editing buttons
 	*/
 	if (!CurrentObject[0]->Is_Techno()) {
 		Add_A_Button(*BaseGauge);
 		Add_A_Button(*BaseLabel);
 		Add_A_Button(*MapArea);
 		return;
 	}
 
 	objtype = (TechnoTypeClass const *)&CurrentObject[0]->Class_Of();
 
 	/*
 	**	Get object's current values
 	*/
 	owner = CurrentObject[0]->Owner();
 	mission_index = 0;
 	for (i = 0; i < NUM_EDIT_MISSIONS; i++) {
 		if (CurrentObject[0]->Get_Mission() == MapEditMissions[i]) {
 			mission_index = i;
 		}
 	}
 	strength = CurrentObject[0]->Health_Ratio()*256;
 
 	switch (objtype->What_Am_I()) {
 		case RTTI_VESSELTYPE:
 		case RTTI_UNITTYPE:
 		case RTTI_INFANTRYTYPE:
 		case RTTI_AIRCRAFTTYPE:
 			MissionList->Set_Selected_Index(mission_index);
 			HealthGauge->Set_Value(strength);
 			sprintf(HealthBuf, "%d", CurrentObject[0]->Strength);
 			FacingDial->Set_Direction(((TechnoClass *)CurrentObject[0])->PrimaryFacing);
 
 			/*
 			**	Make the list.
 			*/
 			Add_A_Button(*HealthGauge);
 			Add_A_Button(*HouseList);
 			HouseList->Set_Selected_Index(owner);
 			Add_A_Button(*MissionList);
 			Add_A_Button(*HealthText);
 			Add_A_Button(*FacingDial);
 			break;
 
 		case RTTI_BUILDINGTYPE:
 			HealthGauge->Set_Value(strength);
 			sprintf(HealthBuf, "%d", CurrentObject[0]->Strength);
 			Add_A_Button(*HealthGauge);
 			Add_A_Button(*HouseList);
 			HouseList->Set_Selected_Index(owner);
 			Add_A_Button(*HealthText);
 
 			Add_A_Button(*Sellable);
 			if (((BuildingClass*)CurrentObject[0])->IsAllowedToSell) {
 				Sellable->Turn_On();
 			} else {
 				Sellable->Turn_Off();
 			}
 			Add_A_Button(*Rebuildable);
 			if (((BuildingClass*)CurrentObject[0])->IsToRebuild) {
 				Rebuildable->Turn_On();
 			} else {
 				Rebuildable->Turn_Off();
 			}
 
 			if (objtype->IsTurretEquipped) {
 				FacingDial->Set_Direction(((TechnoClass *) CurrentObject[0])->PrimaryFacing);
 				Add_A_Button(*FacingDial);
 			}
 			break;
 	}
 
 	/*
 	**	Add the map area last, so it's "underneath" the other buttons, and won't
 	**	intercept input for those buttons.
 	*/
 	Add_A_Button(*BaseGauge);
 	Add_A_Button(*BaseLabel);
 	Add_A_Button(*MapArea);
 }
 
 
 /***************************************************************************
  * MapEditClass::Grab_Object -- grabs the current object                   *
  *                                                                         *
  * INPUT:                                                                  *
  *      none.                                                              *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      none.                                                              *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/07/1994 BR : Created.                                              *
  *=========================================================================*/
 void MapEditClass::Grab_Object(void)
 {
 	CELL cell;
 
 	if (CurrentObject.Count()) {
 		GrabbedObject = CurrentObject[0];
 
 		/*
 		**	Find out which cell 'ZoneCell' is in relation to the object's current cell
 		*/
 		cell = Coord_Cell(GrabbedObject->Coord);
 		GrabOffset = cell - ZoneCell;
 	}
 }
 
 
 /***************************************************************************
  * MapEditClass::Move_Grabbed_Object -- moves the grabbed object           *
  *                                                                         *
  * INPUT:                                                                  *
  *      none.                                                              *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      0 = object moved, -1 = it didn't                                   *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/07/1994 BR : Created.                                              *
  *=========================================================================*/
 int MapEditClass::Move_Grabbed_Object(void)
 {
 	COORDINATE new_coord = 0;
 	int retval = -1;
 
 	/*
 	**	Lift up the object
 	*/
 	GrabbedObject->Mark(MARK_UP);
 
 	/*
 	**	If infantry, use a free spot in this cell
 	*/
 	if (GrabbedObject->Is_Infantry()) {
 
 		if (Is_Spot_Free(Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()))) {
 			new_coord = Closest_Free_Spot(Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()));
 
 			/*
 			**	Clear the occupied bit in this infantry's cell.
 			*/
 			((InfantryClass *)GrabbedObject)->Clear_Occupy_Bit(GrabbedObject->Coord);
 		} else {
 			new_coord = NULL;
 		}
 
 	} else {
 
 		/*
 		**	Non-infantry: use cell's center coordinate
 		*/
 		new_coord = Cell_Coord(ZoneCell + GrabOffset);
 
 		if (GrabbedObject->What_Am_I() == RTTI_BUILDING ||
 			GrabbedObject->What_Am_I() == RTTI_TERRAIN) {
 
 			new_coord = Coord_Whole(new_coord);
 		}
 
 		/*
 		**	Try to place object at new coordinate
 		*/
 		if (GrabbedObject->Can_Enter_Cell(Coord_Cell(new_coord)) != MOVE_OK) {
 			new_coord = NULL;
 		}
 	}
 	if (new_coord != NULL) {
 
 		/*
 		** If this object is part of the AI's Base list, change the coordinate
 		** in the Base's Node list.
 		*/
 		if (GrabbedObject->What_Am_I()==RTTI_BUILDING &&
 			Base.Get_Node((BuildingClass *)GrabbedObject))
 				Base.Get_Node((BuildingClass *)GrabbedObject)->Cell = Coord_Cell(new_coord);
 
 		GrabbedObject->Coord = new_coord;
 		retval = 0;
 	}
 	GrabbedObject->Mark(MARK_DOWN);
 
 	/*
 	**	For infantry, set the bit in its new cell marking that spot as occupied.
 	*/
 	if (GrabbedObject->Is_Infantry()) {
 		((InfantryClass *)GrabbedObject)->Set_Occupy_Bit(new_coord);
 	}
 
 	/*
 	**	Re-select the object, and reset the mouse pointer
 	*/
 	Set_Default_Mouse(MOUSE_NORMAL);
 	Override_Mouse_Shape(MOUSE_NORMAL);
 
 	Flag_To_Redraw(true);
 
 	return(retval);
 }
 
 
 /***************************************************************************
  * MapEditClass::Change_House -- changes CurrentObject's house             *
  *                                                                         *
  * INPUT:                                                                  *
  *      newhouse      house to change to                                   *
  *                                                                         *
  * OUTPUT:                                                                 *
  *      1 = house was changed, 0 = it wasn't                               *
  *                                                                         *
  * WARNINGS:                                                               *
  *      none.                                                              *
  *                                                                         *
  * HISTORY:                                                                *
  *   11/17/1994 BR : Created.                                              *
  *=========================================================================*/
 bool MapEditClass::Change_House(HousesType newhouse)
 {
 	TechnoClass *tp;
 
 	/*
 	**	Return if no current object
 	*/
 	if (!CurrentObject.Count()) {
 		return(false);
 	}
 
 	/*
 	**	Only techno objects can be owned by a house; return if not a techno
 	*/
 	if (!CurrentObject[0]->Is_Techno()) {
 		return(false);
 	}
 
 	/*
 	**	You can't change the house if the object is part of the AI's Base.
 	*/
 	if (CurrentObject[0]->What_Am_I()==RTTI_BUILDING && Base.Is_Node((BuildingClass *)CurrentObject[0])) {
 		return(false);
 	}
 
 	/*
 	**	Verify that the target house exists
 	*/
 	if (HouseClass::As_Pointer(newhouse)==NULL) {
 		return(false);
 	}
 
 	/*
 	**	Verify that this is a valid owner
 	*/
 //	if (!Verify_House(newhouse, &CurrentObject[0]->Class_Of())) {
 //		return(false);
 //	}
 
 	/*
 	**	Change the house
 	*/
 	tp = (TechnoClass *)CurrentObject[0];
 	tp->House = HouseClass::As_Pointer(newhouse);
 
 	tp->IsOwnedByPlayer = false;
 	if (tp->House == PlayerPtr) {
 		tp->IsOwnedByPlayer = true;
 	}
 
 	return(true);
 }
 
 
 #endif