//
// 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"