// // 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/MAPEDPLC.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 : MAPEDPLC.CPP * * * * Programmer : Bill Randolph * * * * Start Date : November 18, 1994 * * * * Last Update : May 12, 1996 [JLB] * * * *-------------------------------------------------------------------------* * Object-placement routines * *-------------------------------------------------------------------------* * Functions: * * MapEditClass::Build_Base_To -- builds the AI base to the given percent* * MapEditClass::Cancel_Base_Building -- stops base-building mode * * MapEditClass::Cancel_Placement -- cancels placement mode * * MapEditClass::Place_Home -- homes the placement object * * MapEditClass::Place_Next -- while placing object, goes to next * * MapEditClass::Place_Next_Category -- places next object category * * MapEditClass::Place_Object -- attempts to place the current object * * MapEditClass::Place_Prev -- while placing object, goes to previous * * MapEditClass::Place_Prev_Category -- places previous object category * * MapEditClass::Place_Trigger -- assigns trigger to object or cell * * MapEditClass::Placement_Dialog -- adds an object to the scenario * * MapEditClass::Set_House_Buttons -- toggles house buttons for btn list * * MapEditClass::Start_Base_Building -- starts base-building mode * * MapEditClass::Start_Placement -- enters placement mode * * MapEditClass::Start_Trigger_Placement -- enters trigger placement mode* * MapEditClass::Stop_Trigger_Placement -- exits trigger placement mode * * MapEditClass::Toggle_House -- toggles current placement object's house* * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #include "function.h" #ifdef SCENARIO_EDITOR /*************************************************************************** * MapEditClass::Placement_Dialog -- adds an object to the scenario * * * * This function sets LastChoice & LastHouse to the values chosen * * by the user. It's up to the caller to call Start_Placement to enter * * placement mode. * * This routine does not modify PendingObject or PendingHouse. * * * * 旼컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴커 * * � [GDI] [NOD] [Neutral] � * * � � * * � 旼컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴� � * * � � � [Template] � * * � � � [Overlay ] � * * � � � [Smudge ] � * * � � � [Terrain ] � * * � � (Object picture) � [Unit ] � * * � � � [Infantry] � * * � � � [Aircraft] � * * � � � [Building] � * * � � � � * * � 읕컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴� 旼컴컴커 � * * � [<-] [->] �(Grid)� � * * � � � � * * � [OK] [Cancel] 읕컴컴켸 � * * 읕컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴켸 * * * * INPUT: * * none. * * * * OUTPUT: * * 0 = OK, -1 = cancel * * * * WARNINGS: * * none. * * * * HISTORY: * * 10/21/1994 BR : Created. * * 12/13/1995 JLB : Fixed house buttons to handle expanded house list. * * 05/12/1996 JLB : Handles hi-res. * *=========================================================================*/ int MapEditClass::Placement_Dialog(void) { HousesType house; RemapControlType * scheme = GadgetClass::Get_Color_Scheme(); /* ** Dialog & button dimensions */ enum { D_DIALOG_W = 400, D_DIALOG_H = 180, D_DIALOG_X = 0, D_DIALOG_Y = 0, D_DIALOG_CX = D_DIALOG_X + (D_DIALOG_W / 2), D_TXT8_H = 11, D_MARGIN = 7, D_PICTURE_W = 152, // must be divisible by 8! D_PICTURE_H = 105, D_PICTURE_X = D_DIALOG_X + 35, // must start on a byte boundary! D_PICTURE_Y = D_DIALOG_Y + D_MARGIN + D_TXT8_H + D_MARGIN, D_PICTURE_CX = D_PICTURE_X + D_PICTURE_W / 2, D_GDI_W = 65, D_GDI_H = 9, D_GDI_X = D_PICTURE_X+D_PICTURE_W+5, D_GDI_Y = D_PICTURE_Y, D_LEFT_W = 45, D_LEFT_H = 9, D_LEFT_X = D_PICTURE_CX - 5 - D_LEFT_W, D_LEFT_Y = D_PICTURE_Y + D_PICTURE_H + D_MARGIN, D_RIGHT_W = 45, D_RIGHT_H = 9, D_RIGHT_X = D_PICTURE_CX + 5, D_RIGHT_Y = D_PICTURE_Y + D_PICTURE_H + D_MARGIN, D_TEMPLATE_W = 70, D_TEMPLATE_H = 9, D_TEMPLATE_X = D_DIALOG_X + D_DIALOG_W - D_MARGIN - D_TEMPLATE_W - 30, D_TEMPLATE_Y = D_PICTURE_Y, D_OVERLAY_W = 70, D_OVERLAY_H = 9, D_OVERLAY_X = D_DIALOG_X + D_DIALOG_W - D_MARGIN - D_OVERLAY_W - 30, D_OVERLAY_Y = D_TEMPLATE_Y + D_TEMPLATE_H, D_SMUDGE_W = 70, D_SMUDGE_H = 9, D_SMUDGE_X = D_DIALOG_X + D_DIALOG_W - D_MARGIN - D_SMUDGE_W - 30, D_SMUDGE_Y = D_OVERLAY_Y + D_OVERLAY_H, D_TERRAIN_W = 70, D_TERRAIN_H = 9, D_TERRAIN_X = D_DIALOG_X + D_DIALOG_W - D_MARGIN - D_TERRAIN_W - 30, D_TERRAIN_Y = D_SMUDGE_Y + D_SMUDGE_H, D_UNIT_W = 70, D_UNIT_H = 9, D_UNIT_X = D_DIALOG_X + D_DIALOG_W - D_MARGIN - D_UNIT_W - 30, D_UNIT_Y = D_TERRAIN_Y + D_TERRAIN_H, D_INFANTRY_W = 70, D_INFANTRY_H = 9, D_INFANTRY_X = D_DIALOG_X + D_DIALOG_W - D_MARGIN - D_INFANTRY_W - 30, D_INFANTRY_Y = D_UNIT_Y + D_UNIT_H, D_AIRCRAFT_W = 70, D_AIRCRAFT_H = 9, D_AIRCRAFT_X = D_DIALOG_X + D_DIALOG_W - D_MARGIN - D_AIRCRAFT_W - 30, D_AIRCRAFT_Y = D_INFANTRY_Y + D_INFANTRY_H, D_BUILDING_W = 70, D_BUILDING_H = 9, D_BUILDING_X = D_DIALOG_X + D_DIALOG_W - D_MARGIN - D_BUILDING_W - 30, D_BUILDING_Y = D_AIRCRAFT_Y + D_AIRCRAFT_H, D_AIR_W = 70, D_AIR_H = 9, D_AIR_X = D_DIALOG_X + D_DIALOG_W - D_MARGIN - D_AIR_W - 30, D_AIR_Y = D_BUILDING_Y + D_BUILDING_H, D_OK_W = 45, D_OK_H = 9, D_OK_X = D_PICTURE_CX - D_OK_W - 5, D_OK_Y = D_DIALOG_Y + D_DIALOG_H - D_OK_H - D_MARGIN - 15, D_CANCEL_W = 45, D_CANCEL_H = 9, D_CANCEL_X = D_PICTURE_CX + 5, D_CANCEL_Y = D_DIALOG_Y + D_DIALOG_H - D_CANCEL_H - D_MARGIN - 15, GRIDSIZE = 10, GRIDBLOCK_W = 3, GRIDBLOCK_H = 3, D_GRID_X = D_DIALOG_X + D_DIALOG_W - (GRIDSIZE * GRIDBLOCK_W) - D_MARGIN - 35, D_GRID_Y = D_DIALOG_Y + D_DIALOG_H - (GRIDSIZE * GRIDBLOCK_H) - D_MARGIN - 35, }; /* ** Button enumerations: */ enum { BUTTON_GDI=100, BUTTON_HOUSE, BUTTON_NEXT, BUTTON_PREV, BUTTON_OK, BUTTON_CANCEL, BUTTON_TEMPLATE, BUTTON_OVERLAY, BUTTON_SMUDGE, BUTTON_TERRAIN, BUTTON_UNIT, BUTTON_INFANTRY, BUTTON_AIRCRAFT, BUTTON_BUILDING, BUTTON_AIR, }; /* ** Dialog variables */ bool cancel = false; // true = user cancels const ObjectTypeClass * curobj; // Working object pointer. int x,y; // for drawing the grid KeyNumType input; // user input short const * occupy; // ptr into object's OccupyList int cell; // cell index for parsing OccupyList int i; int typeindex; // index of class type /* ** Buttons */ ControlClass * commands; ListClass housebtn(BUTTON_HOUSE, D_GDI_X, D_GDI_Y, 60, 8*16, TPF_EFNT | TPF_NOSHADOW, MFCD::Retrieve("EBTN-UP.SHP"), MFCD::Retrieve("EBTN-DN.SHP")); for (house = HOUSE_FIRST; house < HOUSE_COUNT; house++) { housebtn.Add_Item(HouseTypeClass::As_Reference(house).IniName); } house = HOUSE_FIRST; TextButtonClass nextbtn(BUTTON_NEXT, TXT_RIGHT, TPF_EBUTTON, D_RIGHT_X, D_RIGHT_Y, D_RIGHT_W, D_RIGHT_H); TextButtonClass prevbtn(BUTTON_PREV, TXT_LEFT, TPF_EBUTTON, D_LEFT_X, D_LEFT_Y, D_LEFT_W, D_LEFT_H); TextButtonClass okbtn(BUTTON_OK, "OK", TPF_EBUTTON, D_OK_X, D_OK_Y, D_OK_W, D_OK_H); TextButtonClass cancelbtn(BUTTON_CANCEL, "Cancel", TPF_EBUTTON, D_CANCEL_X, D_CANCEL_Y, D_CANCEL_W, D_CANCEL_H); TextButtonClass templatebtn(BUTTON_TEMPLATE, "Template", TPF_EBUTTON, D_TEMPLATE_X, D_TEMPLATE_Y, D_TEMPLATE_W, D_TEMPLATE_H); TextButtonClass overlaybtn(BUTTON_OVERLAY, "Overlay", TPF_EBUTTON, D_OVERLAY_X, D_OVERLAY_Y, D_OVERLAY_W, D_OVERLAY_H); TextButtonClass smudgebtn(BUTTON_SMUDGE, "Smudge", TPF_EBUTTON, D_SMUDGE_X, D_SMUDGE_Y, D_SMUDGE_W, D_SMUDGE_H); TextButtonClass terrainbtn(BUTTON_TERRAIN, "Terrain", TPF_EBUTTON, D_TERRAIN_X, D_TERRAIN_Y, D_TERRAIN_W, D_TERRAIN_H); TextButtonClass unitbtn(BUTTON_UNIT, "Unit", TPF_EBUTTON, D_UNIT_X, D_UNIT_Y, D_UNIT_W, D_UNIT_H); TextButtonClass infantrybtn(BUTTON_INFANTRY, "Infantry", TPF_EBUTTON, D_INFANTRY_X, D_INFANTRY_Y, D_INFANTRY_W, D_INFANTRY_H); TextButtonClass aircraftbtn(BUTTON_AIRCRAFT, "Ships", TPF_EBUTTON, D_AIRCRAFT_X, D_AIRCRAFT_Y, D_AIRCRAFT_W, D_AIRCRAFT_H); TextButtonClass buildingbtn(BUTTON_BUILDING, "Building", TPF_EBUTTON, D_BUILDING_X, D_BUILDING_Y, D_BUILDING_W, D_BUILDING_H); TextButtonClass airbtn(BUTTON_AIR, "Aircraft", TPF_EBUTTON, D_AIR_X, D_AIR_Y, D_AIR_W, D_AIR_H); /* ** Initialize addable objects list; we must do this every time in case one ** of the object pools has become exhausted; that object won't be available ** for adding. (Skip aircraft, since they won't be used in the editor.) */ Clear_List(); TemplateTypeClass::Prep_For_Add(); OverlayTypeClass::Prep_For_Add(); SmudgeTypeClass::Prep_For_Add(); TerrainTypeClass::Prep_For_Add(); UnitTypeClass::Prep_For_Add(); InfantryTypeClass::Prep_For_Add(); VesselTypeClass::Prep_For_Add(); BuildingTypeClass::Prep_For_Add(); AircraftTypeClass::Prep_For_Add(); /* ** Compute offset of each class type in the Objects array */ TypeOffset[0] = 0; for (i = 1; i < NUM_EDIT_CLASSES; i++) { TypeOffset[i] = TypeOffset[i-1] + NumType[i-1]; } /* ** Return if no objects to place */ if (!ObjCount) { return(-1); } /* ** Initialize */ Set_Logic_Page(SeenBuff); if (LastChoice >= ObjCount) { LastChoice = 0; } curobj = Objects[LastChoice]; // current object to choose commands = &nextbtn; housebtn.Add_Tail(*commands); prevbtn.Add_Tail(*commands); okbtn.Add_Tail(*commands); cancelbtn.Add_Tail(*commands); templatebtn.Add_Tail(*commands); overlaybtn.Add_Tail(*commands); smudgebtn.Add_Tail(*commands); terrainbtn.Add_Tail(*commands); unitbtn.Add_Tail(*commands); infantrybtn.Add_Tail(*commands); aircraftbtn.Add_Tail(*commands); buildingbtn.Add_Tail(*commands); airbtn.Add_Tail(*commands); /* ** Make sure the recorded house selection matches the house list ** box selection. */ LastHouse = HousesType(housebtn.Current_Index()); /* ** Main processing loop */ bool display = true; bool process = true; while (process) { /* ** Invoke game callback */ Call_Back(); /* ** Refresh display if needed */ if (display) { /* ** Display the dialog box */ Hide_Mouse(); Dialog_Box(D_DIALOG_X, D_DIALOG_Y, D_DIALOG_W, D_DIALOG_H); Draw_Caption(TXT_PLACE_OBJECT, D_DIALOG_X, D_DIALOG_Y, D_DIALOG_W); /* ** Display the current object: ** - save the current window dimensions ** - adjust the window size to the actual drawable area ** - draw the shape ** - reset the window dimensions */ WindowList[WINDOW_EDITOR][WINDOWX] = D_PICTURE_X; WindowList[WINDOW_EDITOR][WINDOWY] = D_PICTURE_Y; WindowList[WINDOW_EDITOR][WINDOWWIDTH] = D_PICTURE_W; WindowList[WINDOW_EDITOR][WINDOWHEIGHT] = D_PICTURE_H; Change_Window((int)WINDOW_EDITOR); Draw_Box(D_PICTURE_X, D_PICTURE_Y, D_PICTURE_W, D_PICTURE_H, BOXSTYLE_DOWN, false); curobj->Display(WinW/2, WinH>>1, WINDOW_EDITOR, LastHouse); // curobj->Display(WinW<<2, WinH>>1, WINDOW_EDITOR, LastHouse); /* ** Erase the grid */ LogicPage->Fill_Rect(D_GRID_X - GRIDBLOCK_W * 2, D_GRID_Y, D_GRID_X + GRIDSIZE * GRIDBLOCK_W, D_GRID_Y + GRIDSIZE * GRIDBLOCK_H, BLACK); /* ** Draw a box for every cell occupied */ occupy = curobj->Occupy_List(); while ( (*occupy) != REFRESH_EOL) { cell = (*occupy); occupy++; x = D_GRID_X + ((cell % MAP_CELL_W) * GRIDBLOCK_W); y = D_GRID_Y + ((cell / MAP_CELL_W) * GRIDBLOCK_H); LogicPage->Fill_Rect(x, y, x + GRIDBLOCK_W - 1, y + GRIDBLOCK_H - 1, scheme->Bright); } /* ** Draw the grid itself */ for (y = 0; y <= GRIDSIZE; y++) { for (x = 0; x <= GRIDSIZE; x++) { LogicPage->Draw_Line(D_GRID_X + x * GRIDBLOCK_W, D_GRID_Y, D_GRID_X + x * GRIDBLOCK_W, D_GRID_Y + GRIDSIZE * GRIDBLOCK_H, scheme->Shadow); } LogicPage->Draw_Line(D_GRID_X, D_GRID_Y + y * GRIDBLOCK_H, D_GRID_X + GRIDSIZE * GRIDBLOCK_W, D_GRID_Y + y * GRIDBLOCK_H, scheme->Shadow); } /* ** Print the object's label from the class's Full_Name(). ** Warning: Text_String returns an EMS pointer, so standard string ** functions won't work! */ Fancy_Text_Print (curobj->Full_Name(), D_PICTURE_CX, D_PICTURE_Y + D_MARGIN, scheme, TBLACK, TPF_CENTER | TPF_EFNT | TPF_NOSHADOW); /* ** Redraw buttons ** Figure out which class category we're in & highlight that button ** This updates 'typeindex', which is used below, and it also updates ** the category button states. */ i = 0; for (typeindex = 0; typeindex < NUM_EDIT_CLASSES; typeindex++) { i += NumType[typeindex]; if (LastChoice < i) break; } templatebtn.Turn_Off(); overlaybtn.Turn_Off(); smudgebtn.Turn_Off(); terrainbtn.Turn_Off(); unitbtn.Turn_Off(); infantrybtn.Turn_Off(); aircraftbtn.Turn_Off(); airbtn.Turn_Off(); buildingbtn.Turn_Off(); switch (typeindex + BUTTON_TEMPLATE) { case BUTTON_TEMPLATE: templatebtn.Turn_On(); break; case BUTTON_OVERLAY: overlaybtn.Turn_On(); break; case BUTTON_SMUDGE: smudgebtn.Turn_On(); break; case BUTTON_TERRAIN: terrainbtn.Turn_On(); break; case BUTTON_UNIT: unitbtn.Turn_On(); break; case BUTTON_INFANTRY: infantrybtn.Turn_On(); break; case BUTTON_AIRCRAFT: aircraftbtn.Turn_On(); break; case BUTTON_AIR: airbtn.Turn_On(); break; case BUTTON_BUILDING: buildingbtn.Turn_On(); break; } /* ** Redraw buttons */ commands->Draw_All(); Show_Mouse(); display = false; } /* ** Get user input */ input = commands->Input(); /* ** Process user input */ switch (input) { /* ** GDI House */ case (BUTTON_HOUSE | KN_BUTTON): house = HousesType(housebtn.Current_Index()); /* ** Set flags & buttons */ LastHouse = house; display = true; break; /* ** Next in list */ case (KN_RIGHT): case (BUTTON_NEXT | KN_BUTTON): /* ** Increment to next obj */ LastChoice++; if (LastChoice == ObjCount) { LastChoice = 0; } curobj = Objects[LastChoice]; nextbtn.Turn_Off(); display = true; break; /* ** Previous in list */ case (KN_LEFT): case (BUTTON_PREV | KN_BUTTON): /* ** Decrement to prev obj */ LastChoice--; if (LastChoice < 0) { LastChoice = ObjCount-1; } curobj = Objects[LastChoice]; prevbtn.Turn_Off(); display = true; break; /* ** Select a class type */ case (BUTTON_TEMPLATE | KN_BUTTON): case (BUTTON_OVERLAY | KN_BUTTON): case (BUTTON_SMUDGE | KN_BUTTON): case (BUTTON_TERRAIN | KN_BUTTON): case (BUTTON_UNIT | KN_BUTTON): case (BUTTON_INFANTRY | KN_BUTTON): case (BUTTON_AIRCRAFT | KN_BUTTON): case (BUTTON_BUILDING | KN_BUTTON): case (BUTTON_AIR | KN_BUTTON): /* ** Find index of class */ typeindex = input - (BUTTON_TEMPLATE | KN_BUTTON); /* ** If no objects of that type, do nothing */ if (NumType[typeindex]==0) { display = true; break; } /* ** Set current object */ LastChoice = TypeOffset[typeindex]; curobj = Objects[LastChoice]; display = true; break; /* ** Next category */ case KN_PGDN: typeindex++; if (typeindex==NUM_EDIT_CLASSES) { typeindex = 0; } /* ** Set current object */ LastChoice = TypeOffset[typeindex]; curobj = Objects[LastChoice]; display = true; break; /* ** Previous category */ case KN_PGUP: typeindex--; if (typeindex < 0) { typeindex = NUM_EDIT_CLASSES - 1; } /* ** Set current object */ LastChoice = TypeOffset[typeindex]; curobj = Objects[LastChoice]; display = true; break; /* ** Jump to 1st choice */ case KN_HOME: LastChoice = 0; /* ** Set current object */ curobj = Objects[LastChoice]; display = true; break; /* ** OK */ case (KN_RETURN): case (BUTTON_OK | KN_BUTTON): cancel = false; process = false; break; /* ** Cancel */ case (KN_ESC): case (BUTTON_CANCEL | KN_BUTTON): cancel = true; process = false; break; default: break; } } /* ** Redraw the display */ HidPage.Clear(); Flag_To_Redraw(true); Render(); if (cancel) { return(-1); } return(0); } /*************************************************************************** * MapEditClass::Start_Placement -- enters placement mode * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 11/04/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Start_Placement(void) { /* ** Initialize addable objects list; we must do this every time in case one ** of the object pools has become exhausted; that object won't be available ** for adding. These must be added in the same order expected by the ** object selection dialog (same as button order). */ Clear_List(); TemplateTypeClass::Prep_For_Add(); OverlayTypeClass::Prep_For_Add(); SmudgeTypeClass::Prep_For_Add(); TerrainTypeClass::Prep_For_Add(); UnitTypeClass::Prep_For_Add(); InfantryTypeClass::Prep_For_Add(); VesselTypeClass::Prep_For_Add(); BuildingTypeClass::Prep_For_Add(); AircraftTypeClass::Prep_For_Add(); /* ** Compute offset of each class type in the Objects array */ TypeOffset[0] = 0; for (int i = 1; i < NUM_EDIT_CLASSES; i++) { TypeOffset[i] = TypeOffset[i-1] + NumType[i-1]; } /* ** Create the placement object: ** - For normal placement mode, use the last-used index into Objects ** (LastChoice), and the last-used house (LastHouse). ** - For base-building mode, force the object to be a building, and use the ** House specified in the Base object */ if (!BaseBuilding) { if (LastChoice >= ObjCount) { LastChoice = ObjCount - 1; } PendingObject = Objects[LastChoice]; PendingHouse = LastHouse; PendingObjectPtr = PendingObject->Create_One_Of(HouseClass::As_Pointer(LastHouse)); } else { if (LastChoice < TypeOffset[7]) { LastChoice = TypeOffset[7]; } if (LastChoice >= ObjCount) { LastChoice = ObjCount - 1; } PendingObject = Objects[LastChoice]; PendingHouse = LastHouse = Base.House; PendingObjectPtr = PendingObject->Create_One_Of(HouseClass::As_Pointer(LastHouse)); } /* ** Error if no more objects available */ if (!PendingObjectPtr) { WWMessageBox().Process("No more objects of this type available."); HidPage.Clear(); Flag_To_Redraw(true); Render(); PendingObject = NULL; if (BaseBuilding) { Cancel_Base_Building(); } return; } /* ** Set the placement cursor */ Set_Cursor_Pos(); Set_Cursor_Shape(PendingObject->Occupy_List()); } /*************************************************************************** * MapEditClass::Place_Object -- attempts to place the current object * * * * Placement of "real" objects is simply checked via their Unlimbo routine.* * Placement of templates is more complex: * * - for every cell in the template's OccupyList, check for objects * * already in that cell by looking at the cell's OccupyList & * * OverlapList * * - "lift" all the objects in the cell by Mark'ing them * * - temporarily place the template in that cell * * - try to Unlimbo all the objects that were in the cell. If any * * objects fail to Unlimbo onto that template, the template cannot * * be placed here * * * * It is assumed that the object being placed is a "new" object; the * * object's strength & mission are not set during Unlimbo. * * * * INPUT: * * none. * * * * OUTPUT: * * 0 = OK, -1 = unable to place * * * * WARNINGS: * * none. * * * * HISTORY: * * 11/04/1994 BR : Created. * *=========================================================================*/ int MapEditClass::Place_Object(void) { CELL template_cell; // cell being checked for template COORDINATE obj_coord; // coord of occupier object int okflag; // OK to place a template? short const * occupy; // ptr into template's OccupyList ObjectClass * occupier; // occupying object TemplateType save_ttype; // for saving cell's TType unsigned char save_ticon; // for saving cell's TIcon // BaseNodeClass node; // for adding to an AI Base /* ** Placing a template: ** - first lift up any objects in the cell ** - place the template, and try to replace the objects; if they won't go ** back, the template can't go there */ //ScenarioInit++; if (PendingObject->What_Am_I() == RTTI_TEMPLATETYPE) { /* ** Loop through all cells this template will occupy */ okflag = true; occupy = PendingObject->Occupy_List(); while ((*occupy) != REFRESH_EOL) { /* ** Check this cell for an occupier */ template_cell = (ZoneCell+ZoneOffset) + (*occupy); if ((*this)[template_cell].Cell_Occupier()) { occupier = (*this)[template_cell].Cell_Occupier(); /* ** Save object's coordinates */ obj_coord = occupier->Coord; /* ** Place the object in limbo */ occupier->Mark(MARK_UP); /* ** Set the cell's template values */ save_ttype = (*this)[template_cell].TType; save_ticon = (*this)[template_cell].TIcon; (*this)[template_cell].TType = ((TemplateTypeClass *)PendingObject)->Type; (*this)[template_cell].TIcon = Cell_X(*occupy) + Cell_Y(*occupy) * ((TemplateTypeClass *)PendingObject)->Width; (*this)[template_cell].Recalc_Attributes(); /* ** Try to put the object back down */ if (occupier->Can_Enter_Cell(Coord_Cell(obj_coord)) != MOVE_OK) { okflag = false; } /* ** Put everything back the way it was */ (*this)[template_cell].TType = save_ttype; (*this)[template_cell].TIcon = save_ticon; (*this)[template_cell].Recalc_Attributes(); /* ** Major error if can't replace the object now */ occupier->Mark(MARK_DOWN); } occupy++; } /* ** If it's still OK after ALL THAT, place the template */ if (okflag) { if (PendingObjectPtr->Unlimbo(Cell_Coord(ZoneCell + ZoneOffset))) { /* ** Loop through all cells occupied by this template, and clear the ** smudge & overlay. */ occupy = PendingObject->Occupy_List(); while ((*occupy) != REFRESH_EOL) { /* ** Get cell for this occupy item */ template_cell = (ZoneCell+ZoneOffset) + (*occupy); /* ** Clear smudge & overlay */ (*this)[template_cell].Overlay = OVERLAY_NONE; (*this)[template_cell].OverlayData = 0; (*this)[template_cell].Smudge = SMUDGE_NONE; /* ** make adjacent cells recalc attrib's */ (*this)[template_cell].Recalc_Attributes(); (*this)[template_cell].Wall_Update(); (*this)[template_cell].Concrete_Calc(); occupy++; } /* ** Set flags etc */ PendingObjectPtr = 0; PendingObject = 0; PendingHouse = HOUSE_NONE; Set_Cursor_Shape(0); //ScenarioInit--; TotalValue = Overpass(); Flag_To_Redraw(false); return(0); } /* ** Failure to deploy results in a returned failure code. */ //ScenarioInit--; return(-1); } /* ** Not OK; return error */ //ScenarioInit--; return(-1); } /* ** Placing infantry: Infantry can go into cell sub-positions, so find the ** sub-position closest to the mouse & put him there */ if (PendingObject->What_Am_I() == RTTI_INFANTRYTYPE) { /* ** Find cell sub-position */ if (Is_Spot_Free(Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y()))) { obj_coord = Closest_Free_Spot(Pixel_To_Coord(Get_Mouse_X(), Get_Mouse_Y())); } else { obj_coord = NULL; } /* ** No free spots; don't place the object */ if (obj_coord == NULL) { //ScenarioInit--; return(-1); } /* ** Unlimbo the object */ if (PendingObjectPtr->Unlimbo(obj_coord)) { ((InfantryClass *)PendingObjectPtr)->Set_Occupy_Bit(obj_coord); // Map[obj_coord].Flag.Composite |= // (1 << CellClass::Spot_Index(obj_coord)); PendingObjectPtr = 0; PendingObject = 0; PendingHouse = HOUSE_NONE; Set_Cursor_Shape(0); //ScenarioInit--; return(0); } //ScenarioInit--; return(-1); } /* ** Placing an object */ if (PendingObjectPtr->Unlimbo(Cell_Coord(ZoneCell + ZoneOffset))) { /* ** Update the Tiberium computation if we're placing an overlay */ if (PendingObject->What_Am_I() == RTTI_OVERLAYTYPE && ((OverlayTypeClass *)PendingObject)->IsTiberium) { TotalValue = Overpass(); Flag_To_Redraw(false); } /* ** If we're building a base, add this building to the base's Node list. */ if (BaseBuilding && PendingObject->What_Am_I() == RTTI_BUILDINGTYPE) { // node.Type = ((BuildingTypeClass *)PendingObject)->Type; // node.Cell = Coord_Cell(PendingObjectPtr->Coord); Base.Nodes.Add(BaseNodeClass(((BuildingTypeClass *)PendingObject)->Type, Coord_Cell(PendingObjectPtr->Coord))); } PendingObjectPtr = 0; PendingObject = 0; PendingHouse = HOUSE_NONE; Set_Cursor_Shape(0); //ScenarioInit--; return(0); } return(-1); } /*************************************************************************** * MapEditClass::Cancel_Placement -- cancels placement mode * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 11/04/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Cancel_Placement(void) { /* ** Delete the placement object */ delete PendingObjectPtr; PendingObject = 0; PendingObjectPtr = 0; PendingHouse = HOUSE_NONE; /* ** Restore cursor shape */ Set_Cursor_Shape(0); /* ** Redraw the map to erase old leftovers */ HidPage.Clear(); Flag_To_Redraw(true); Render(); } /*************************************************************************** * MapEditClass::Place_Next -- while placing object, goes to next * * * * - Deletes the current 'PendingObjectPtr' * * - Increments LastChoice * * - Tries to create a new 'PendingObjectPtr'; if fails, keeps * * incrementing until it gets it * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 11/03/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Place_Next(void) { delete PendingObjectPtr; PendingObjectPtr = NULL; PendingObject = NULL; /* ** Loop until we create a valid object */ while (!PendingObjectPtr) { /* ** Go to next object in Objects list */ LastChoice++; if (LastChoice == ObjCount) { /* ** If we're in normal placement mode, wrap to the 1st object; ** if we're in base-building mode, wrap to the 1st building */ if (!BaseBuilding) { LastChoice = 0; } else { LastChoice = TypeOffset[7]; } } /* ** Create placement object */ PendingObject = Objects[LastChoice]; PendingHouse = LastHouse; PendingObjectPtr = PendingObject->Create_One_Of(HouseClass::As_Pointer(PendingHouse)); if (!PendingObjectPtr) { PendingObject = NULL; } } /* ** Set the new cursor shape */ Set_Cursor_Pos(); Set_Cursor_Shape(0); Set_Cursor_Shape(PendingObject->Occupy_List()); /* ** Redraw the map to erase old leftovers */ HidPage.Clear(); Flag_To_Redraw(true); Render(); } /*************************************************************************** * MapEditClass::Place_Prev -- while placing object, goes to previous * * * * - Deletes the current 'PendingObjectPtr' * * - Decrements LastChoice * * - Tries to create a new 'PendingObjectPtr'; if fails, keeps * * decrementing until it gets it * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 11/03/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Place_Prev(void) { delete PendingObjectPtr; PendingObjectPtr = NULL; PendingObject = NULL; /* ** Loop until we create a valid object */ while (!PendingObjectPtr) { /* ** Go to prev object in Objects list */ LastChoice--; /* ** If we're in normal placement mode, wrap at the 1st object. ** If we're building a base, wrap at the 1st building. */ if (!BaseBuilding) { if (LastChoice < 0) { LastChoice = ObjCount - 1; } } else { if (LastChoice < TypeOffset[7]) { LastChoice = ObjCount - 1; } } /* ** Create placement object */ PendingObject = Objects[LastChoice]; PendingHouse = LastHouse; PendingObjectPtr = PendingObject->Create_One_Of(HouseClass::As_Pointer(PendingHouse)); if (!PendingObjectPtr) { PendingObject = NULL; } } /* ** Set the new cursor shape */ Set_Cursor_Pos(); Set_Cursor_Shape(0); Set_Cursor_Shape(PendingObject->Occupy_List()); /* ** Redraw the map to erase old leftovers */ HidPage.Clear(); Flag_To_Redraw(true); Render(); } /*************************************************************************** * MapEditClass::Place_Next_Category -- places next category of object * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 11/03/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Place_Next_Category(void) { int i; /* ** Don't allow this command if we're building a base; the only valid ** category for base-building is buildings. */ if (BaseBuilding) { return; } delete PendingObjectPtr; PendingObjectPtr = NULL; PendingObject = NULL; /* ** Go to next category in Objects list */ i = LastChoice; while (Objects[i]->What_Am_I() == Objects[LastChoice]->What_Am_I()) { i++; if (i == ObjCount) { i = 0; } } LastChoice = i; /* ** Loop until we create a valid object */ while (!PendingObjectPtr) { /* ** Get house for this object type */ // if (!Verify_House(LastHouse, Objects[LastChoice])) { // LastHouse = Cycle_House(LastHouse, Objects[LastChoice]); // } /* ** Create placement object */ PendingObject = Objects[LastChoice]; PendingHouse = LastHouse; PendingObjectPtr = PendingObject->Create_One_Of(HouseClass::As_Pointer(PendingHouse)); /* ** If this one failed, try the next */ if (!PendingObjectPtr) { PendingObject = NULL; LastChoice++; if (LastChoice == ObjCount) { LastChoice = 0; } } } /* ** Set the new cursor shape */ Set_Cursor_Pos(); Set_Cursor_Shape(0); Set_Cursor_Shape(PendingObject->Occupy_List()); /* ** Redraw the map to erase old leftovers */ HidPage.Clear(); Flag_To_Redraw(true); Render(); } /*************************************************************************** * MapEditClass::Place_Prev_Category -- places previous category of object * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 11/03/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Place_Prev_Category(void) { int i; /* ** Don't allow this command if we're building a base; the only valid ** category for base-building is buildings. */ if (BaseBuilding) { return; } delete PendingObjectPtr; PendingObjectPtr = NULL; PendingObject = NULL; /* ** Go to prev category in Objects list */ i = LastChoice; /* ** Scan for start of this category */ while (Objects[i]->What_Am_I() == Objects[LastChoice]->What_Am_I()) { i--; if (i < 0) { i = ObjCount - 1; } } i--; if (i < 0) i = ObjCount-1; LastChoice = i; /* ** Scan for the previous category */ while (Objects[i]->What_Am_I() == Objects[LastChoice]->What_Am_I()) { i--; if (i < 0) { i = ObjCount - 1; } } i++; if (i >= ObjCount) i = 0; LastChoice = i; /* ** Loop until we create a valid object */ while (!PendingObjectPtr) { /* ** Get house for this object type */ // if (!Verify_House(LastHouse, Objects[LastChoice])) { // LastHouse = Cycle_House(LastHouse, Objects[LastChoice]); // } /* ** Create placement object */ PendingObject = Objects[LastChoice]; PendingHouse = LastHouse; PendingObjectPtr = PendingObject->Create_One_Of(HouseClass::As_Pointer(PendingHouse)); /* ** If this one failed, try the next */ if (!PendingObjectPtr) { PendingObject = NULL; LastChoice--; if (LastChoice < 0) { LastChoice = ObjCount - 1; } } } /* ** Set the new cursor shape */ Set_Cursor_Pos(); Set_Cursor_Shape(0); Set_Cursor_Shape(PendingObject->Occupy_List()); /* ** Redraw the map to erase old leftovers */ HidPage.Clear(); Flag_To_Redraw(true); Render(); } /*************************************************************************** * MapEditClass::Place_Home -- homes the placement object * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 11/03/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Place_Home(void) { delete PendingObjectPtr; PendingObjectPtr = NULL; PendingObject = NULL; /* ** Don't allow this command if we're building a base; the only valid ** category for base-building is buildings. */ if (BaseBuilding) { return; } /* ** Loop until we create a valid object */ LastChoice = 0; while (!PendingObjectPtr) { /* ** Get house for this object type */ if (!Verify_House(LastHouse, Objects[LastChoice])) { LastHouse = Cycle_House(LastHouse, Objects[LastChoice]); } /* ** Create placement object */ PendingObject = Objects[LastChoice]; PendingHouse = LastHouse; PendingObjectPtr = PendingObject->Create_One_Of(HouseClass::As_Pointer(PendingHouse)); /* ** If this one failed, try the next */ if (!PendingObjectPtr) { PendingObject = NULL; LastChoice++; if (LastChoice == ObjCount) { LastChoice = 0; } } } /* ** Set the new cursor shape */ Set_Cursor_Pos(); Set_Cursor_Shape(0); Set_Cursor_Shape(PendingObject->Occupy_List()); /* ** Redraw the map to erase old leftovers */ HidPage.Clear(); Flag_To_Redraw(true); Render(); } /*************************************************************************** * MapEditClass::Toggle_House -- toggles current placement object's house * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 11/04/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Toggle_House(void) { TechnoClass *tp; /* ** Don't allow this command if we're building a base; the only valid ** house for base-building is the one assigned to the base. */ if (BaseBuilding) { return; } /* ** Only techno objects can be owned by a house; return if not a techno */ if (!PendingObjectPtr->Is_Techno()) { return; } /* ** Select the house that will own this object */ LastHouse = Cycle_House(PendingObjectPtr->Owner(), PendingObject); /* ** Change the house */ tp = (TechnoClass *)PendingObjectPtr; tp->House = HouseClass::As_Pointer(LastHouse); /* ** Set house variables to new house */ PendingHouse = LastHouse; } /*************************************************************************** * MapEditClass::Set_House_Buttons -- toggles house buttons for btn list * * * * Looks in the given button list for the given GDI, NOD & Neutral button * * id's. Sets the On/Off state of the buttons based on the given house, * * only if that button is found in the list. * * * * INPUT: * * house house to set buttons to * * btnlist ptr to button list to search * * base_id button ID for GDI; assumes other id's are sequential* * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 11/23/1994 BR : Created. * * 01/26/1996 JLB : Uses new house selection list method. * *=========================================================================*/ void MapEditClass::Set_House_Buttons(HousesType house, GadgetClass *, int ) //void MapEditClass::Set_House_Buttons(HousesType house, GadgetClass * btnlist, int base_id) { HouseList->Set_Selected_Index(house); #ifdef NEVER HousesType h; int id; TextButtonClass * btn; /* ** Loop through all houses, searching the button list for each one. */ for (h = HOUSE_FIRST; h < HOUSE_COUNT; h++) { /* ** Compute the desired button ID; get a pointer to the button */ id = (int)h + base_id; btn = (TextButtonClass *)btnlist->Extract_Gadget(id); if (btn) { /* ** If this house value is the desired one, turn the button on; ** otherwise, turn it off. */ if (h == house) { btn->Turn_On(); } else { btn->Turn_Off(); } } } #endif } /*************************************************************************** * MapEditClass::Start_Trigger_Placement -- enters trigger placement mode * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 12/01/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Start_Trigger_Placement(void) { Set_Default_Mouse(MOUSE_CAN_MOVE); Override_Mouse_Shape(MOUSE_CAN_MOVE); } /*************************************************************************** * MapEditClass::Stop_Trigger_Placement -- exits trigger placement mode * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 12/01/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Stop_Trigger_Placement(void) { CurTrigger = NULL; Set_Default_Mouse(MOUSE_NORMAL); Override_Mouse_Shape(MOUSE_NORMAL); } /*************************************************************************** * MapEditClass::Place_Trigger -- assigns trigger to object or cell * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 12/01/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Place_Trigger(void) { ObjectClass * object=NULL; // Generic object clicked on. int x,y; CELL cell; // Cell that was selected. /* ** 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); /* ** Assign trigger to an object */ AttachType a1 = CurTrigger->Attaches_To(); if (object && (a1 & ATTACH_OBJECT) != 0) { if (CurTrigger) { TriggerClass * tt = Find_Or_Make(CurTrigger); if (tt) { object->Trigger = tt; } } } else { /* ** Assign trigger to a cell */ if ((a1 & ATTACH_CELL) != 0) { if (CurTrigger) { TriggerClass * tt = Find_Or_Make(CurTrigger); Map[cell].Trigger = tt; } // CellTriggers[cell] = CurTrigger; } } /* ** Force map to redraw */ HidPage.Clear(); Flag_To_Redraw(true); } /*************************************************************************** * MapEditClass::Start_Base_Building -- starts base-building mode * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 12/01/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Start_Base_Building(void) { /* ** Fully build the base so the user can edit it */ Build_Base_To(100); /* ** Start placement mode */ BaseBuilding = true; Start_Placement(); /* ** Force map to redraw */ HidPage.Clear(); Flag_To_Redraw(true); } /*************************************************************************** * MapEditClass::Cancel_Base_Building -- stops base-building mode * * * * INPUT: * * none. * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 12/01/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Cancel_Base_Building(void) { /* ** Build the base to the proper amount */ Build_Base_To(Scen.Percent); /* ** Cancel placement mode */ Cancel_Placement(); BaseBuilding = false; /* ** Force map to redraw */ HidPage.Clear(); Flag_To_Redraw(true); } /*************************************************************************** * MapEditClass::Build_Base_To -- builds the AI base to the given percent * * * * INPUT: * * percent percentage to build base to * * * * OUTPUT: * * none. * * * * WARNINGS: * * none. * * * * HISTORY: * * 12/01/1994 BR : Created. * *=========================================================================*/ void MapEditClass::Build_Base_To(int percent) { int i; int num_buildings; BuildingTypeClass const * objtype; BuildingClass * obj; //ScenarioInit++; /* ** Completely dismantle the base, so we start at a known point */ for (i = 0; i < Base.Nodes.Count(); i++) { if (Base.Is_Built(i)) { obj = Base.Get_Building(i); delete obj; } } /* ** Compute number of buildings to build */ num_buildings = (Base.Nodes.Count() * percent) / 100; /* ** Build the base to the desired amount */ for (i = 0; i < num_buildings; i++) { /* ** Get a ptr to the type of building to build, create one, and unlimbo it. */ objtype = &BuildingTypeClass::As_Reference(Base.Nodes[i].Type); obj = (BuildingClass *)objtype->Create_One_Of(HouseClass::As_Pointer(Base.House)); /* ** If unlimbo fails, error out */ ScenarioInit++; if (!obj->Unlimbo(Cell_Coord(Base.Nodes[i].Cell))) { delete obj; WWMessageBox().Process("Unable to build base!"); ScenarioInit--; return; } ScenarioInit--; } //ScenarioInit--; } #endif