mirrors
/
CnC_Remastered_Collection
mirror of https://github.com/electronicarts/CnC_Remastered_Collection.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/MAPEDIT.CPP

2171 lines
62 KiB
C++
Raw Normal View History

Initial Source Code commit Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
2020-05-27 20:16:20 +01:00
//
// 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"