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/SIDEBAR.CPP

2478 lines
111 KiB
C++
Raw Blame History

//
// 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/SIDEBAR.CPP 2 3/17/97 1:05a 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 : SIDEBAR.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : October 20, 1994 *
* *
* Last Update : October 9, 1996 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* SidebarClass::AI -- Handles player clicking on sidebar area. *
* SidebarClass::Abandon_Production -- Stops production of the object specified. *
* SidebarClass::Activate -- Controls the sidebar activation. *
* SidebarClass::Activate_Demolish -- Controls the demolish button on the sidebar. *
* SidebarClass::Activate_Repair -- Controls the repair button on the sidebar. *
* SidebarClass::Activate_Upgrade -- Controls the upgrade button on the sidebar. *
* SidebarClass::Add -- Adds a game object to the sidebar list. *
* SidebarClass::Draw_It -- Renders the sidebar display. *
* SidebarClass::Factory_Link -- Links a factory to a sidebar strip. *
* SidebarClass::Init_Clear -- Sets sidebar to a known (and deactivated) state *
* SidebarClass::Init_IO -- Adds buttons to the button list *
* SidebarClass::Init_Theater -- Performs theater-specific initialization *
* SidebarClass::One_Time -- Handles the one time game initializations. *
* SidebarClass::One_Time -- Handles the one time game initializations. *
* SidebarClass::Recalc -- Examines the sidebar data and updates it as necessary. *
* SidebarClass::Refresh_Cells -- Intercepts the refresh, looking for sidebar controls. *
* SidebarClass::SBGadgetClass::Action -- Special function that controls the mouse over the s*
* SidebarClass::Scroll -- Handles scrolling the sidebar object strip. *
* SidebarClass::Set_Current -- Sets a specified object that controls the sidebar display. *
* SidebarClass::SidebarClass -- Default constructor for the sidebar. *
* SidebarClass::SidebarClass -- This is the no initialization constructor for the sidebar. *
* SidebarClass::StripClass::AI -- Input and AI processing for the side strip. *
* SidebarClass::StripClass::Abandon_Produ -- Abandons production associated with sidebar. *
* SidebarClass::StripClass::Activate -- Adds the strip buttons to the input system. *
* SidebarClass::StripClass::Add -- Add an object to the side strip. *
* SidebarClass::StripClass::Deactivate -- Removes the side strip buttons from the input syst*
* SidebarClass::StripClass::Draw_It -- Render the sidebar display. *
* SidebarClass::StripClass::Factory_Link -- Links a factory to a sidebar button. *
* SidebarClass::StripClass::Flag_To_Redra -- Flags the sidebar strip to be redrawn. *
* SidebarClass::StripClass::Get_Special_Cameo -- Fetches the special event cameo shape. *
* SidebarClass::StripClass::Init_Clear -- Sets sidebar to a known (and deactivated) state *
* SidebarClass::StripClass::Init_IO -- Adds buttons to the button list *
* SidebarClass::StripClass::Init_Theater -- Performs theater-specific initialization *
* SidebarClass::StripClass::One_Time -- Performs one time actions necessary for the side str*
* SidebarClass::StripClass::Recalc -- Revalidates the current sidebar list of objects. *
* SidebarClass::StripClass::Scroll -- Causes the side strip to scroll. *
* SidebarClass::StripClass::SelectClass:: -- Action function when buildable cameo is selecte*
* SidebarClass::StripClass::SelectClass:: -- Assigns special values to a buildable select bu*
* SidebarClass::StripClass::SelectClass::SelectClass -- Default constructor. *
* SidebarClass::StripClass::StripClass -- Default constructor for the side strip class. *
* SidebarClass::Which_Column -- Determines which column a given type should appear. *
* SidebarClass::Zoom_Mode_Control -- Handles the zoom mode toggle operation. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
void * SidebarClass::SidebarShape = NULL;
void * SidebarClass::SidebarMiddleShape = NULL;
void * SidebarClass::SidebarBottomShape = NULL;
/***************************************************************************
** This holds the translucent table for use with the construction clock
** animation.
*/
char SidebarClass::StripClass::ClockTranslucentTable[(1+1)*256];
/***************************************************************************
** This points to the main sidebar shapes. These include the upgrade and
** repair buttons.
*/
//TheaterType SidebarClass::StripClass::LastTheater = THEATER_NONE;
typedef enum ButtonNumberType {
BUTTON_RADAR = 100,
BUTTON_REPAIR,
BUTTON_DEMOLISH,
BUTTON_UPGRADE,
BUTTON_SELECT,
BUTTON_ZOOM
} ButtonNumberType;
/*
** Sidebar buttons
*/
SidebarClass::SBGadgetClass SidebarClass::Background;
ShapeButtonClass SidebarClass::Repair;
ShapeButtonClass SidebarClass::Upgrade;
ShapeButtonClass SidebarClass::Zoom;
ShapeButtonClass SidebarClass::StripClass::UpButton[COLUMNS];
ShapeButtonClass SidebarClass::StripClass::DownButton[COLUMNS];
SidebarClass::StripClass::SelectClass
SidebarClass::StripClass::SelectButton[COLUMNS][MAX_VISIBLE];
/*
** Shape data pointers
*/
void * SidebarClass::StripClass::LogoShapes = NULL;
void const * SidebarClass::StripClass::ClockShapes;
void const * SidebarClass::StripClass::SpecialShapes[SPC_COUNT];
/***********************************************************************************************
* SidebarClass::SidebarClass -- Default constructor for the sidebar. *
* *
* Constructor for the sidebar handler. It basically sets up the sidebar to the empty *
* condition. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 11/17/1994 JLB : Created. *
*=============================================================================================*/
SidebarClass::SidebarClass(void) :
IsSidebarActive(false),
IsToRedraw(true),
IsRepairActive(false),
IsUpgradeActive(false),
IsDemolishActive(false)
{
/*
** This sets up the clipping window. This window is used by the shape drawing
** code so that as the sidebar buildable buttons scroll, they get properly
** clipped at the top and bottom edges.
*/
WindowList[WINDOW_SIDEBAR][WINDOWX] = (SIDE_X+8);
WindowList[WINDOW_SIDEBAR][WINDOWY] = SIDE_Y + 1 + TOP_HEIGHT;
WindowList[WINDOW_SIDEBAR][WINDOWWIDTH] = SIDE_WIDTH;
WindowList[WINDOW_SIDEBAR][WINDOWHEIGHT] = StripClass::MAX_VISIBLE * StripClass::OBJECT_HEIGHT;
// WindowList[WINDOW_SIDEBAR][WINDOWHEIGHT] = StripClass::MAX_VISIBLE * StripClass::OBJECT_HEIGHT-1;
/*
** Set up the coordinates for the sidebar strips. These coordinates are for
** the upper left corner.
*/
new (&Column[0]) StripClass(InitClass());
new (&Column[1]) StripClass(InitClass());
Column[0].X = COLUMN_ONE_X * RESFACTOR;
Column[0].Y = COLUMN_ONE_Y * RESFACTOR;
Column[1].X = COLUMN_TWO_X * RESFACTOR;
Column[1].Y = COLUMN_TWO_Y * RESFACTOR;
}
/***********************************************************************************************
* SidebarClass::SidebarClass -- This is the no initialization constructor for the sidebar. *
* *
* Unlike the normal constructor, this one doesn't do any initialization. There is one *
* exception to this. The stip classes can't call an explicit NoInitClass constructor *
* since they are an array. Since the default constructor is called for these strips, we *
* must reset the X and Y location to what we know they should be. *
* *
* INPUT: flag to indicate that this is a no initialization constructor. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/06/1996 JLB : Created. *
*=============================================================================================*/
SidebarClass::SidebarClass(NoInitClass const & x) : PowerClass(x)
{
/*
** Set up the coordinates for the sidebar strips. These coordinates are for
** the upper left corner.
*/
// Column[0].X = COLUMN_ONE_X * RESFACTOR;
// Column[0].Y = COLUMN_ONE_Y * RESFACTOR;
// Column[1].X = COLUMN_TWO_X * RESFACTOR;
// Column[1].Y = COLUMN_TWO_Y * RESFACTOR;
}
/***********************************************************************************************
* SidebarClass::One_Time -- Handles the one time game initializations. *
* *
* This routine is used to load the graphic data that is needed by the sidebar display. It *
* should only be called ONCE. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: Only call this routine once when the game first starts. *
* *
* HISTORY: *
* 10/28/94 JLB : Created. *
*=============================================================================================*/
void SidebarClass::One_Time(void)
{
PowerClass::One_Time();
/*
** This sets up the clipping window. This window is used by the shape drawing
** code so that as the sidebar buildable buttons scroll, they get properly
** clipped at the top and bottom edges.
*/
WindowList[WINDOW_SIDEBAR][WINDOWX] = ((SIDE_X+8)) * RESFACTOR;
WindowList[WINDOW_SIDEBAR][WINDOWY] = (SIDE_Y + 1 + TOP_HEIGHT) * RESFACTOR;
WindowList[WINDOW_SIDEBAR][WINDOWWIDTH] = (SIDE_WIDTH) * RESFACTOR;
WindowList[WINDOW_SIDEBAR][WINDOWHEIGHT] = (StripClass::MAX_VISIBLE * StripClass::OBJECT_HEIGHT) * RESFACTOR;
// WindowList[WINDOW_SIDEBAR][WINDOWHEIGHT] = (StripClass::MAX_VISIBLE * StripClass::OBJECT_HEIGHT-1) * RESFACTOR;
/*
** Top of the window seems to be wrong for the new sidebar. ST - 5/2/96 2:49AM
*/
WindowList[WINDOW_SIDEBAR][WINDOWY] -= 1*RESFACTOR;
/*
** Set up the coordinates for the sidebar strips. These coordinates are for
** the upper left corner.
*/
// Column[0].X = COLUMN_ONE_X * RESFACTOR;
// Column[0].Y = COLUMN_ONE_Y * RESFACTOR;
// Column[1].X = COLUMN_TWO_X * RESFACTOR;
// Column[1].Y = COLUMN_TWO_Y * RESFACTOR;
Column[0].One_Time(0);
Column[1].One_Time(1);
/*
** Load the sidebar shape in at this time. (Hi-Res sidebar is theater dependant)
*/
if (SidebarShape == NULL) {
SidebarShape = (void*)MFCD::Retrieve("SIDEBAR.SHP");
}
}
/***********************************************************************************************
* SidebarClass::Init_Clear -- Sets sidebar to a known (and deactivated) state *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/24/1994 JLB : Created. *
*=============================================================================================*/
void SidebarClass::Init_Clear(void)
{
PowerClass::Init_Clear();
IsToRedraw = true;
IsRepairActive = false;
IsUpgradeActive = false;
IsDemolishActive = false;
Column[0].Init_Clear();
Column[1].Init_Clear();
Activate(false);
}
/***********************************************************************************************
* SidebarClass::Init_IO -- Adds buttons to the button list *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/24/1994 JLB : Created. *
*=============================================================================================*/
void SidebarClass::Init_IO(void)
{
PowerClass::Init_IO();
/*
** Add the sidebar's buttons only if we're not in editor mode.
*/
if (!Debug_Map) {
Repair.IsSticky = true;
Repair.ID = BUTTON_REPAIR;
Repair.X = (0x1f2/2)*RESFACTOR;
Repair.Y = (0x96/2)*RESFACTOR;
Repair.IsPressed = false;
Repair.IsToggleType = true;
Repair.ReflectButtonState = true;
Repair.Set_Shape(MFCD::Retrieve("REPAIR.SHP"));
Upgrade.IsSticky = true;
Upgrade.ID = BUTTON_UPGRADE;
#ifdef WIN32
Upgrade.X = 0x21f;
#else
Upgrade.X = ((0x21f/2)+1)*RESFACTOR;
#endif
Upgrade.Y = (0x96/2)*RESFACTOR;
Upgrade.IsPressed = false;
Upgrade.IsToggleType = true;
Upgrade.ReflectButtonState = true;
Upgrade.Set_Shape(MFCD::Retrieve("SELL.SHP"));
Zoom.IsSticky = true;
Zoom.ID = BUTTON_ZOOM;
Zoom.X = (0x24c/2)*RESFACTOR;
Zoom.Y = (0x96/2)*RESFACTOR;
Zoom.IsPressed = false;
Zoom.Set_Shape(MFCD::Retrieve("MAP.SHP"));
if ((IsRadarActive && Is_Zoomable()) || Session.Type != GAME_NORMAL) {
Zoom.Enable();
} else {
Zoom.Disable();
}
Column[0].Init_IO(0);
Column[1].Init_IO(1);
/*
** If a game was loaded & the sidebar was enabled, pop it up now
*/
if (IsSidebarActive) {
IsSidebarActive = false;
Activate(1);
// Background.Zap();
// Add_A_Button(Background);
}
}
}
/***********************************************************************************************
* SidebarClass::Init_Theater -- Performs theater-specific initialization *
* *
* INPUT: theater -- The theater that is being initialized. Sometimes this has an effect on *
* the data that is loaded. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/24/1994 JLB : Created. *
*=============================================================================================*/
void SidebarClass::Init_Theater(TheaterType theater)
{
Reload_Sidebar();
PowerClass::Init_Theater(theater);
Column[0].Init_Theater(theater);
Column[1].Init_Theater(theater);
}
/***********************************************************************************************
* SidebarClass::Reload_Sidebar -- Loads appropriate sidebar shapes depending on house *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 9/18/1996 BWG : Created. *
*=============================================================================================*/
void SidebarClass::Reload_Sidebar(void)
{
static char * sidebarnames[]={
"SIDE?NA.SHP", //NATO
"SIDE?NA.SHP",
"SIDE?US.SHP", //USSR
"SIDE?NA.SHP",
"SIDE?US.SHP", //UKRAINE
"SIDE?NA.SHP",
"SIDE?NA.SHP",
"SIDE?NA.SHP",
"SIDE?NA.SHP", //HOUSE_GOOD
"SIDE?US.SHP" //HOUSE_BAD
};
int houseloaded = 0;
if(PlayerPtr) {
houseloaded = PlayerPtr->ActLike;
}
/* Don't have write access to the static char array. ST - 5/20/2019 */
#if (0)
char * sidename = sidebarnames[houseloaded];
*(sidename+4) = '1';
SidebarShape = (void*)MFCD::Retrieve(sidename);
*(sidename+4) = '2';
SidebarMiddleShape = (void*)MFCD::Retrieve(sidename);
*(sidename+4) = '3';
SidebarBottomShape = (void*)MFCD::Retrieve(sidename);
#else
char sb_name[16];
strcpy(sb_name, sidebarnames[houseloaded]);
sb_name[4] = '1';
SidebarShape = (void*)MFCD::Retrieve(sb_name);
sb_name[4] = '2';
SidebarMiddleShape = (void*)MFCD::Retrieve(sb_name);
sb_name[4] = '3';
SidebarBottomShape = (void*)MFCD::Retrieve(sb_name);
#endif
Column[0].Reload_LogoShapes();
Column[1].Reload_LogoShapes();
}
/***********************************************************************************************
* SidebarClass::Which_Column -- Determines which column a given type should appear. *
* *
* Use this function to resolve what column the specified object type should be placed *
* into. *
* *
* INPUT: otype -- Pointer to the object type class of the object in question. *
* *
* OUTPUT: Returns with the column number that the object should be placed in. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 01/01/1995 JLB : Created. *
*=============================================================================================*/
int SidebarClass::Which_Column(RTTIType type)
{
if (type == RTTI_BUILDINGTYPE || type == RTTI_BUILDING) {
return(0);
}
return(1);
}
/***********************************************************************************************
* SidebarClass::Factory_Link -- Links a factory to a sidebar strip. *
* *
* This routine will link the specified factory to the sidebar strip. A factory must be *
* linked to the sidebar so that as the factory production progresses, the sidebar will *
* show the production progress. *
* *
* INPUT: factory -- The factory number to attach. *
* *
* type -- The object type number. *
* *
* id -- The object sub-type number. *
* *
* OUTPUT: Was the factory successfully attached to the sidebar strip? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/19/1995 JLB : Created. *
*=============================================================================================*/
bool SidebarClass::Factory_Link(int factory, RTTIType type, int id)
{
assert((unsigned)type < RTTI_COUNT);
assert(id >= 0);
return(Column[Which_Column(type)].Factory_Link(factory, type, id));
}
/***********************************************************************************************
* SidebarClass::Refresh_Cells -- Intercepts the refresh, looking for sidebar controls. *
* *
* This routine intercepts the Refresh_Cells call in order to see if the sidebar needs *
* to be refreshed as well. If the special code to refresh the sidebar was found, it *
* flags the sidebar to be redrawn and then removes the code from the list. *
* *
* INPUT: cell -- The cell to base the refresh list on. *
* *
* list -- Pointer to the cell offset list that elaborates all the cells that *
* need to be flagged for redraw. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 01/19/1995 JLB : Created. *
*=============================================================================================*/
void SidebarClass::Refresh_Cells(CELL cell, short const * list)
{
if (*list == REFRESH_SIDEBAR) {
IsToRedraw = true;
Column[0].IsToRedraw = true;
Column[1].IsToRedraw = true;
Flag_To_Redraw(false);
}
PowerClass::Refresh_Cells(cell, list);
}
/***********************************************************************************************
* SidebarClass::Activate_Repair -- Controls the repair button on the sidebar. *
* *
* Use this routine to turn the repair sidebar button on and off. Typically, the button *
* is enabled when the currently selected structure is friendly and damaged. *
* *
* INPUT: control -- The controls how the button is to be activated or deactivated; *
* 0 -- Turn button off. *
* 1 -- Turn button on. *
* -1 -- Toggle button state. *
* *
* OUTPUT: bool; Was the button previously activated? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/24/1994 JLB : Created. *
*=============================================================================================*/
bool SidebarClass::Activate_Repair(int control)
{
bool old = IsRepairActive;
if (control == -1) {
control = IsRepairActive ? 0 : 1;
}
switch (control) {
case 1:
IsRepairActive = true;
break;
default:
case 0:
IsRepairActive = false;
break;
}
if (old != IsRepairActive) {
Flag_To_Redraw(false);
IsToRedraw = true;
if (!IsRepairActive) {
Help_Text(TXT_NONE);
Set_Default_Mouse(MOUSE_NORMAL, false);
}
}
return(old);
}
/***********************************************************************************************
* SidebarClass::Activate_Upgrade -- Controls the upgrade button on the sidebar. *
* *
* Use this routine to turn the upgrade sidebar button on and off. Typically, the button *
* is enabled when the currently selected structure can be upgraded and disabled otherwise. *
* *
* INPUT: control -- The controls how the button is to be activated or deactivated; *
* 0 -- Turn button off. *
* 1 -- Turn button on. *
* -1 -- Toggle button state. *
* *
* OUTPUT: bool; Was the button previously activated? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/24/1994 JLB : Created. *
*=============================================================================================*/
bool SidebarClass::Activate_Upgrade(int control)
{
bool old = IsUpgradeActive;
if (control == -1) {
control = IsUpgradeActive ? 0 : 1;
}
switch (control) {
case 1:
IsUpgradeActive = true;
break;
default:
case 0:
IsUpgradeActive = false;
break;
}
if (old != IsUpgradeActive) {
Flag_To_Redraw(false);
IsToRedraw = true;
if (!IsUpgradeActive) {
Set_Default_Mouse(MOUSE_NORMAL, false);
}
}
return(old);
}
/***********************************************************************************************
* SidebarClass::Activate_Demolish -- Controls the demolish button on the sidebar. *
* *
* Use this routine to turn the demolish/dismantle sidebar button on and off. Typically, *
* the button is enabled when a friendly building is selected and disabled otherwise. *
* *
* INPUT: control -- The controls how the button is to be activated or deactivated; *
* 0 -- Turn button off. *
* 1 -- Turn button on. *
* -1 -- Toggle button state. *
* *
* OUTPUT: bool; Was the button previously activated? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/24/1994 JLB : Created. *
*=============================================================================================*/
bool SidebarClass::Activate_Demolish(int control)
{
bool old = IsDemolishActive;
if (control == -1) {
control = IsDemolishActive ? 0 : 1;
}
switch (control) {
case 1:
IsDemolishActive = true;
break;
default:
case 0:
IsDemolishActive = false;
break;
}
if (old != IsDemolishActive) {
Flag_To_Redraw(false);
IsToRedraw = true;
if (!IsDemolishActive) {
Set_Default_Mouse(MOUSE_NORMAL, false);
}
}
return(old);
}
/***********************************************************************************************
* SidebarClass::Add -- Adds a game object to the sidebar list. *
* *
* This routine is used to add a game object to the sidebar. Call this routine when a *
* factory type building is created. It handles the case of adding an item that has already *
* been added -- it just ignores it. *
* *
* INPUT: object -- Pointer to the object that is being added. *
* *
* OUTPUT: bool; Was the object added to the sidebar? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 11/17/1994 JLB : Created. *
* 9/24/2019 3:17PM : Added via capture parameter for new sidebar functionality *
*=============================================================================================*/
bool SidebarClass::Add(RTTIType type, int id, bool via_capture)
{
assert((unsigned)type < RTTI_COUNT);
/*
** Add the sidebar only if we're not in editor mode.
*/
if (!Debug_Map) {
int column = Which_Column(type);
if (Column[column].Add(type, id, via_capture)) {
Activate(1);
IsToRedraw = true;
Flag_To_Redraw(false);
return(true);
}
return(false);
}
return(false);
}
/***********************************************************************************************
* SidebarClass::Scroll -- Handles scrolling the sidebar object strip. *
* *
* This routine is used to scroll the sidebar strip of objects. The strip appears whenever *
* a building is selected that can produce units. If the number of units to produce is *
* greater than what the sidebar can hold, this routine is used to scroll the other object *
* into view so they can be selected. *
* *
* INPUT: up -- Should the scroll be upwards? Upward scrolling reveals object that are *
* later in the list of objects. *
* *
* OUTPUT: bool; Did scrolling occur? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/28/94 JLB : Created. *
*=============================================================================================*/
bool SidebarClass::Scroll(bool up, int column)
{
if (column == -1) {
bool scr = false;
scr |= Column[0].Scroll(up);
scr |= Column[1].Scroll(up);
if (!scr) {
Sound_Effect(VOC_SCOLD);
}
if (scr) {
IsToRedraw = true;
Flag_To_Redraw(false);
return(true);
}
return(false);
}
if (Column[column].Scroll(up)) {
// No need to redraw the whole sidebar juts because we scrolled a strip is there? ST - 10/15/96 7:29PM
//IsToRedraw = true;
Flag_To_Redraw(false);
return(true);
}
return(false);
}
/***********************************************************************************************
* SidebarClass::Draw_It -- Renders the sidebar display. *
* *
* This routine performs the actual drawing of the sidebar display. *
* *
* INPUT: none *
* *
* OUTPUT: bool; Was the sidebar imagery changed at all? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/28/94 JLB : Created. *
* 12/31/1994 JLB : Split rendering off into the sidebar strip class. *
*=============================================================================================*/
void SidebarClass::Draw_It(bool complete)
{
PowerClass::Draw_It(complete);
BStart(BENCH_SIDEBAR);
if (IsSidebarActive && (IsToRedraw || complete) && !Debug_Map) {
IsToRedraw = false;
if (LogicPage->Lock()) {
/*
** Draw the outline box around the sidebar buttons.
*/
int shape = complete ? 0 : 1;
/*
** The sidebar shape is too big in 640x400 so it needs to be drawn in three chunks.
*/
CC_Draw_Shape(SidebarShape, 0, SIDE_X * RESFACTOR, 8*RESFACTOR, WINDOW_MAIN, SHAPE_WIN_REL);
CC_Draw_Shape(SidebarMiddleShape, shape, SIDE_X * RESFACTOR, (8+80)*RESFACTOR, WINDOW_MAIN, SHAPE_WIN_REL);
CC_Draw_Shape(SidebarBottomShape, shape, SIDE_X * RESFACTOR, (8+80+50)*RESFACTOR, WINDOW_MAIN, SHAPE_WIN_REL);
Repair.Draw_Me(true);
Upgrade.Draw_Me(true);
Zoom.Draw_Me(true);
LogicPage->Unlock();
}
}
/*
** Draw the side strip elements by calling their respective draw functions.
*/
if (IsSidebarActive) {
Column[0].Draw_It(complete);
Column[1].Draw_It(complete);
if (complete || IsToRedraw) {
Repair.Draw_Me(true);
Upgrade.Draw_Me(true);
Zoom.Draw_Me(true);
}
}
IsToRedraw = false;
BEnd(BENCH_SIDEBAR);
}
/***********************************************************************************************
* SidebarClass::AI -- Handles player clicking on sidebar area. *
* *
* This routine handles the processing necessary when the player clicks on the sidebar. *
* Typically, this is selection of the item to build. *
* *
* INPUT: input -- Reference to the keyboard input value. *
* *
* x,y -- Mouse coordinates at time of input. *
* *
* OUTPUT: bool; Was the click handled? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 10/28/94 JLB : Created. *
* 11/11/1994 JLB : Processes input directly. *
* 12/26/1994 JLB : Uses factory manager class for construction handling. *
* 12/31/1994 JLB : Simplified to use the sidebar strip class handlers. *
* 12/31/1994 JLB : Uses mouse coordinate parameters. *
* 06/27/1995 JLB : <TAB> key toggles sidebar. *
*=============================================================================================*/
void SidebarClass::AI(KeyNumType & input, int x, int y)
{
bool redraw = false;
//
// We need to process the sidebar differently in multiplayer. ST - 8/7/2019 10:48AM
//
if (Session.Type == GAME_GLYPHX_MULTIPLAYER) {
PowerClass::AI(input, x, y);
return;
}
/*
** Toggle the sidebar in and out with the <TAB> key.
*/
#ifndef WIN32
if (input == KN_TAB) {
Activate(-1);
}
#else
if (!Debug_Map) {
Activate(1); // Force the sidebar always on in Win95 mode
}
#endif //WIN32
if (!Debug_Map) {
Column[0].AI(input, x, y);
Column[1].AI(input, x, y);
}
#ifdef NEVER
if (IsSidebarActive && !Debug_Map) {
if (input == KN_DOWN) {
int scr = 0;
scr |= Column[0].Scroll(false);
scr |= Column[1].Scroll(false);
if (!scr) {
Sound_Effect(VOC_SCOLD);
}
redraw |= scr;
input = KN_NONE;
}
if (input == KN_UP) {
int scr = 0;
scr |= Column[0].Scroll(true);
scr |= Column[1].Scroll(true);
if (!scr) {
Sound_Effect(VOC_SCOLD);
}
redraw |= scr;
input = KN_NONE;
}
}
#endif
if (IsSidebarActive) {
/*
** If there are any buildings in the payer's inventory, then allow the repair
** option.
*/
if (PlayerPtr->BScan) {
Activate_Repair(true);
} else {
Activate_Repair(false);
}
if (input == (BUTTON_REPAIR|KN_BUTTON)) {
Repair_Mode_Control(-1);
}
if (input == (BUTTON_ZOOM|KN_BUTTON)) {
Zoom_Mode_Control();
}
if (input == (BUTTON_UPGRADE|KN_BUTTON)) {
Sell_Mode_Control(-1);
}
if (redraw) {
//IsToRedraw = true;
Column[0].Flag_To_Redraw();
Column[1].Flag_To_Redraw();
Flag_To_Redraw(false);
}
}
if ((!IsRepairMode) && Repair.IsOn) {
Repair.Turn_Off();
}
if ((!IsSellMode) && Upgrade.IsOn) {
Upgrade.Turn_Off();
}
PowerClass::AI(input, x, y);
}
/***********************************************************************************************
* SidebarClass::Recalc -- Examines the sidebar data and updates it as necessary. *
* *
* Occasionally a factory gets destroyed. This routine must be called in such a case *
* because it might be possible that sidebar object need to be removed. This routine will *
* examine all existing objects in the sidebar class and if no possible factory can *
* produce it, then it will be removed. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: This routine is exhaustive and thus time consuming. Only call it when really *
* necessary. Such as when a factory is destroyed rather than when a non-factory *
* is destroyed. *
* *
* HISTORY: *
* 11/30/1994 JLB : Created. *
*=============================================================================================*/
void SidebarClass::Recalc(void)
{
bool redraw = false;
// Done elsewhere for new multiplayer. ST - 8/7/2019 10:49AM
if (Session.Type == GAME_GLYPHX_MULTIPLAYER) {
return;
}
redraw |= Column[0].Recalc();
redraw |= Column[1].Recalc();
if (redraw) {
IsToRedraw = true;
Flag_To_Redraw(false);
}
}
/***********************************************************************************************
* SidebarClass::Activate -- Controls the sidebar activation. *
* *
* Use this routine to turn the sidebar on or off. This routine handles updating the *
* necessary flags. *
* *
* INPUT: control -- Tells what to do with the sidebar according to the following: *
* 0 = Turn sidebar off. *
* 1 = Turn sidebar on. *
* -1= Toggle sidebar on or off. *
* *
* OUTPUT: bool; Was the sidebar already on? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/09/1994 JLB : Created. *
*=============================================================================================*/
bool SidebarClass::Activate(int control)
{
//
// We don't want the original sidebar to be visible. ST - 1/31/2019 11:28AM
//
if (control < 100) {
return IsSidebarActive;
}
bool old = IsSidebarActive;
if (Session.Play)
return (old);
/*
** Determine the new state of the sidebar.
*/
switch (control) {
case -1:
IsSidebarActive = IsSidebarActive == false;
break;
case 1:
IsSidebarActive = true;
break;
default:
case 0:
IsSidebarActive = false;
break;
}
/*
** Only if there is a change in the state of the sidebar will anything
** be done to change it.
*/
if (IsSidebarActive != old) {
/*
** If the sidebar is activated but was on the right side of the screen, then
** activate it on the left side of the screen.
*/
if (IsSidebarActive /*&& X*/) {
Set_View_Dimensions(0, 8 * RESFACTOR, ((320-SIDE_WIDTH)/ICON_PIXEL_W) * RESFACTOR);
IsToRedraw = true;
Help_Text(TXT_NONE);
Repair.Zap();
Add_A_Button(Repair);
Upgrade.Zap();
Add_A_Button(Upgrade);
Zoom.Zap();
Add_A_Button(Zoom);
Column[0].Activate();
Column[1].Activate();
Background.Zap();
Add_A_Button(Background);
Map.RadarButton.Zap();
Add_A_Button(Map.RadarButton);
Map.PowerButton.Zap();
Add_A_Button(Map.PowerButton);
} else {
Help_Text(TXT_NONE);
Set_View_Dimensions(0, 8 * RESFACTOR);
Remove_A_Button(Repair);
Remove_A_Button(Upgrade);
Remove_A_Button(Zoom);
Remove_A_Button(Background);
Column[0].Deactivate();
Column[1].Deactivate();
Remove_A_Button(Map.RadarButton);
Remove_A_Button(Map.PowerButton);
}
/*
** Since the sidebar status has changed, update the map so that the graphics
** will be rendered correctly.
*/
Flag_To_Redraw(true);
}
return(old);
}
/***********************************************************************************************
* SidebarClass::StripClass::StripClass -- Default constructor for the side strip class. *
* *
* This constructor is used to reset the side strip to default empty state. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/31/1994 JLB : Created. *
*=============================================================================================*/
SidebarClass::StripClass::StripClass(InitClass const & ) :
X(0),
Y(0),
ID(0),
IsToRedraw(true),
IsBuilding(false),
IsScrollingDown(false),
IsScrolling(false),
Flasher(-1),
TopIndex(0),
Scroller(0),
Slid(0),
BuildableCount(0)
{
for (int index = 0; index < MAX_BUILDABLES; index++) {
Buildables[index].BuildableID = 0;
Buildables[index].BuildableType = RTTI_NONE;
Buildables[index].Factory = -1;
Buildables[index].BuildableViaCapture = false; // Added for new sidebar functionality. ST - 9/24/2019 3:10PM
}
}
/***********************************************************************************************
* SidebarClass::StripClass::One_Time -- Performs one time actions necessary for the side stri *
* *
* Call this routine ONCE at the beginning of the game. It handles retrieving pointers to *
* the shape files it needs for rendering. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/31/1994 JLB : Created. *
*=============================================================================================*/
void SidebarClass::StripClass::One_Time(int )
{
/*
** Sidebar is player team specific in Hires
*/
ClockShapes = MFCD::Retrieve("CLOCK.SHP");
for (SpecialWeaponType lp = SPC_FIRST; lp < SPC_COUNT; lp++) {
char buffer[_MAX_FNAME];
sprintf(buffer, "%sICON", SpecialWeaponFile[lp]);
char fullname[_MAX_FNAME+_MAX_EXT];
_makepath(fullname, NULL, NULL, buffer, ".SHP");
SpecialShapes[lp] = MFCD::Retrieve(fullname);
}
}
/***********************************************************************************************
* SidebarClass::StripClass::Get_Special_Cameo -- Fetches the special event cameo shape. *
* *
* This routine will return with a pointer to the cameo data for the special objects that *
* can appear on the sidebar (e.g., nuclear bomb). *
* *
* INPUT: type -- The special type to fetch the cameo imagery for. *
* *
* OUTPUT: Returns with a pointer to the cameo imagery for the specified special object. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/19/1995 JLB : commented *
*=============================================================================================*/
void const * SidebarClass::StripClass::Get_Special_Cameo(SpecialWeaponType type)
{
if ((unsigned)type < SPC_COUNT) {
return(SpecialShapes[type]);
}
return(0);
}
/***********************************************************************************************
* SidebarClass::StripClass::Init_Clear -- Sets sidebar to a known (and deactivated) state *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/24/1994 JLB : Created. *
*=============================================================================================*/
void SidebarClass::StripClass::Init_Clear(void)
{
IsScrollingDown = false;
IsScrolling = false;
IsBuilding = false;
Flasher = -1;
TopIndex = 0;
Slid = 0;
BuildableCount = 0;
/*
** Since we're resetting the strips, clear out all the buildables & factory pointers.
*/
for (int index = 0; index < MAX_BUILDABLES; index++) {
Buildables[index].BuildableID = 0;
Buildables[index].BuildableType = RTTI_NONE;
Buildables[index].Factory = -1;
Buildables[index].BuildableViaCapture = false; // Added for new sidebar functionality. ST - 9/24/2019 3:10PM
}
}
/***********************************************************************************************
* SidebarClass::StripClass::Init_IO -- Initializes the strip's buttons *
* *
* This routine doesn't actually add any buttons to the list. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/24/1994 JLB : Created. *
*=============================================================================================*/
void SidebarClass::StripClass::Init_IO(int id)
{
ID = id;
UpButton[ID].IsSticky = true;
UpButton[ID].ID = BUTTON_UP+id;
UpButton[ID].X = X+(UP_X_OFFSET * RESFACTOR);
UpButton[ID].Y = Y+(UP_Y_OFFSET * RESFACTOR);
#if (FRENCH)
#ifdef WIN32
UpButton[ID].Set_Shape(MFCD::Retrieve("STRIPUP.SHP"));
#else
UpButton[ID].Set_Shape(MFCD::Retrieve("STUP_FIX.SHP"));
#endif
#else //FRENCH
UpButton[ID].Set_Shape(MFCD::Retrieve("STRIPUP.SHP"));
#endif //FRENCH
DownButton[ID].IsSticky = true;
DownButton[ID].ID = BUTTON_DOWN+id;
DownButton[ID].X = X+(DOWN_X_OFFSET * RESFACTOR);
DownButton[ID].Y = Y+(DOWN_Y_OFFSET * RESFACTOR);
/*
** Buttons are in a slightly different position in the new sidebar
*/
UpButton[ID].Y--;
DownButton[ID].Y--;
DownButton[ID].Set_Shape(MFCD::Retrieve("STRIPDN.SHP"));
for (int index = 0; index < MAX_VISIBLE; index++) {
SelectClass & g = SelectButton[ID][index];
g.ID = BUTTON_SELECT;
g.X = X;
g.Y = Y + ((OBJECT_HEIGHT*index) * RESFACTOR);
g.Width = OBJECT_WIDTH * RESFACTOR;
g.Height = OBJECT_HEIGHT * RESFACTOR;
g.Set_Owner(*this, index);
}
}
/***********************************************************************************************
* SidebarClass::StripClass::Init_Theater -- Performs theater-specific initialization *
* *
* INPUT: theater *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/24/1994 JLB : Created. *
*=============================================================================================*/
void SidebarClass::StripClass::Init_Theater(TheaterType theater)
{
Reload_LogoShapes();
if ( (theater != THEATER_NONE) && (theater != ::LastTheater)) {
static TLucentType const ClockCols[1] = {
{GREEN, BLACK, 100, 0}
// {GREEN, LTGREY, 180, 0}
};
/*
** Make sure that remapping doesn't occur on the colors that cycle.
*/
PaletteClass pal = OriginalPalette;
memset(&pal[CYCLE_COLOR_START*3], 0x3f, CYCLE_COLOR_COUNT*3);
Build_Translucent_Table(pal, &ClockCols[0], 1, (void*)ClockTranslucentTable);
// Mem_Copy(GamePalette, OriginalPalette, 768);
// memset(&GamePalette[CYCLE_COLOR_START*3], 0x3f, CYCLE_COLOR_COUNT*3);
/*
** Create the translucent table used for the sidebar.
*/
// Build_Translucent_Table(GamePalette, &ClockCols[0], 1, (void*)ClockTranslucentTable);
// GamePalette = OriginalPalette;
Conquer_Build_Fading_Table(GamePalette, &ClockTranslucentTable[256], BLACK, 100);
}
}
void SidebarClass::StripClass::Reload_LogoShapes(void)
{
/*
** Load hi-res strip art here since it is player side specific
*/
static char * stripnames[]={
"stripna.shp", //Nato
"stripna.shp",
"stripus.shp", //USSR
"stripna.shp",
"stripus.shp", //UKRAINE
"stripna.shp",
"stripna.shp",
"stripna.shp",
"stripna.shp", //HOUSE_GOOD
"stripus.shp", //HOUSE_BAD
};
int houseloaded = 0;
/*
** Sidebar art is dependent on the side of the player
*/
if(PlayerPtr) {
houseloaded = PlayerPtr->ActLike;
}
LogoShapes = (void*)MFCD::Retrieve(stripnames[houseloaded]);
}
/***********************************************************************************************
* SidebarClass::StripClass::Activate -- Adds the strip buttons to the input system. *
* *
* This routine will add the side strip buttons to the map's input system. This routine *
* should be called once when the sidebar activates. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: Never call this routine a second time without first calling Deactivate(). *
* *
* HISTORY: *
* 01/19/1995 JLB : Created. *
*=============================================================================================*/
void SidebarClass::StripClass::Activate(void)
{
UpButton[ID].Zap();
Map.Add_A_Button(UpButton[ID]);
DownButton[ID].Zap();
Map.Add_A_Button(DownButton[ID]);
for (int index = 0; index < MAX_VISIBLE; index++) {
SelectButton[ID][index].Zap();
Map.Add_A_Button(SelectButton[ID][index]);
}
}
/***********************************************************************************************
* SidebarClass::StripClass::Deactivate -- Removes the side strip buttons from the input syste *
* *
* Call this routine to remove all the buttons on the side strip from the map's input *
* system. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: Never call this routine unless the Activate() function was previously called. *
* *
* HISTORY: *
* 01/19/1995 JLB : Created. *
*=============================================================================================*/
void SidebarClass::StripClass::Deactivate(void)
{
Map.Remove_A_Button(UpButton[ID]);
Map.Remove_A_Button(DownButton[ID]);
for (int index = 0; index < MAX_VISIBLE; index++) {
Map.Remove_A_Button(SelectButton[ID][index]);
}
}
/***********************************************************************************************
* SidebarClass::StripClass::Add -- Add an object to the side strip. *
* *
* Use this routine to add a buildable object to the side strip. *
* *
* INPUT: object -- Pointer to the object type that can be built and is to be added to *
* the side strip. *
* *
* OUTPUT: bool; Was the object successfully added to the side strip? Failure could be the *
* result of running out of room in the side strip array or the object might *
* already be in the list. *
* *
* WARNINGS: none. *
* *
* HISTORY: *
* 12/31/1994 JLB : Created. *
* 9/24/2019 3:17PM : Added via capture parameter for new sidebar functionality *
*=============================================================================================*/
bool SidebarClass::StripClass::Add(RTTIType type, int id, bool via_capture)
{
if (BuildableCount <= MAX_BUILDABLES) {
for (int index = 0; index < BuildableCount; index++) {
if (Buildables[index].BuildableType == type && Buildables[index].BuildableID == id) {
return(false);
}
}
if (!ScenarioInit && type != RTTI_SPECIAL) {
Speak(VOX_NEW_CONSTRUCT);
}
Buildables[BuildableCount].BuildableType = type;
Buildables[BuildableCount].BuildableID = id;
Buildables[BuildableCount].BuildableViaCapture = via_capture;
BuildableCount++;
IsToRedraw = true;
return(true);
}
return(false);
}
/***********************************************************************************************
* SidebarClass::StripClass::Scroll -- Causes the side strip to scroll. *
* *
* Use this routine to flag the side strip to scroll. The direction scrolled is controlled *
* by the parameter. Scrolling is merely initiated by this routine. Subsequent calls to *
* the AI function and the Draw_It function are required to properly give the appearance *
* of scrolling. *
* *
* INPUT: bool; Should the side strip scroll UP? If it is to scroll down then pass false. *
* *
* OUTPUT: bool; Was the side strip started to scroll in the desired direction? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/31/1994 JLB : Created. *
* 07/29/1995 JLB : Simplified scrolling logic. *
*=============================================================================================*/
bool SidebarClass::StripClass::Scroll(bool up)
{
if (up) {
if (!TopIndex) return(false);
Scroller--;
} else {
if (TopIndex+MAX_VISIBLE >= BuildableCount) return(false);
Scroller++;
}
return(true);
}
/***********************************************************************************************
* SidebarClass::StripClass::Flag_To_Redra -- Flags the sidebar strip to be redrawn. *
* *
* This utility routine is called when something changes on the sidebar and it must be *
* reflected the next time drawing is performed. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/18/1995 JLB : Created. *
*=============================================================================================*/
void SidebarClass::StripClass::Flag_To_Redraw(void)
{
IsToRedraw = true;
//Map.SidebarClass::IsToRedraw = true;
Map.Flag_To_Redraw(false);
}
/***********************************************************************************************
* SidebarClass::StripClass::AI -- Input and AI processing for the side strip. *
* *
* The side strip AI processing is performed by this function. This function not only *
* checks for player input, but also handles any graphic logic updating necessary as a *
* result of flashing or construction animation. *
* *
* INPUT: input -- The player input code. *
* *
* x,y -- Mouse coordinate to use. *
* *
* OUTPUT: bool; Did the AI detect that it will need a rendering change? If this routine *
* returns true, then the Draw_It function should be called at the *
* earliest opportunity. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/31/1994 JLB : Created. *
* 12/31/1994 JLB : Uses mouse coordinate parameters. *
*=============================================================================================*/
bool SidebarClass::StripClass::AI(KeyNumType & input, int , int )
{
bool redraw = false;
/*
** If this is scroll button for this side strip, then scroll the strip as
** indicated.
*/
if (input == (UpButton[ID].ID|KN_BUTTON)) { // && !IsScrolling
UpButton[ID].IsPressed = false;
if (!Scroll(true)) {
Sound_Effect(VOC_SCOLD);
}
}
if (input == (DownButton[ID].ID|KN_BUTTON)) { // && !IsScrolling
DownButton[ID].IsPressed = false;
if (!Scroll(false)) {
Sound_Effect(VOC_SCOLD);
}
}
/*
** Reflect the scroll desired direction/value into the scroll
** logic handler. This might result in up or down scrolling.
*/
if (!IsScrolling && Scroller) {
if (BuildableCount <= MAX_VISIBLE) {
Scroller = 0;
} else {
/*
** Top of list is moving toward lower ordered entries in the object list. It looks like
** the "window" to the object list is moving up even though the actual object images are
** scrolling downward.
*/
if (Scroller < 0) {
if (!TopIndex) {
Scroller = 0;
} else {
Scroller++;
IsScrollingDown = false;
IsScrolling = true;
TopIndex--;
Slid = 0;
}
} else {
if (TopIndex+MAX_VISIBLE >= BuildableCount) {
Scroller = 0;
} else {
Scroller--;
Slid = OBJECT_HEIGHT;
IsScrollingDown = true;
IsScrolling = true;
}
}
}
}
/*
** Scroll logic is handled here.
*/
if (IsScrolling) {
if (IsScrollingDown) {
Slid -= SCROLL_RATE;
if (Slid <= 0) {
IsScrolling = false;
Slid = 0;
TopIndex++;
}
} else {
Slid += SCROLL_RATE;
if (Slid >= OBJECT_HEIGHT) {
IsScrolling = false;
Slid = 0;
}
}
redraw = true;
}
/*
** Handle any flashing logic. Flashing occurs when the player selects an object
** and provides the visual feedback of a recognized and legal selection.
*/
if (Flasher != -1) {
if (Graphic_Logic()) {
redraw = true;
if (Fetch_Stage() >= 7) {
Set_Rate(0);
Set_Stage(0);
Flasher = -1;
}
}
}
/*
** Handle any building clock animation logic.
*/
if (IsBuilding) {
for (int index = 0; index < BuildableCount; index++) {
int factoryid = Buildables[index].Factory;
if (factoryid != -1) {
FactoryClass * factory = Factories.Raw_Ptr(factoryid);
if (factory && (factory->Has_Changed() || factory->Is_Blocked())) {
redraw = true;
if (factory->Has_Completed()) {
/*
** Construction has been completed. Announce this fact to the player and
** try to get the object to automatically leave the factory. Buildings are
** the main exception to the ability to leave the factory under their own
** power.
*/
TechnoClass * pending = factory->Get_Object();
if (pending != NULL) {
switch (pending->What_Am_I()) {
case RTTI_VESSEL:
case RTTI_UNIT:
case RTTI_AIRCRAFT:
OutList.Add(EventClass(EventClass::PLACE, pending->What_Am_I(), -1));
if (!factory->Is_Blocked()) {
Speak(VOX_UNIT_READY);
}
break;
case RTTI_BUILDING:
Speak(VOX_CONSTRUCTION);
break;
case RTTI_INFANTRY:
OutList.Add(EventClass(EventClass::PLACE, pending->What_Am_I(), -1));
if (!factory->Is_Blocked()) {
Speak(VOX_UNIT_READY);
}
break;
}
}
}
}
}
}
}
/*
** If any of the logic determined that this side strip needs to be redrawn, then
** set the redraw flag for this side strip.
*/
if (redraw) {
Flag_To_Redraw();
}
return(redraw);
}
/***********************************************************************************************
* SidebarClass::StripClass::Draw_It -- Render the sidebar display. *
* *
* Use this routine to render the sidebar display. It checks to see if it needs to be *
* redrawn and only redraw if necessary. If the "complete" parameter is true, then it *
* will force redraw the entire strip. *
* *
* INPUT: complete -- Should the redraw be forced? A force redraw will ignore the redraw *
* flag. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/31/1994 JLB : Created. *
* 08/06/1995 JLB : Handles multi factory tracking in same strip. *
*=============================================================================================*/
void SidebarClass::StripClass::Draw_It(bool complete)
{
if (IsToRedraw || complete) {
IsToRedraw = false;
if (RunningAsDLL) {
return;
}
SidebarRedraws++;
/*
** Fills the background to the side strip. We shouldnt need to do this if the strip
** has a full complement of icons.
*/
/*
** New sidebar needs to be drawn not filled
*/
if (BuildableCount < MAX_VISIBLE) {
CC_Draw_Shape(LogoShapes, ID, X+(2*RESFACTOR), Y, WINDOW_MAIN, SHAPE_WIN_REL|SHAPE_NORMAL, 0);
}
/*
** Redraw the scroll buttons.
*/
UpButton[ID].Draw_Me(true);
DownButton[ID].Draw_Me(true);
/*
** Loop through all the buildable objects that are visible in the strip and render
** them. Their Y offset may be adjusted if the strip is in the process of scrolling.
*/
for (int i = 0; i < MAX_VISIBLE + (IsScrolling ? 1 : 0); i++) {
bool production;
bool completed;
int stage;
bool darken = false;
void const * shapefile = 0;
int shapenum = 0;
void const * remapper = 0;
FactoryClass * factory = 0;
int index = i+TopIndex;
int x = X;
int y = Y + (i*OBJECT_HEIGHT * RESFACTOR);
/*
** If the strip is scrolling, then the offset is adjusted accordingly.
*/
if (IsScrolling) {
y -= (OBJECT_HEIGHT - Slid) * RESFACTOR;
// y -= OBJECT_HEIGHT - Slid;
}
/*
** Fetch the shape number for the object type located at this current working
** slot. This shape pointer is used to draw the underlying graphic there.
*/
if (index < BuildableCount) {
ObjectTypeClass const * obj = NULL;
SpecialWeaponType spc = SPC_NONE;
if (Buildables[index].BuildableType != RTTI_SPECIAL) {
obj = Fetch_Techno_Type(Buildables[index].BuildableType, Buildables[index].BuildableID);
if (obj != NULL) {
/*
** Fetch the remap table that is appropriate for this object
** type.
*/
remapper = PlayerPtr->Remap_Table(false, ((TechnoTypeClass const *)obj)->Remap);
/*
** If there is already a factory producing this kind of object, then all
** objects of this type are displays in a disabled state.
*/
bool isbusy = (PlayerPtr->Fetch_Factory(Buildables[index].BuildableType) != NULL);
if (!isbusy && PlayerPtr->Is_Hack_Prevented(Buildables[index].BuildableType, Buildables[index].BuildableID)) {
isbusy = true;
}
/*
** Infantry don't get remapped in the sidebar (special case).
*/
if (Buildables[index].BuildableType == RTTI_INFANTRYTYPE) {
remapper = 0;
}
shapefile = obj->Get_Cameo_Data();
shapenum = 0;
if (Buildables[index].Factory != -1) {
factory = Factories.Raw_Ptr(Buildables[index].Factory);
production = true;
completed = factory->Has_Completed();
stage = factory->Completion();
darken = false;
} else {
production = false;
// darken = IsBuilding;
/*
** Darken the imagery if a factory of a matching type is
** already busy.
*/
darken = isbusy;
}
} else {
darken = PlayerPtr->Is_Hack_Prevented(Buildables[index].BuildableType, Buildables[index].BuildableID);
}
} else {
spc = SpecialWeaponType(Buildables[index].BuildableID);
shapefile = Get_Special_Cameo(spc);
shapenum = 0;
production = true;
completed = PlayerPtr->SuperWeapon[spc].Is_Ready();
stage = PlayerPtr->SuperWeapon[spc].Anim_Stage();
darken = false;
}
if (obj != NULL || spc != SPC_NONE) {
/*
** If this item is flashing then take care of it.
**
*/
if (Flasher == index && (Fetch_Stage() & 0x01)) {
remapper = Map.FadingLight;
}
} else {
shapefile = LogoShapes;
if (!darken) {
shapenum = SB_BLANK;
}
}
} else {
shapefile = LogoShapes;
shapenum = SB_BLANK;
production = false;
}
remapper = 0;
/*
** Now that the shape of the object at the current working slot has been found,
** draw it and any graphic overlays as necessary.
**
** Don't draw blank shapes over the new 640x400 sidebar art - ST 5/1/96 6:01PM
*/
if (shapenum != SB_BLANK || shapefile != LogoShapes) {
CC_Draw_Shape(shapefile, shapenum,
x-(WindowList[WINDOW_SIDEBAR][WINDOWX])+(LEFT_EDGE_OFFSET * RESFACTOR),
y-WindowList[WINDOW_SIDEBAR][WINDOWY],
WINDOW_SIDEBAR,
SHAPE_NORMAL|SHAPE_WIN_REL| (remapper ? SHAPE_FADING : SHAPE_NORMAL),
remapper);
/*
** Darken this object because it cannot be produced or is otherwise
** unavailable.
*/
if (darken) {
CC_Draw_Shape(ClockShapes, 0,
x-(WindowList[WINDOW_SIDEBAR][WINDOWX])+(LEFT_EDGE_OFFSET * RESFACTOR),
y-WindowList[WINDOW_SIDEBAR][WINDOWY],
WINDOW_SIDEBAR,
SHAPE_NORMAL|SHAPE_WIN_REL|SHAPE_GHOST,
NULL, ClockTranslucentTable);
}
}
/*
** Draw the overlapping clock shape if this is object is being constructed.
** If the object is completed, then display "Ready" with no clock shape.
*/
if (production) {
if (completed) {
/*
** Display text showing that the object is ready to place.
*/
CC_Draw_Shape(ObjectTypeClass::PipShapes, PIP_READY,
(x-(WindowList[WINDOW_SIDEBAR][WINDOWX]))+(LEFT_EDGE_OFFSET+15) * RESFACTOR,
(y-WindowList[WINDOW_SIDEBAR][WINDOWY])+(4 * RESFACTOR),
WINDOW_SIDEBAR, SHAPE_CENTER);
} else {
CC_Draw_Shape(ClockShapes, stage+1,
x-(WindowList[WINDOW_SIDEBAR][WINDOWX])+(LEFT_EDGE_OFFSET * RESFACTOR),
y-WindowList[WINDOW_SIDEBAR][WINDOWY],
WINDOW_SIDEBAR,
SHAPE_NORMAL|SHAPE_WIN_REL|SHAPE_GHOST,
NULL, ClockTranslucentTable);
/*
** Display text showing that the construction is temporarily on hold.
*/
if (factory && !factory->Is_Building()) {
CC_Draw_Shape(ObjectTypeClass::PipShapes, PIP_HOLDING,
(x-(WindowList[WINDOW_SIDEBAR][WINDOWX])) + ((LEFT_EDGE_OFFSET+15) * RESFACTOR),
(y-WindowList[WINDOW_SIDEBAR][WINDOWY])+(4 * RESFACTOR),
WINDOW_SIDEBAR, SHAPE_CENTER);
}
}
}
}
LastSlid = Slid;
}
}
/***********************************************************************************************
* SidebarClass::StripClass::Recalc -- Revalidates the current sidebar list of objects. *
* *
* This routine will revalidate all the buildable objects in the sidebar. This routine *
* comes in handy when a factory has been destroyed, and the sidebar needs to reflect any *
* change that this requires. It checks every object to see if there is a factory available *
* that could produce it. If none can be found, then the object is removed from the *
* sidebar. *
* *
* INPUT: none *
* *
* OUTPUT: bool; The sidebar has changed as a result of this call? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 01/19/1995 JLB : Created. *
* 06/26/1995 JLB : Doesn't collapse sidebar when buildables removed. *
*=============================================================================================*/
bool SidebarClass::StripClass::Recalc(void)
{
int ok;
if (Debug_Map || !BuildableCount) {
return(false);
}
/*
** Sweep through all objects listed in the sidebar. If any of those object can
** not be created -- even in theory -- then they must be removed form the sidebar and
** any current production must be abandoned.
*/
bool redraw = false;
for (int index = 0; index < BuildableCount; index++) {
TechnoTypeClass const * tech = Fetch_Techno_Type(Buildables[index].BuildableType, Buildables[index].BuildableID);
if (tech != NULL) {
ok = tech->Who_Can_Build_Me(true, false, PlayerPtr->Class->House) != NULL;
} else {
if ((unsigned)Buildables[index].BuildableID < SPC_COUNT) {
ok = PlayerPtr->SuperWeapon[Buildables[index].BuildableID].Is_Present();
} else {
ok = false;
}
}
if (!ok) {
/*
** Removes this entry from the list.
*/
if (BuildableCount > 1 && index < BuildableCount-1) {
memcpy(&Buildables[index], &Buildables[index+1], sizeof(Buildables[0])*((BuildableCount-index)-1));
}
TopIndex = 0;
IsToRedraw = true;
redraw = true;
BuildableCount--;
index--;
}
}
#ifdef NEVER
/*
** If there are no more buildable objects to display, make the sidebar go away.
*/
if (!BuildableCount) {
Map.SidebarClass::Activate(0);
}
#endif
return(redraw);
}
/***********************************************************************************************
* SidebarClass::StripClass::SelectClass::SelectClass -- Default constructor. *
* *
* This is the default constructor for the button that controls the buildable cameos on *
* the sidebar strip. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: The coordinates are set to zero by this routine. They must be set to the *
* correct values before this button will function. *
* *
* HISTORY: *
* 01/19/1995 JLB : Created. *
*=============================================================================================*/
SidebarClass::StripClass::SelectClass::SelectClass(void) :
ControlClass(0, 0, 0, (OBJECT_WIDTH-1) * RESFACTOR, OBJECT_HEIGHT * RESFACTOR, LEFTPRESS|RIGHTPRESS|LEFTUP),
Strip(0),
Index(0)
{
}
/***********************************************************************************************
* SidebarClass::StripClass::SelectClass:: -- Assigns special values to a buildable select but *
* *
* Use this routine to set custom buildable vars for this particular select button. It *
* uses this information to properly know what buildable object to start or stop production *
* on. *
* *
* INPUT: strip -- Reference to the strip that owns this buildable button. *
* *
* index -- The index (0 .. MAX_VISIBLE-1) of this button. This is used to let *
* the owning strip know what index this button refers to. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 01/19/1995 JLB : Created. *
*=============================================================================================*/
void SidebarClass::StripClass::SelectClass::Set_Owner(StripClass & strip, int index)
{
Strip = &strip;
Index = index;
X = strip.X;
Y = strip.Y + ((index * OBJECT_HEIGHT) * RESFACTOR);
}
/***********************************************************************************************
* SidebarClass::StripClass::SelectClass:: -- Action function when buildable cameo is selected *
* *
* This function is called when the buildable icon (cameo) is clicked on. It handles *
* starting and stopping production as indicated. *
* *
* INPUT: flags -- The input event that triggered the call. *
* *
* key -- The keyboard value at the time of the input. *
* *
* OUTPUT: Returns with whether the input list should be scanned further. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 01/19/1995 JLB : Created. *
* 10/09/1996 JLB : Sonar pulse converted to regular event type. *
*=============================================================================================*/
int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType & key)
{
int index = Strip->TopIndex + Index;
RTTIType otype = Strip->Buildables[index].BuildableType;
int oid = Strip->Buildables[index].BuildableID;
int fnumber = Strip->Buildables[index].Factory;
RemapControlType * scheme = GadgetClass::Get_Color_Scheme();
ObjectTypeClass const * choice = NULL;
SpecialWeaponType spc = SPC_NONE;
/*
** Determine the factory number that would apply to objects of the type
** the mouse is currently addressing. This doesn't mean that the factory number
** fetched is actually producing the indicated object, merely that that particular
** kind of factory is specified by the "genfactory" value. This can be used to see
** if the factory type is currently busy or not.
*/
FactoryClass * factory = PlayerPtr->Fetch_Factory(otype);
Map.Override_Mouse_Shape(MOUSE_NORMAL);
if (index < Strip->BuildableCount) {
if (otype != RTTI_SPECIAL) {
choice = Fetch_Techno_Type(otype, oid);
} else {
spc = SpecialWeaponType(oid);
}
if (fnumber != -1) {
factory = Factories.Raw_Ptr(fnumber);
}
} else {
Map.Help_Text(TXT_NONE);
}
if (spc != SPC_NONE) {
/*
** Display the help text if the mouse is over the button.
*/
if (flags & LEFTUP) {
Map.Help_Text(SpecialWeaponHelp[spc], X, Y, scheme->Color, true);
flags &= ~LEFTUP;
}
/*
** A right mouse button signals "cancel". If we are in targeting
** mode then we don't want to be any more.
*/
if (flags & RIGHTPRESS) {
Map.IsTargettingMode = SPC_NONE;
}
/*
** A left mouse press signal "activate". If our weapon type is
** available then we should activate it.
*/
if (flags & LEFTPRESS) {
if ((unsigned)spc < SPC_COUNT) {
if (PlayerPtr->SuperWeapon[spc].Is_Ready()) {
if (spc != SPC_SONAR_PULSE) {
Map.IsTargettingMode = spc;
Unselect_All();
Speak(VOX_SELECT_TARGET);
} else {
OutList.Add(EventClass(EventClass::SPECIAL_PLACE, SPC_SONAR_PULSE, 0));
}
} else {
PlayerPtr->SuperWeapon[spc].Impatient_Click();
}
}
}
} else {
if (choice != NULL) {
/*
** Display the help text if the mouse is over the button.
*/
if (flags & LEFTUP) {
Map.Help_Text(choice->Full_Name(), X, Y, scheme->Color, true);
Map.Set_Cost(choice->Cost_Of() * PlayerPtr->CostBias);
flags &= ~LEFTUP;
}
/*
** A right mouse button signals "cancel".
*/
if (flags & RIGHTPRESS) {
/*
** If production is in progress, put it on hold. If production is already
** on hold, then abandon it. Money will be refunded, the factory
** manager deleted, and the object under construction is returned to
** the free pool.
*/
if (factory != NULL) {
/*
** Cancels placement mode if the sidebar factory is abandoned or
** suspended.
*/
if (Map.PendingObjectPtr && Map.PendingObjectPtr->Is_Techno()) {
Map.PendingObjectPtr = 0;
Map.PendingObject = 0;
Map.PendingHouse = HOUSE_NONE;
Map.Set_Cursor_Shape(0);
}
if (!factory->Is_Building()) {
Speak(VOX_CANCELED);
OutList.Add(EventClass(EventClass::ABANDON, otype, oid));
} else {
Speak(VOX_SUSPENDED);
OutList.Add(EventClass(EventClass::SUSPEND, otype, oid));
Map.Column[0].IsToRedraw = true;
Map.Column[1].IsToRedraw = true;
}
}
}
if (flags & LEFTPRESS) {
/*
** If there is already a factory attached to this strip but the player didn't click
** on the icon that has the attached factory, then say that the factory is busy and
** ignore the click.
*/
if (fnumber == -1 && factory != NULL) {
Speak(VOX_NO_FACTORY);
ControlClass::Action(flags, key);
return(true);
}
if (factory != NULL) {
/*
** If this object is currently being built, then give a scold sound and text and then
** bail.
*/
if (factory->Is_Building()) {
Speak(VOX_NO_FACTORY);
} else {
/*
** If production has completed, then attempt to have the object exit
** the factory or go into placement mode.
*/
if (factory->Has_Completed()) {
TechnoClass * pending = factory->Get_Object();
if (!pending && factory->Get_Special_Item()) {
Map.IsTargettingMode = SPC_ANY;
} else {
BuildingClass * builder = pending->Who_Can_Build_Me(false, false);
if (!builder) {
OutList.Add(EventClass(EventClass::ABANDON, otype, oid));
Speak(VOX_NO_FACTORY);
} else {
/*
** If the completed object is a building, then change the
** game state into building placement mode. This fact is
** not transmitted to any linked computers until the moment
** the building is actually placed down.
*/
if (pending->What_Am_I() == RTTI_BUILDING) {
PlayerPtr->Manual_Place(builder, (BuildingClass *)pending);
} else {
/*
** For objects that can leave the factory under their own
** power, queue this event and process through normal house
** production channels.
*/
OutList.Add(EventClass(EventClass::PLACE, otype, -1));
}
}
}
} else {
if (PlayerPtr->Is_Hack_Prevented(otype, oid)) {
// Eva scolds the player here.
} else {
/*
** The factory must have been in a suspended state. Resume construction
** normally.
*/
if (otype == RTTI_INFANTRYTYPE) {
Speak(VOX_TRAINING);
} else {
Speak(VOX_BUILDING);
}
OutList.Add(EventClass(EventClass::PRODUCE, Strip->Buildables[index].BuildableType, Strip->Buildables[index].BuildableID));
}
}
}
} else {
if (PlayerPtr->Is_Hack_Prevented(otype, oid)) {
// Eva scolds the player here.
} else {
/*
** If this side strip is already busy with production, then ignore the
** input and announce this fact.
*/
if (otype == RTTI_INFANTRYTYPE) {
Speak(VOX_TRAINING);
} else {
Speak(VOX_BUILDING);
}
OutList.Add(EventClass(EventClass::PRODUCE, Strip->Buildables[index].BuildableType, Strip->Buildables[index].BuildableID));
}
}
}
} else {
flags = 0;
}
}
ControlClass::Action(flags, key);
return(true);
}
/***********************************************************************************************
* SidebarClass::SBGadgetClass::Action -- Special function that controls the mouse over the si *
* *
* This routine is called whenever the mouse is over the sidebar. It makes sure that the *
* mouse is always the normal shape while over the sidebar. *
* *
* INPUT: flags -- The event flags that resulted in this routine being called. *
* *
* key -- Reference the keyboard code that may be present. *
* *
* OUTPUT: Returns that no further keyboard processing is necessary. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/28/1995 JLB : Created. *
*=============================================================================================*/
int SidebarClass::SBGadgetClass::Action(unsigned , KeyNumType & )
{
Map.Help_Text(TXT_NONE);
Map.Override_Mouse_Shape(MOUSE_NORMAL, false);
return(true);
}
/***********************************************************************************************
* SidebarClass::StripClass::Factory_Link -- Links a factory to a sidebar button. *
* *
* This routine will link the specified factory to this sidebar strip. The exact button to *
* link to is determined from the object type and id specified. A linked button is one that *
* will show appropriate construction animation (clock shape) that matches the state of *
* the factory. *
* *
* INPUT: factory -- The factory number to link to the sidebar. *
* *
* type -- The object type that this factory refers to. *
* *
* id -- The object sub-type that this factory refers to. *
* *
* OUTPUT: Was the factory successfully attached? Failure would indicate that there is no *
* object of the specified type and sub-type in the sidebar list. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/18/1995 JLB : Created. *
*=============================================================================================*/
bool SidebarClass::StripClass::Factory_Link(int factory, RTTIType type, int id)
{
for (int index = 0; index < BuildableCount; index++) {
if (Buildables[index].BuildableType == type && Buildables[index].BuildableID == id) {
Buildables[index].Factory = factory;
IsBuilding = true;
/*
** Flag that all the icons on this strip need to be redrawn
*/
Flag_To_Redraw();
return(true);
}
}
return(false);
}
/***********************************************************************************************
* SidebarClass::Abandon_Production -- Stops production of the object specified. *
* *
* This routine is used to abandon production of the object specified. The factory will *
* be completely disabled by this call. *
* *
* INPUT: type -- The object type that is to be abandoned. The sub-type is not needed *
* since it is presumed there can be only one type in production at any *
* one time. *
* *
* factory -- The factory number that is doing the production. *
* *
* OUTPUT: Was the factory successfully abandoned? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/18/1995 JLB : Created. *
*=============================================================================================*/
bool SidebarClass::Abandon_Production(RTTIType type, int factory)
{
return(Column[Which_Column(type)].Abandon_Production(factory));
}
/***********************************************************************************************
* SidebarClass::StripClass::Abandon_Produ -- Abandons production associated with sidebar. *
* *
* Production of the object associated with this sidebar is abandoned when this routine is *
* called. *
* *
* INPUT: factory -- The factory index that is to be suspended. *
* *
* OUTPUT: Was the production abandonment successful? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/18/1995 JLB : Created. *
* 08/06/1995 JLB : More intelligent abandon logic for multiple factories. *
*=============================================================================================*/
bool SidebarClass::StripClass::Abandon_Production(int factory)
{
bool noprod = true;
bool abandon = false;
for (int index = 0; index < BuildableCount; index++) {
if (Buildables[index].Factory == factory) {
Factories.Raw_Ptr(factory)->Abandon();
Buildables[index].Factory = -1;
abandon = true;
} else {
if (Buildables[index].Factory != -1) {
noprod = false;
}
}
}
/*
** If there was a change to the strip, then flag the strip to be redrawn.
*/
if (abandon) {
Flag_To_Redraw();
}
/*
** If there is no production whatsoever on this strip, then flag it so.
*/
if (noprod) {
IsBuilding = false;
}
return(abandon);
}
/***********************************************************************************************
* SidebarClass::Zoom_Mode_Control -- Handles the zoom mode toggle operation. *
* *
* This is the function that is called when the map button is pressed. It will toggle *
* between the different modes that the radar map can assume. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/31/1996 JLB : Created. *
*=============================================================================================*/
void SidebarClass::Zoom_Mode_Control(void)
{
#ifdef WIN32
/*
** If radar is active, cycle as follows:
** Zoomed => not zoomed
** not zoomed => player status (multiplayer only)
** player status => radar spying readout
** radar spying readout => zoomed
*/
if (IsRadarActive) {
if (Is_Zoomed() || Session.Type==GAME_NORMAL) {
if (Is_Zoomed() || !Spy_Next_House()) {
Zoom_Mode(Coord_Cell(TacticalCoord));
}
} else {
if (!Spying_On_House() && !Is_Player_Names()) {
Player_Names(1);
} else {
Player_Names(0);
if (!Spy_Next_House()) {
Zoom_Mode(Coord_Cell(TacticalCoord));
}
}
}
} else {
if (Session.Type!=GAME_NORMAL) {
Player_Names(Is_Player_Names()==0);
}
}
#else
/*
** If radar is active, cycle as follows:
** not zoomed => player status (multiplayer only)
** player status => radar spying readout
** radar spying readout => not zoomed
*/
if (IsRadarActive) {
if (Session.Type==GAME_NORMAL) {
if (!Spy_Next_House()) {
Zoom_Mode(Coord_Cell(TacticalCoord));
}
} else {
if (!Spying_On_House() && !Is_Player_Names()) {
Player_Names(1);
} else {
Player_Names(0);
if (!Spy_Next_House()) {
Zoom_Mode(Coord_Cell(TacticalCoord));
}
}
}
} else {
if (Session.Type!=GAME_NORMAL) {
Player_Names(Is_Player_Names()==0);
}
}
#endif
}
Reference in New Issue View Git Blame Copy Permalink