hans/CnC_Remastered_Collection
1
0
Fork 0
mirror of https://github.com/jmarshall23/CnC_Remastered_Collection.git synced 2026-08-11 23:50:51 +02:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Merge branch 'master' into master"

Browse Source 
This reverts commit b91fab3474, reversing
changes made to 78812727c7.
This commit is contained in:
Justin Marshall
2020-07-02 13:42:08 -07:00
parent abfa27fa06
commit 33b9fd94bd
20 changed files with 740 additions and 1075 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+5 -6
View File
@@ -8,12 +8,11 @@
/fonts
/sound
/ui
/*.mix
/*.pal
/*.ini
/*.exe
/*.ilk
/*.MIX
/*.PAL
/*.INI
/*.DAT
/SAVEGAME*
/*.dat
/savegame*
/cache
code/CMakeLists.txt
+1 -3
View File
@@ -11,8 +11,6 @@ set(CMAKE_VERBOSE_MAKEFILE ON)
set(src_io
./redalert/io/userinput.cpp
./redalert/io/userinput.h
./redalert/io/eventqueue.h
./redalert/io/eventqueue.cpp
)
set(src_win32lib
@@ -742,4 +740,4 @@ if (UNIX)
set_target_properties(RedAlert PROPERTIES OUTPUT_NAME "RedAlert" RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/.." )
endif(UNIX)
target_include_directories(RedAlert PRIVATE ./external/xml/;./external/devil/;./external/;./redalert/win32lib;./redalert/io;./external/lua/;./external/imgui;./external/dxsdk/Include;./external/ffmpeg-win32/include;./external/sdl2/include;./win32lib;./external/openal/include)
target_include_directories(RedAlert PRIVATE ./external/xml/;./external/devil/;./external/;./redalert/win32lib;./external/lua/;./external/imgui;./external/dxsdk/Include;./external/ffmpeg-win32/include;./external/sdl2/include;./win32lib;./external/openal/include)
code/redalert/conquer.cpp
+5 -5
View File
@@ -743,7 +743,7 @@ void Keyboard_Process(KeyNumType & input)
** Center the map about the construction yard or construction vehicle
** if one is present.
*/
if (key != 0 && key == Options.KeyBase) {
if (key != 0 && key == VK_H) {
Unselect_All();
if (PlayerPtr->CurBuildings) {
for (index = 0; index < Buildings.Count(); index++) {
@@ -875,19 +875,19 @@ void Keyboard_Process(KeyNumType & input)
** Scrolls the tactical map in the direction specified.
*/
int distance = CELL_LEPTON_W;
if (key != 0 && key == KN_LEFT) {
if (key != 0 && key == VK_LEFT) {
Map.Scroll_Map(DIR_W, distance, true);
input = KN_NONE;
}
if (key != 0 && key == KN_RIGHT) {
if (key != 0 && key == VK_RIGHT) {
Map.Scroll_Map(DIR_E, distance, true);
input = KN_NONE;
}
if (key != 0 && key == KN_UP) {
if (key != 0 && key == VK_UP) {
Map.Scroll_Map(DIR_N, distance, true);
input = KN_NONE;
}
if (key != 0 && key == KN_DOWN) {
if (key != 0 && key == VK_DOWN) {
Map.Scroll_Map(DIR_S, distance, true);
input = KN_NONE;
}
code/redalert/display.h
+1 -1
View File
@@ -275,7 +275,7 @@ class DisplayClass: public MapClass
*/
class TacticalClass : public GadgetClass {
public:
TacticalClass(void) : GadgetClass(0,0,0,0,KEYBOARD|LEFTPRESS|LEFTRELEASE|LEFTHELD|LEFTUP|RIGHTPRESS,true) {};
TacticalClass(void) : GadgetClass(0,0,0,0,LEFTPRESS|LEFTRELEASE|LEFTHELD|LEFTUP|RIGHTPRESS,true) {};
int Selection_At_Mouse(unsigned flags, KeyNumType & key);
int Command_Object(unsigned flags, KeyNumType & key);
code/redalert/edit.cpp
+48 -21
View File
@@ -253,8 +253,39 @@ int EditClass::Action(unsigned flags, KeyNumType & key)
} else {
#ifdef WIN32
//KeyASCIIType ascii = (KeyASCIIType)(Keyboard->To_ASCII(key) & 0xff);
Handle_Key(key, flags);
KeyASCIIType ascii = (KeyASCIIType)(Keyboard->To_ASCII(key) & 0xff);
/*
** Allow numeric keypad presses to map to ascii numbers
*/
if ((key & WWKEY_VK_BIT) && ascii >='0' && ascii <= '9') {
key = (KeyNumType)(key & ~WWKEY_VK_BIT);
if ( (!(flags & LEFTRELEASE)) && (!(flags & RIGHTRELEASE))) {
if (Handle_Key (ascii) ) {
flags &= ~KEYBOARD;
key = KN_NONE;
}
}
} else {
/*
** Filter out all special keys except return and backspace
*/ if ((!(key & WWKEY_VK_BIT) && ascii >= ' ' && ascii <= 255)
|| key == KN_RETURN || key == KN_BACKSPACE) {
if ((!(flags & LEFTRELEASE)) && (!(flags & RIGHTRELEASE))) {
if (Handle_Key(Keyboard->To_ASCII(key))) {
flags &= ~KEYBOARD;
key = KN_NONE;
}
}
} else {
flags &= ~KEYBOARD;
key = KN_NONE;
}
}
}
#else //WIN32
@@ -343,11 +374,11 @@ void EditClass::Draw_Text(char const * text)
* HISTORY: *
* 01/21/1995 JLB : Created. *
*=============================================================================================*/
bool EditClass::Handle_Key(KeyNumType key, unsigned flags)
bool EditClass::Handle_Key(KeyASCIIType ascii)
{
unsigned rawKey = key & 0xff;
unsigned char testAscii = (unsigned char)ascii;
switch (rawKey) {
switch (ascii) {
/*
** Handle the special case of a non-keyboard event. It is possible that this
** key code might be passed to this routine if this routine has been overridden
@@ -356,7 +387,6 @@ bool EditClass::Handle_Key(KeyNumType key, unsigned flags)
case 0:
break;
/*
** If the return key is pressed, then remove the focus from this edit
** gadget but otherwise let the normal gadget processing proceed. This
@@ -364,14 +394,14 @@ bool EditClass::Handle_Key(KeyNumType key, unsigned flags)
** so that the controlling program will know that the text can be
** processed.
*/
case KN_RETURN:
case KA_RETURN:
Clear_Focus();
return(false);
/*
** When the BACKSPACE key is pressed, remove the last character in the edit string.
*/
case KN_BACKSPACE:
case KA_BACKSPACE:
if (Length) {
Length--;
String[Length] = '\0';
@@ -384,13 +414,11 @@ bool EditClass::Handle_Key(KeyNumType key, unsigned flags)
** if it can legally be added to the edit string and do so if possible.
*/
default:
unsigned char keyAscii = UserInput.KeyB.ASCII;
if (key & KN_SHIFT_BIT || key & KN_CAPSLOCK_BIT) keyAscii = toupper(keyAscii);
/*
** Don't add a character if the length is greater than edit width.
*/
if (((int)String_Pixel_Width(String) + (int)Char_Pixel_Width(keyAscii) ) >= (Width-2)) {
if (((int)String_Pixel_Width(String) + (int)Char_Pixel_Width(testAscii) ) >= (Width-2)) {
break;
}
@@ -403,21 +431,21 @@ bool EditClass::Handle_Key(KeyNumType key, unsigned flags)
** Invisible characters are never added to the string. This is
** especially true for spaces at the beginning of the string.
*/
if (!isgraph(keyAscii) && keyAscii != ' ') break;
if (keyAscii == ' ' && Length == 0) break;
if (!isgraph(testAscii) && testAscii != ' ') break;
if (testAscii == ' ' && Length == 0) break;
/*
** If this is an upper case only edit gadget, then force the alphabetic
** character to upper case.
*/
if ((EditFlags & UPPERCASE) && isalpha(keyAscii)) {
rawKey = (KeyASCIIType)toupper(keyAscii);
if ((EditFlags & UPPERCASE) && isalpha(testAscii)) {
testAscii = (KeyASCIIType)toupper(testAscii);
}
if ((!(EditFlags & NUMERIC) || !isdigit(keyAscii)) &&
(!(EditFlags & ALPHA) || !isalpha(keyAscii)) &&
(!(EditFlags & MISC) || isalnum(keyAscii)) &&
rawKey != ' ') {
if ((!(EditFlags & NUMERIC) || !isdigit(testAscii)) &&
(!(EditFlags & ALPHA) || !isalpha(testAscii)) &&
(!(EditFlags & MISC) || isalnum(testAscii)) &&
testAscii != ' ') {
break;
}
@@ -427,9 +455,8 @@ bool EditClass::Handle_Key(KeyNumType key, unsigned flags)
** because the event flag has been cleared. This prevents the gadget's ID
** number from being returned just because the gadget has been edited.
*/
String[Length++] = keyAscii;
String[Length++] = testAscii;
String[Length] = '\0';
Flag_To_Redraw();
break;
}
code/redalert/edit.h
+1 -1
View File
@@ -91,7 +91,7 @@ class EditClass : public ControlClass
virtual int Action (unsigned flags, KeyNumType &key);
virtual void Draw_Background(void);
virtual void Draw_Text(char const * text);
virtual bool Handle_Key(KeyNumType ascii, unsigned flags);
virtual bool Handle_Key(KeyASCIIType ascii);
private:
int IsReadOnly;
code/redalert/externs.h
-1
View File
@@ -162,7 +162,6 @@ extern PKey SlowKey;
extern RulesClass Rule;
extern KeyboardClass * Keyboard;
extern UserInputClass UserInput;
extern EventQueueClass EventQueue;
extern RandomStraw CryptRandom;
extern RandomClass NonCriticalRandomNumber;
extern CarryoverClass * Carryover;
code/redalert/function.h
+1 -2
View File
@@ -200,8 +200,7 @@ struct NoInitClass {
#endif
#include "key.h"
#include "io/userinput.h"
#include "io/eventqueue.h"
#include "io/UserInput.h"
#include <wwlib32.h>
#include "mpu.h"
code/redalert/gadget.cpp
+77 -21
View File
@@ -471,9 +471,7 @@ void GadgetClass::Draw_All(bool forced)
*=========================================================================*/
KeyNumType GadgetClass::Input(void)
{
EventMessage eventMessage;
KeyNumType key = KN_NONE;
int flags = 0;
KeyNumType key;
int forced = false;
/*
@@ -490,13 +488,77 @@ KeyNumType GadgetClass::Input(void)
/*
** Fetch any pending keyboard input.
*/
UserInput.Process_Input(key, flags);
if (EventQueue.Check()) {
eventMessage = EventQueue.Get();
eventMessage.Key_Flags(key, flags);
key = Keyboard->Check();
if (key != 0) {
key = Keyboard->Get();
}
/*
** For mouse button clicks, the mouse position is actually held in the MouseQ...
** globals rather than their normal Mouse... globals. This is because we need to
** know the position of the mouse at the exact instant when the click occurred
** rather the the mouse position at the time we get around to this function.
*/
// jmarshall
UserInput.Process_Input( g_globalKeyNumType, g_globalKeyFlags);
int flags = g_globalKeyFlags;
// jmarshall end
/*
** Set the mouse button state flags. These will be passed to the individual
** buttons so that they can determine what action to perform (if any).
*/
//if (key) {
// if (key == KN_LMOUSE) {
// flags |= LEFTPRESS;
// }
// if (key == KN_RMOUSE) {
// flags |= RIGHTPRESS;
// }
// if (key == (KN_LMOUSE | KN_RLSE_BIT)) {
// flags |= LEFTRELEASE;
// }
// if (key == (KN_RMOUSE | KN_RLSE_BIT)) {
// flags |= RIGHTRELEASE;
// }
//}
/*
** If the mouse wasn't responsible for this key code, then it must be from
** the keyboard. Flag this fact.
*/
if (key && !flags) {
flags |= KEYBOARD;
}
/*
** Mouse button up or down action is ignored if there is a keyboard event. This
** allows keyboard events to fall through normally even if the mouse is over a
** gadget that is flagged for LEFTUP or RIGHTUP.
*/
// jmarshall
//if (!key) {
//
// /*
// ** Check for the mouse being held down. We can't use the normal input system
// ** for this, so we must examine the actual current state of the mouse
// ** buttons. As a side note, if we determine that the mouse button isn't being
// ** held down, then we automatically know that it must be up -- set the flag
// ** accordingly.
// */
// if (Keyboard->Down(KN_LMOUSE)) {
// flags |= LEFTHELD;
// } else {
// flags |= LEFTUP;
// }
// if (Keyboard->Down(KN_RMOUSE)) {
// flags |= RIGHTHELD;
// } else {
// flags |= RIGHTUP;
// }
//}
// jmarshall end
/*
** If "sticky" processing is active, then only process the stuck gadget.
*/
@@ -504,35 +566,30 @@ KeyNumType GadgetClass::Input(void)
StuckOn->Draw_Me(false);
GadgetClass * oldstuck = StuckOn;
StuckOn->Clicked_On(key, flags, UserInput.Mouse.X, UserInput.Mouse.Y);
if (StuckOn)
{
if (StuckOn) {
StuckOn->Draw_Me(false);
}
else {
} else {
oldstuck->Draw_Me(false);
}
}
else
{
} else {
/*
** If there is a gadget that has the keyboard focus, then route all keyboard
** events to it.
*/
if (Focused && eventMessage.EventType == EventMessageType::EVENT_KEYBOARD) {
if (Focused && (flags & KEYBOARD)) {
Focused->Draw_Me(false);
Focused->Clicked_On(key, flags, UserInput.Mouse.X, UserInput.Mouse.Y);
if (Focused) {
Focused->Draw_Me(false);
}
}
else {
} else {
/*
** Sweep through all the buttons in the chain and pass the current button state
** and keyboard input data to them. These routines will detect whether they should
** perform some action and return a flag to this effect. They also have the option
** of changing the key value so that an appropriate return value is used for this
** of changing the key value so that an appropriate return value is use for this
** processing routine.
*/
GadgetClass * next_button = this;
@@ -564,7 +621,6 @@ KeyNumType GadgetClass::Input(void)
}
}
}
return(key);
}
code/redalert/globals.cpp
-1
View File
@@ -257,7 +257,6 @@ RulesClass Rule;
** user input class pointer.
*/
UserInputClass UserInput;
EventQueueClass EventQueue;
/***************************************************************************
** All keyboard input is routed through the object pointed to by this
code/redalert/io/eventqueue.cpp
-157
View File
@@ -1,157 +0,0 @@
#include "../function.h"
#include "eventqueue.h"
/*
Clears the event queue and frees memory
*/
void EventQueueClass::Clear()
{
while (this->eventQueue.size() > 0) {
this->eventQueue.pop();
}
}
/*
Inserts a new event message event into the FIFO buffer.
*/
void EventQueueClass::Put(EventMessage input)
{
if ( Is_Buffer_Full() ) return;
this->eventQueue.push( input );
}
/*
Check if the buffer contains an element
*/
bool EventQueueClass::Check() const
{
return !this->Is_Buffer_Empty();
}
/*
Get the first (unprocessed) element in the event queue
*/
EventMessage EventQueueClass::Get()
{
// wait for buffer
while( !this->Check() ) { }
EventMessage returnVal = this->eventQueue.front();
this->eventQueue.pop();
return returnVal;
}
/*
Returns ASCII value of the key in the buffer
*/
char EventQueueClass::Get_ASCII()
{
// get the last key from the buffer
EventMessage eventMessage = this->Get();
return eventMessage.Keyboard.ASCII;
}
EventMessage::EventMessage(KeyNumType key, char ascii, bool shift, bool alt, bool control, bool capsLock) {
this->Clear();
this->Valid = true;
this->EventType = EventMessageType::EVENT_KEYBOARD;
this->Keyboard.Key = key;
this->Keyboard.Shift = shift;
this->Keyboard.Alt = alt;
this->Keyboard.Control = control;
this->Keyboard.CapsLock = capsLock;
this->Keyboard.ASCII = ascii;
}
EventMessage::EventMessage(int x, int y, unsigned short button, MouseButtonState buttonState)
{
this->Clear();
this->Valid = true;
this->EventType = EventMessageType::EVENT_MOUSE;
this->Mouse.x = x;
this->Mouse.y = y;
this->Mouse.Button = button;
this->Mouse.ButtonState = buttonState;
this->Flags = 0;
if (buttonState == MouseButtonState::MOUSE_BUTTON_UP) {
this->Flags = (button == KN_LMOUSE) ? GadgetClass::LEFTUP : GadgetClass::RIGHTUP;
}
if (buttonState == MouseButtonState::MOUSE_BUTTON_DOWN) {
this->Flags = (button == KN_LMOUSE) ? GadgetClass::LEFTPRESS : GadgetClass::RIGHTPRESS;
}
if (buttonState == MouseButtonState::MOUSE_BUTTON_HOLD) {
this->Flags = (button == KN_LMOUSE) ? GadgetClass::LEFTHELD : GadgetClass::RIGHTHELD;
}
if (buttonState == MouseButtonState::MOUSE_BUTTON_RELEASE) {
this->Flags = (button == KN_LMOUSE) ? GadgetClass::LEFTRELEASE : GadgetClass::RIGHTRELEASE;
}
}
void EventMessage::Key_Flags(KeyNumType& key, int& flags)
{
if (this->EventType == EventMessageType::EVENT_KEYBOARD)
{
flags = this->Flags;
flags |= GadgetClass::KEYBOARD;
unsigned short outputKey = this->Keyboard.Key;
if (this->Keyboard.Shift) outputKey |= KN_SHIFT_BIT;
if (this->Keyboard.Alt) outputKey |= KN_ALT_BIT;
if (this->Keyboard.Control) outputKey |= KN_CTRL_BIT;
key = (KeyNumType)outputKey;
}
if (this->EventType == EventMessageType::EVENT_MOUSE)
{
key = (KeyNumType)this->Mouse.Button;
if (key == KN_LMOUSE) {
switch (this->Mouse.ButtonState)
{
case MouseButtonState::MOUSE_BUTTON_UP:
flags = GadgetClass::LEFTUP;
break;
case MouseButtonState::MOUSE_BUTTON_DOWN:
flags = GadgetClass::LEFTPRESS;
break;
case MouseButtonState::MOUSE_BUTTON_RELEASE:
flags = GadgetClass::LEFTRELEASE;
break;
case MouseButtonState::MOUSE_BUTTON_HOLD:
flags = GadgetClass::LEFTHELD;
break;
}
}
if (key == KN_RMOUSE) {
switch (this->Mouse.ButtonState)
{
case MouseButtonState::MOUSE_BUTTON_UP:
flags = GadgetClass::LEFTUP;
break;
case MouseButtonState::MOUSE_BUTTON_DOWN:
flags = GadgetClass::RIGHTPRESS;
break;
case MouseButtonState::MOUSE_BUTTON_RELEASE:
flags = GadgetClass::RIGHTRELEASE;
break;
case MouseButtonState::MOUSE_BUTTON_HOLD:
flags = GadgetClass::RIGHTHELD;
break;
}
}
}
}
code/redalert/io/eventqueue.h
-121
View File
@@ -1,121 +0,0 @@
#pragma once
#include <memory>
/*
* WWKeyboardClass::Buff_Get -- Lowlevel function to get a key from key buffer*
* WWKeyboardClass::Check -- Checks to see if a key is in the buffer*
* WWKeyboardClass::Down -- Checks to see if the specified key is being held down.*
* WWKeyboardClass::Fetch_Element -- Extract the next element in the keyboard buffer.*
* WWKeyboardClass::Get -- Logic to get a metakey from the buffer*
* WWKeyboardClass::Message_Handler -- Process a windows message as it relates to the keyboar*
* WWKeyboardClass::Peek_Element -- Fetches the next element in the keyboard buffer.*
* WWKeyboardClass::To_ASCII -- Convert the key value into an ASCII representation.*
* WWKeyboardClass::Available_Buffer_Room -- Fetch the quantity of free elements in the keybo*
* ----------------------------------------------*/
/**
* EVENT QUEUE class
* Supports pumping of event messages using a FIFO buffer.
*/
extern UserInputClass UserInput;
/*
Event type definitions
*/
typedef enum EventMessageType {
EVENT_NONE,
EVENT_KEYBOARD,
EVENT_MOUSE
};
/*
Event types
*/
class EventMessage {
public:
EventMessageType EventType;
bool Valid;
EventMessage() {
this->EventType == EVENT_NONE;
this->Keyboard.Key = KN_NONE;
this->Keyboard.Shift = false;
this->Keyboard.Alt = false;
this->Keyboard.Control = false;
this->Keyboard.CapsLock = false;
this->Mouse.x = -1;
this->Mouse.y = -1;
this->Mouse.Button = 0;
this->Mouse.ButtonState = MouseButtonState::MOUSE_BUTTON_UP;
this->Flags = 0;
this->Valid = false;
}
// for keyboard
struct {
KeyNumType Key;
char ASCII;
bool Shift;
bool Alt;
bool Control;
bool CapsLock;
} Keyboard;
// for mouse
struct {
int x;
int y;
unsigned short Button;
MouseButtonState ButtonState;
} Mouse;
// for cascading functions
unsigned short Flags;
EventMessage( KeyNumType key, char asciis, bool shift, bool alt, bool control, bool capsLock );
EventMessage( int x, int y, unsigned short button = KN_LMOUSE, MouseButtonState buttonState = MouseButtonState::MOUSE_BUTTON_DOWN );
void Key_Flags(KeyNumType& key, int& flags);
private:
void Clear() {
this->Keyboard.Key = KN_NONE;
this->Keyboard.Shift = false;
this->Keyboard.Alt = false;
this->Keyboard.Control = false;
this->Keyboard.CapsLock = false;
this->Mouse.x = -1;
this->Mouse.y = -1;
this->Mouse.Button = 0;
this->Mouse.ButtonState = MouseButtonState::MOUSE_BUTTON_UP;
this->Flags = 0;
this->Valid = false;
}
};
class EventQueueClass {
public:
int Get_Mouse_X() const { return UserInput.Mouse.X; }
int Get_Mouse_Y() const { return UserInput.Mouse.Y; }
void Clear();
void Put(EventMessage input);
bool Check() const;
EventMessage Get();
char EventQueueClass::Get_ASCII();
private:
const int MaxCapacity = 100;
std::queue< EventMessage > eventQueue;
bool Is_Buffer_Full() const { return this->eventQueue.size() == MaxCapacity; }
bool Is_Buffer_Empty() const { return this->eventQueue.size() == 0; }
};
code/redalert/io/userinput.cpp
+16 -93
View File
@@ -1,60 +1,18 @@
#include "../function.h"
#include "userinput.h"
#include "../FUNCTION.H"
#include "UserInput.h"
extern KeyboardClass * Keyboard;
std::map<KeyNumType, SDL_KeyCode> sdl_keyMapping_reverse;
UserInputClass::UserInputClass()
{
LastAction = InputAction::INPUT_ACTION_NONE;
// generate reverse keymapping
for (auto it = sdl_keyMapping.begin(); it != sdl_keyMapping.end(); it++)
{
sdl_keyMapping_reverse[it->second] = it->first;
}
}
bool UserInputClass::KeyboardState::Key_Down(KeyNumType key) const
{
auto sdl_Key = sdl_keyMapping_reverse.find(key);
if (sdl_Key != sdl_keyMapping_reverse.end())
{
const SDL_Scancode scanCode = SDL_GetScancodeFromKey(sdl_Key->second);
const Uint8* keyState = SDL_GetKeyboardState(NULL);
return (keyState[scanCode]);
}
return false;
}
bool UserInputClass::MouseState::Mouse_Down(KeyNumType key) const
{
// get mouse state, we are only interested in the buttons
const Uint32 MouseState = SDL_GetMouseState(NULL, NULL);
switch (key)
{
case KN_LMOUSE:
return MouseState & SDL_BUTTON(SDL_BUTTON_LEFT);
break;
case KN_RMOUSE:
return MouseState & SDL_BUTTON(SDL_BUTTON_RIGHT);
break;
}
}
void UserInputClass::Process_Input(KeyNumType& key, int& flags)
{
bool leftMouseProcessed = false;
const Uint32 MouseState = SDL_GetMouseState(&Mouse.X, &Mouse.Y);
flags = 0;
SDL_GetMouseState(&Mouse.X, &Mouse.Y);
Keyboard->MouseQX = Mouse.X;
Keyboard->MouseQY = Mouse.Y;
flags = 0;
static SDL_Event event;
memset(&event, 0, sizeof(SDL_Event));
@@ -86,13 +44,8 @@ void UserInputClass::Process_Input(KeyNumType& key, int& flags)
break;
/* Mouse is moving */
case SDL_MOUSEMOTION:
if (!(MouseState & SDL_BUTTON(SDL_BUTTON_LEFT)))
{
flags |= GadgetClass::LEFTUP;
}
flags = GadgetClass::LEFTUP;
break;
case SDL_MOUSEBUTTONDOWN:
@@ -102,22 +55,20 @@ void UserInputClass::Process_Input(KeyNumType& key, int& flags)
key = KN_LMOUSE;
flags |= GadgetClass::LEFTPRESS;
EventQueue.Put(EventMessage(Mouse.X, Mouse.Y, KN_LMOUSE));
Keyboard->Put_Element(KN_LMOUSE);
leftMouseProcessed = true;
numFramesLMouse++;
// after first left-mouse down, abort handling any other SDL events
// because game might first need to switch into rubber band mode
if (numFramesLMouse == 1) return;
// Seems to fix "missed mouse click" bug
if (numFramesLMouse == 0) {
numFramesLMouse++;
return;
}
numFramesLMouse++;
}
else if (event.button.button == SDL_BUTTON_RIGHT) {
Mouse.Button_Right == MouseButtonState::MOUSE_BUTTON_DOWN;
EventQueue.Put(EventMessage(Mouse.X, Mouse.Y, KN_RMOUSE));
Keyboard->Put_Element(KN_RMOUSE);
key = KN_RMOUSE;
@@ -130,29 +81,19 @@ void UserInputClass::Process_Input(KeyNumType& key, int& flags)
case SDL_MOUSEBUTTONUP:
if (event.button.button == SDL_BUTTON_LEFT) {
Mouse.Button_Left == MouseButtonState::MOUSE_BUTTON_RELEASE;
EventQueue.Put(EventMessage(Mouse.X, Mouse.Y, KN_LMOUSE, MouseButtonState::MOUSE_BUTTON_RELEASE));
flags &= GadgetClass::LEFTPRESS;
flags |= GadgetClass::LEFTRELEASE;
numFramesLMouse = 0;
}
else if (event.button.button == SDL_BUTTON_RIGHT) {
Mouse.Button_Right == MouseButtonState::MOUSE_BUTTON_RELEASE;
EventQueue.Put(EventMessage(Mouse.X, Mouse.Y, KN_RMOUSE, MouseButtonState::MOUSE_BUTTON_RELEASE));
flags &= GadgetClass::RIGHTPRESS;
flags |= GadgetClass::RIGHTRELEASE;
numFramesLMouse = 0;
}
break;
// Keyboard key lifted up
case SDL_KEYUP:
flags |= GadgetClass::KEYBOARD;
break;
// Keyboard key pressed down
case SDL_KEYDOWN:
{
if (event.key.keysym.scancode == SDL_SCANCODE_GRAVE) {
@@ -169,14 +110,7 @@ void UserInputClass::Process_Input(KeyNumType& key, int& flags)
break;
}
flags |= GadgetClass::KEYBOARD;
int keyFlags = 0x00;
KeyB.Shift = false;
KeyB.Alt = false;
KeyB.Control = false;
KeyB.CapsLock = false;
if (state[SDL_SCANCODE_RSHIFT] || state[SDL_SCANCODE_LSHIFT]) {
KeyB.Shift = true;
keyFlags |= KN_SHIFT_BIT;
@@ -189,22 +123,13 @@ void UserInputClass::Process_Input(KeyNumType& key, int& flags)
keyFlags |= KN_CTRL_BIT;
KeyB.Control = true;
}
if (state[SDL_SCANCODE_CAPSLOCK]) {
keyFlags |= KN_CAPSLOCK_BIT;
KeyB.CapsLock = true;
}
// handle match between SDL and internals (non-text keys)
auto element = sdl_keyMapping.find((SDL_KeyCode)event.key.keysym.sym);
if (element != sdl_keyMapping.end())
{
//EventQueue.Put( element->second | keyFlags );
EventQueue.Put(EventMessage((KeyNumType)element->second, element->second, KeyB.Shift, KeyB.Alt, KeyB.Control, KeyB.CapsLock));
Keyboard->Put_Element(element->second | keyFlags);
KeyB.LastKey = element->first;
KeyB.ASCII = 0x0;
KeyB.ASCII = element->second;
}
break;
@@ -226,8 +151,6 @@ void UserInputClass::Process_Input(KeyNumType& key, int& flags)
if (!leftMouseProcessed && numFramesLMouse != 0)
{
Mouse.Button_Left == MouseButtonState::MOUSE_BUTTON_HOLD;
flags |= GadgetClass::LEFTHELD;
EventQueue.Put(EventMessage(Mouse.X, Mouse.Y, KN_LMOUSE, MouseButtonState::MOUSE_BUTTON_HOLD));
flags = GadgetClass::LEFTHELD;
}
}
code/redalert/io/userinput.h
+7 -23
View File
@@ -1,9 +1,9 @@
#pragma once
#ifndef USERINPUT_H
#define USERINPUT_H
#include <SDL.h>
#include <SDL_syswm.h>
#include <map>
#include <queue>
#include "examples/imgui_impl_sdl.h"
@@ -86,20 +86,11 @@ std::map<SDL_KeyCode, KeyNumType> const sdl_keyMapping = {
{ SDLK_DOWN, KN_DOWN },
{ SDLK_LEFT, KN_LEFT },
{ SDLK_RIGHT, KN_RIGHT },
{ SDLK_LALT, KN_LALT },
{ SDLK_RALT, KN_RALT },
{ SDLK_LCTRL, KN_LCTRL },
{ SDLK_RCTRL, KN_RCTRL },
{ SDLK_LSHIFT, KN_LSHIFT },
{ SDLK_RSHIFT, KN_RSHIFT },
};
extern std::map<KeyNumType, SDL_KeyCode> sdl_keyMapping_reverse;
const int USERINPUT_SHIFT_BIT = 0x100;
const int USERINPUT_CTRL_BIT = 0x200;
const int USERINPUT_ALT_BIT = 0x400;
class UserInputClass
{
public:
typedef enum {
MOUSE_BUTTON_UP,
MOUSE_BUTTON_DOWN,
@@ -113,10 +104,6 @@ typedef enum {
INPUT_ACTION_MOUSE,
} InputAction;
class UserInputClass
{
public:
UserInputClass();
void UserInputClass::Process_Input(KeyNumType& key = g_globalKeyNumType, int& flags = g_globalKeyFlags);
InputAction LastAction;
@@ -129,9 +116,6 @@ public:
bool Shift;
bool Control;
bool Alt;
bool CapsLock;
bool Key_Down(KeyNumType key) const;
void ResetState() {
this->Shift = false;
@@ -151,8 +135,6 @@ public:
MouseButtonState Button_Middle;
MouseButtonState Button_Right;
bool UserInputClass::MouseState::Mouse_Down(KeyNumType key) const;
void ResetState() {
this->Button_Left = MouseButtonState::MOUSE_BUTTON_UP;
this->Button_Middle = MouseButtonState::MOUSE_BUTTON_UP;
@@ -164,3 +146,5 @@ public:
private:
int numFramesLMouse = 0;
};
#endif
code/redalert/key.cpp
+1 -1
View File
@@ -372,7 +372,7 @@ bool WWKeyboardClass::Down(unsigned short key)
return g_globalKeyFlags & GadgetClass::RIGHTPRESS;
}
return UserInput.KeyB.Key_Down((KeyNumType)key);
return(GetAsyncKeyState(key & 0xFF) == 0 ? false : true);
}
code/redalert/key.h
+107 -112
View File
@@ -525,124 +525,119 @@ typedef enum KeyASCIIType {
typedef enum KeyNumType {
KN_NONE = 0,
KN_0,
KN_1,
KN_2,
KN_3,
KN_4,
KN_5,
KN_6,
KN_7,
KN_8,
KN_9,
KN_A,
KN_B,
KN_C,
KN_D,
KN_E,
KN_F,
KN_G,
KN_H,
KN_I,
KN_J,
KN_K,
KN_L,
KN_M,
KN_N,
KN_O,
KN_P,
KN_Q,
KN_R,
KN_S,
KN_T,
KN_U,
KN_V,
KN_W,
KN_X,
KN_Y,
KN_Z,
KN_BACKSLASH,
KN_BACKSPACE,
KN_CAPSLOCK,
KN_CENTER,
KN_COMMA,
KN_DELETE,
KN_DOWN,
KN_DOWNLEFT,
KN_DOWNRIGHT,
KN_END,
KN_EQUAL,
KN_ESC,
KN_E_DELETE,
KN_E_DOWN,
KN_E_END,
KN_E_HOME,
KN_E_INSERT,
KN_E_LEFT,
KN_E_PGDN,
KN_E_PGUP,
KN_E_RIGHT,
KN_E_UP,
KN_GRAVE,
KN_HOME,
KN_INSERT,
KN_KEYPAD_ASTERISK,
KN_KEYPAD_MINUS,
KN_KEYPAD_PLUS,
KN_KEYPAD_RETURN,
KN_KEYPAD_SLASH,
KN_MINUS,
KN_NUMLOCK,
KN_PAUSE,
KN_PERIOD,
KN_PGDN,
KN_PGUP,
KN_PRNTSCRN,
KN_SCROLLLOCK,
KN_SEMICOLON,
KN_SLASH,
KN_SPACE,
KN_SQUOTE,
KN_TAB,
KN_UP,
KN_UPLEFT,
KN_UPRIGHT,
KN_LALT,
KN_LBRACKET,
KN_LCTRL,
KN_LEFT,
KN_LMOUSE,
KN_LSHIFT,
KN_RALT,
KN_RBRACKET,
KN_RCTRL,
KN_RETURN,
KN_RIGHT,
KN_RMOUSE,
KN_RSHIFT,
KN_F1,
KN_F2,
KN_F3,
KN_F4,
KN_F5,
KN_F6,
KN_F7,
KN_F8,
KN_F9,
KN_F10,
KN_F11,
KN_F12,
KN_0 = VK_0,
KN_1 = VK_1,
KN_2 = VK_2,
KN_3 = VK_3,
KN_4 = VK_4,
KN_5 = VK_5,
KN_6 = VK_6,
KN_7 = VK_7,
KN_8 = VK_8,
KN_9 = VK_9,
KN_A = VK_A,
KN_B = VK_B,
KN_BACKSLASH = VK_NONE_DC,
KN_BACKSPACE = VK_BACK,
KN_C = VK_C,
KN_CAPSLOCK = VK_CAPITAL,
KN_CENTER = VK_CLEAR,
KN_COMMA = VK_NONE_BC,
KN_D = VK_D,
KN_DELETE = VK_DELETE,
KN_DOWN = VK_DOWN,
KN_DOWNLEFT = VK_END,
KN_DOWNRIGHT = VK_NEXT,
KN_E = VK_E,
KN_END = VK_END,
KN_EQUAL = VK_NONE_BB,
KN_ESC = VK_ESCAPE,
KN_E_DELETE = VK_DELETE,
KN_E_DOWN = VK_NUMPAD2,
KN_E_END = VK_NUMPAD1,
KN_E_HOME = VK_NUMPAD7,
KN_E_INSERT = VK_INSERT,
KN_E_LEFT = VK_NUMPAD4,
KN_E_PGDN = VK_NUMPAD3,
KN_E_PGUP = VK_NUMPAD9,
KN_E_RIGHT = VK_NUMPAD6,
KN_E_UP = VK_NUMPAD8,
KN_F = VK_F,
KN_F1 = VK_F1,
KN_F10 = 67,
KN_F11 = 68,
KN_F12 = 69,
KN_F2 = 59,
KN_F3 = 60,
KN_F4 = 61,
KN_F5 = 62,
KN_F6 = 63,
KN_F7 = 64,
KN_F8 = 65,
KN_F9 = 66,
KN_G = VK_G,
KN_GRAVE = VK_NONE_C0,
KN_H = VK_H,
KN_HOME = VK_HOME,
KN_I = VK_I,
KN_INSERT = VK_INSERT,
KN_J = VK_J,
KN_K = VK_K,
KN_KEYPAD_ASTERISK= VK_MULTIPLY,
KN_KEYPAD_MINUS = VK_SUBTRACT,
KN_KEYPAD_PLUS = VK_ADD,
KN_KEYPAD_RETURN = VK_RETURN,
KN_KEYPAD_SLASH = VK_DIVIDE,
KN_L = VK_L,
KN_LALT = VK_MENU,
KN_LBRACKET = VK_NONE_DB,
KN_LCTRL = VK_CONTROL,
KN_LEFT = VK_LEFT,
KN_LMOUSE = VK_LBUTTON,
KN_LSHIFT = VK_SHIFT,
KN_M = VK_M,
KN_MINUS = VK_NONE_BD,
KN_N = VK_N,
KN_NUMLOCK = VK_NUMLOCK,
KN_O = VK_O,
KN_P = VK_P,
KN_PAUSE = VK_PAUSE,
KN_PERIOD = VK_NONE_BE,
KN_PGDN = VK_NEXT,
KN_PGUP = VK_PRIOR,
KN_PRNTSCRN = VK_PRINT,
KN_Q = VK_Q,
KN_R = VK_R,
KN_RALT = VK_MENU,
KN_RBRACKET = VK_NONE_DD,
KN_RCTRL = VK_CONTROL,
KN_RETURN = VK_RETURN,
KN_RIGHT = VK_RIGHT,
KN_RMOUSE = VK_RBUTTON,
KN_RSHIFT = VK_SHIFT,
KN_S = VK_S,
KN_SCROLLLOCK = VK_SCROLL,
KN_SEMICOLON = VK_NONE_BA,
KN_SLASH = VK_NONE_BF,
KN_SPACE = VK_SPACE,
KN_SQUOTE = VK_NONE_DE,
KN_T = VK_T,
KN_TAB = VK_TAB,
KN_U = VK_U,
KN_UP = VK_UP,
KN_UPLEFT = VK_HOME,
KN_UPRIGHT = VK_PRIOR,
KN_V = VK_V,
KN_W = VK_W,
KN_X = VK_X,
KN_Y = VK_Y,
KN_Z = VK_Z,
KN_SHIFT_BIT = WWKEY_SHIFT_BIT,
KN_CTRL_BIT = WWKEY_CTRL_BIT,
KN_ALT_BIT = WWKEY_ALT_BIT,
KN_RLSE_BIT = WWKEY_RLS_BIT,
KN_BUTTON = WWKEY_BTN_BIT,
KN_CAPSLOCK_BIT = WWKEY_SHIFT_BIT,
} KeyNumType;
code/redalert/options.cpp
+1 -2
View File
@@ -591,7 +591,6 @@ void OptionsClass::Load_Settings(void)
SlowPalette = ini.Get_Bool(OPTIONS, "SlowPalette", SlowPalette);
IsPaletteScroll = ini.Get_Bool(OPTIONS, "PaletteScroll", IsPaletteScroll);
/*
KeyForceMove1 = (KeyNumType)ini.Get_Int(HotkeyName, "KeyForceMove1", KeyForceMove1);
KeyForceMove2 = (KeyNumType)ini.Get_Int(HotkeyName, "KeyForceMove2", KeyForceMove2);
KeyForceAttack1 = (KeyNumType)ini.Get_Int(HotkeyName, "KeyForceAttack1", KeyForceAttack1);
@@ -642,6 +641,7 @@ void OptionsClass::Load_Settings(void)
KeyTeam9 = (KeyNumType)ini.Get_Int(HotkeyName, "KeyTeam9", KeyTeam9);
KeyTeam10 = (KeyNumType)ini.Get_Int(HotkeyName, "KeyTeam10", KeyTeam10);
#ifdef WIN32
KeyForceMove1 = (KeyNumType)(KeyForceMove1 & ~WWKEY_VK_BIT);
KeyForceMove2 = (KeyNumType)(KeyForceMove2 & ~WWKEY_VK_BIT);
@@ -693,7 +693,6 @@ void OptionsClass::Load_Settings(void)
KeyTeam9 = (KeyNumType)(KeyTeam9 & ~WWKEY_VK_BIT);
KeyTeam10 = (KeyNumType)(KeyTeam10 & ~WWKEY_VK_BIT);
#endif
*/
}
code/redalert/power.cpp
+11 -20
View File
@@ -169,7 +169,6 @@ void PowerClass::Draw_It(bool complete)
// jmarshall - render the world before the power bar.
RadarClass::Draw_It(complete);
// jmarshall end
{
BStart(BENCH_POWER);
@@ -191,13 +190,13 @@ void PowerClass::Draw_It(bool complete)
int bottomOfBar = (88 * RESFACTOR) + 56;
while (bottomOfBar < PowerButton.Height + 42)
while(bottomOfBar < PowerButton.Height + 34 )
{
CC_Draw_Shape(PowerBarShape, 1, ScreenWidth - (640 - (240 * RESFACTOR)), bottomOfBar, WINDOW_MAIN, flags | SHAPE_NORMAL | SHAPE_WIN_REL, remap);
bottomOfBar += 8 * RESFACTOR;
}
int bottom = bottomOfBar + (28 * RESFACTOR);
int bottom = ( PowerButton.Y * RESFACTOR ) + PowerButton.Height;
/*
** Determine how much the power production exceeds or falls short
@@ -208,6 +207,8 @@ void PowerClass::Draw_It(bool complete)
power_height = Bound(power_height, 0, PowerButton.Height - 2);
drain_height = Bound(drain_height, 0, PowerButton.Height - 2);
bottom -= (15 * RESFACTOR);
/*
** Draw the power output graphic on top of the power bar framework.
*/
@@ -243,11 +244,8 @@ void PowerClass::Draw_It(bool complete)
/*
** Draw the power drain threshold marker.
*/
if (PlayerPtr->Drain > 0)
{
CC_Draw_Shape(PowerShape, 0, ScreenWidth - (640 - (((POWER_X * RESFACTOR)) +RESFACTOR)), bottom - (drain_height + (2 * RESFACTOR)), WINDOW_MAIN, flags | SHAPE_NORMAL, remap);
}
}
LogicPage->Unlock();
}
BEnd(BENCH_POWER);
@@ -289,11 +287,9 @@ void PowerClass::AI(KeyNumType& input, int x, int y)
PowerBounce = 12;
if (PowerHeight > DesiredPowerHeight) {
PowerDir = -1;
}
else if (PowerHeight < DesiredPowerHeight) {
} else if (PowerHeight < DesiredPowerHeight) {
PowerDir = 1;
}
else {
} else {
PowerBounce = 0;
}
}
@@ -308,11 +304,9 @@ void PowerClass::AI(KeyNumType& input, int x, int y)
DrainBounce = 12;
if (DrainHeight > DesiredDrainHeight) {
DrainDir = -1;
}
else if (DrainHeight < DesiredDrainHeight) {
} else if (DrainHeight < DesiredDrainHeight) {
DrainDir = 1;
}
else {
} else {
DrainBounce = 0;
}
}
@@ -321,8 +315,7 @@ void PowerClass::AI(KeyNumType& input, int x, int y)
IsToRedraw = true;
Flag_To_Redraw(false);
DrainBounce--;
}
else {
} else {
/*
** If we need to move the drain height then do so.
*/
@@ -335,8 +328,7 @@ void PowerClass::AI(KeyNumType& input, int x, int y)
IsToRedraw = true;
Flag_To_Redraw(false);
PowerBounce--;
}
else {
} else {
/*
** If we need to move the power height then do so.
*/
@@ -460,8 +452,7 @@ int PowerClass::PowerButtonClass::Action(unsigned flags, KeyNumType& key)
Map.Override_Mouse_Shape(MOUSE_NORMAL);
if (PlayerPtr->Power_Fraction() < 1 && PlayerPtr->Power > 0) {
Map.Help_Text(TXT_POWER_OUTPUT_LOW, -1, -1, GadgetClass::Get_Color_Scheme()->Color);
}
else {
} else {
Map.Help_Text(TXT_POWER_OUTPUT, -1, -1, GadgetClass::Get_Color_Scheme()->Color);
}
GadgetClass::Action(flags, key);
code/redalert/shapebtn.cpp
-1
View File
@@ -164,7 +164,6 @@ int ShapeButtonClass::Draw_Me(int forced)
}
CC_Draw_Shape(ShapeData, shapenum, X, Y, WINDOW_MAIN, SHAPE_NORMAL);
/*
** Display the mouse.
*/
code/redalert/sidebar.cpp
+63 -88
View File
@@ -332,8 +332,7 @@ void SidebarClass::Init_IO(void)
if ((IsRadarActive && Is_Zoomable()) || Session.Type != GAME_NORMAL) {
Zoom.Enable();
}
else {
} else {
Zoom.Disable();
}
Column[0].Init_IO(0);
@@ -773,16 +772,19 @@ void SidebarClass::Draw_It(bool complete)
*/
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);
// @@ this one repeats
CC_Draw_Shape(SidebarMiddleShape, shape, SIDE_X * RESFACTOR, (8+80)*RESFACTOR, WINDOW_MAIN, SHAPE_WIN_REL);
CC_Draw_Shape(SidebarBottomShape, shape, SIDE_X * RESFACTOR, ScreenHeight - (80 * RESFACTOR) + 3, WINDOW_MAIN, SHAPE_WIN_REL);
CC_Draw_Shape(SidebarBottomShape, shape, SIDE_X * RESFACTOR, ScreenHeight - ( 80*RESFACTOR ), WINDOW_MAIN, SHAPE_WIN_REL);
Repair.Draw_Me(true);
Upgrade.Draw_Me(true);
Zoom.Draw_Me(true);
LogicPage->Unlock();
}
}
@@ -800,6 +802,7 @@ void SidebarClass::Draw_It(bool complete)
Zoom.Draw_Me(true);
}
}
//IsToRedraw = false;
BEnd(BENCH_SIDEBAR);
}
@@ -891,8 +894,7 @@ void SidebarClass::AI(KeyNumType& input, int x, int y)
*/
if (PlayerPtr->BScan) {
Activate_Repair(true);
}
else {
} else {
Activate_Repair(false);
}
@@ -1046,8 +1048,7 @@ bool SidebarClass::Activate(int control)
Add_A_Button(Map.RadarButton);
Map.PowerButton.Zap();
Add_A_Button(Map.PowerButton);
}
else {
} else {
Help_Text(TXT_NONE);
Set_View_Dimensions(0, 0);
Remove_A_Button(Repair);
@@ -1225,16 +1226,29 @@ void SidebarClass::StripClass::Init_IO(int id)
UpButton[ID].ID = BUTTON_UP+id;
UpButton[ID].X = X + (UP_X_OFFSET * RESFACTOR);
UpButton[ID].Y = HEIGHT - ( ( OBJECT_HEIGHT + 7 ) * 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 = HEIGHT - ( (OBJECT_HEIGHT + 7 ) * RESFACTOR );
DownButton[ID].Set_Shape(MFCD::Retrieve("STRIPDN.SHP"));
UpButton[ID].Y += 3;
DownButton[ID].Y += 3;
/*
** 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 < MaxButtonsVisible; index++) {
SelectClass & g = SelectButton[ID][index];
@@ -1444,8 +1458,7 @@ bool SidebarClass::StripClass::Scroll(bool up)
if (up) {
if (!TopIndex) return(false);
Scroller--;
}
else {
} else {
if ( TopIndex+ MaxButtonsVisible >= BuildableCount ) return(false);
Scroller++;
}
@@ -1525,8 +1538,7 @@ bool SidebarClass::StripClass::AI(KeyNumType& input, int, int)
if (!IsScrolling && Scroller) {
if (BuildableCount <= MaxButtonsVisible ) {
Scroller = 0;
}
else {
} else {
/*
** Top of list is moving toward lower ordered entries in the object list. It looks like
@@ -1536,8 +1548,7 @@ bool SidebarClass::StripClass::AI(KeyNumType& input, int, int)
if (Scroller < 0) {
if (!TopIndex) {
Scroller = 0;
}
else {
} else {
Scroller++;
IsScrollingDown = false;
IsScrolling = true;
@@ -1545,12 +1556,10 @@ bool SidebarClass::StripClass::AI(KeyNumType& input, int, int)
Slid = 0;
}
}
else {
} else {
if (TopIndex + MaxButtonsVisible >= BuildableCount) {
Scroller = 0;
}
else {
} else {
Scroller--;
Slid = OBJECT_HEIGHT;
IsScrollingDown = true;
@@ -1571,8 +1580,7 @@ bool SidebarClass::StripClass::AI(KeyNumType& input, int, int)
Slid = 0;
TopIndex++;
}
}
else {
} else {
Slid += SCROLL_RATE;
if (Slid >= OBJECT_HEIGHT) {
IsScrolling = false;
@@ -1772,8 +1780,7 @@ void SidebarClass::StripClass::Draw_It(bool complete)
completed = factory->Has_Completed();
stage = factory->Completion();
darken = false;
}
else {
} else {
production = false;
// darken = IsBuilding;
@@ -1783,13 +1790,11 @@ void SidebarClass::StripClass::Draw_It(bool complete)
*/
darken = isbusy;
}
}
else {
} else {
darken = PlayerPtr->Is_Hack_Prevented(Buildables[index].BuildableType, Buildables[index].BuildableID);
}
}
else {
} else {
spc = SpecialWeaponType(Buildables[index].BuildableID);
shapefile = Get_Special_Cameo(spc);
@@ -1810,22 +1815,19 @@ void SidebarClass::StripClass::Draw_It(bool complete)
remapper = Map.FadingLight;
}
}
else {
} else {
shapefile = LogoShapes;
if (!darken) {
shapenum = SB_BLANK;
}
}
}
else {
} 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.
@@ -1868,8 +1870,7 @@ void SidebarClass::StripClass::Draw_It(bool complete)
(x-(WindowList[WINDOW_SIDEBAR][WINDOWX]))+(LEFT_EDGE_OFFSET+15) * RESFACTOR,
(y-WindowList[WINDOW_SIDEBAR][WINDOWY])+(4 * RESFACTOR),
WINDOW_SIDEBAR, SHAPE_CENTER);
}
else {
} else {
CC_Draw_Shape(ClockShapes, stage+1,
x-(WindowList[WINDOW_SIDEBAR][WINDOWX])+(LEFT_EDGE_OFFSET * RESFACTOR),
@@ -1934,12 +1935,10 @@ bool SidebarClass::StripClass::Recalc(void)
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 {
} else {
if ((unsigned)Buildables[index].BuildableID < SPC_COUNT) {
ok = PlayerPtr->SuperWeapon[Buildables[index].BuildableID].Is_Present();
}
else {
} else {
ok = false;
}
}
@@ -2069,8 +2068,7 @@ int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType& ke
if (index < Strip->BuildableCount) {
if (otype != RTTI_SPECIAL) {
choice = Fetch_Techno_Type(otype, oid);
}
else {
} else {
spc = SpecialWeaponType(oid);
}
@@ -2078,8 +2076,7 @@ int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType& ke
factory = Factories.Raw_Ptr(fnumber);
}
}
else {
} else {
Map.Help_Text(TXT_NONE);
}
@@ -2112,19 +2109,16 @@ int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType& ke
Map.IsTargettingMode = spc;
Unselect_All();
Speak(VOX_SELECT_TARGET);
}
else {
} else {
OutList.Add(EventClass(EventClass::SPECIAL_PLACE, SPC_SONAR_PULSE, 0));
}
}
else {
} else {
PlayerPtr->SuperWeapon[spc].Impatient_Click();
}
}
}
}
else {
} else {
if (choice != NULL) {
@@ -2164,8 +2158,7 @@ int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType& ke
if (!factory->Is_Building()) {
Speak(VOX_CANCELED);
OutList.Add(EventClass(EventClass::ABANDON, otype, oid));
}
else {
} else {
Speak(VOX_SUSPENDED);
OutList.Add(EventClass(EventClass::SUSPEND, otype, oid));
Map.Column[0].IsToRedraw = true;
@@ -2195,8 +2188,7 @@ int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType& ke
*/
if (factory->Is_Building()) {
Speak(VOX_NO_FACTORY);
}
else {
} else {
/*
** If production has completed, then attempt to have the object exit
@@ -2207,14 +2199,12 @@ int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType& ke
TechnoClass * pending = factory->Get_Object();
if (!pending && factory->Get_Special_Item()) {
Map.IsTargettingMode = SPC_ANY;
}
else {
} else {
BuildingClass * builder = pending->Who_Can_Build_Me(false, false);
if (!builder) {
OutList.Add(EventClass(EventClass::ABANDON, otype, oid));
Speak(VOX_NO_FACTORY);
}
else {
} else {
/*
** If the completed object is a building, then change the
@@ -2224,8 +2214,7 @@ int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType& ke
*/
if (pending->What_Am_I() == RTTI_BUILDING) {
PlayerPtr->Manual_Place(builder, (BuildingClass *)pending);
}
else {
} else {
/*
** For objects that can leave the factory under their own
@@ -2236,21 +2225,18 @@ int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType& ke
}
}
}
}
else {
} else {
if (PlayerPtr->Is_Hack_Prevented(otype, oid)) {
// Eva scolds the player here.
}
else {
} else {
/*
** The factory must have been in a suspended state. Resume construction
** normally.
*/
if (otype == RTTI_INFANTRYTYPE) {
Speak(VOX_TRAINING);
}
else {
} else {
Speak(VOX_BUILDING);
}
OutList.Add(EventClass(EventClass::PRODUCE, Strip->Buildables[index].BuildableType, Strip->Buildables[index].BuildableID));
@@ -2258,13 +2244,11 @@ int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType& ke
}
}
}
else {
} else {
if (PlayerPtr->Is_Hack_Prevented(otype, oid)) {
// Eva scolds the player here.
}
else {
} else {
/*
** If this side strip is already busy with production, then ignore the
@@ -2272,16 +2256,14 @@ int SidebarClass::StripClass::SelectClass::Action(unsigned flags, KeyNumType& ke
*/
if (otype == RTTI_INFANTRYTYPE) {
Speak(VOX_TRAINING);
}
else {
} else {
Speak(VOX_BUILDING);
}
OutList.Add(EventClass(EventClass::PRODUCE, Strip->Buildables[index].BuildableType, Strip->Buildables[index].BuildableID));
}
}
}
}
else {
} else {
flags = 0;
}
}
@@ -2405,8 +2387,7 @@ bool SidebarClass::StripClass::Abandon_Production(int factory)
Factories.Raw_Ptr(factory)->Abandon();
Buildables[index].Factory = -1;
abandon = true;
}
else {
} else {
if (Buildables[index].Factory != -1) {
noprod = false;
}
@@ -2460,20 +2441,17 @@ void SidebarClass::Zoom_Mode_Control(void)
if (Is_Zoomed() || !Spy_Next_House()) {
Zoom_Mode(Coord_Cell(TacticalCoord));
}
}
else {
} else {
if (!Spying_On_House() && !Is_Player_Names()) {
Player_Names(1);
}
else {
} else {
Player_Names(0);
if (!Spy_Next_House()) {
Zoom_Mode(Coord_Cell(TacticalCoord));
}
}
}
}
else {
} else {
if (Session.Type!=GAME_NORMAL) {
Player_Names(Is_Player_Names()==0);
}
@@ -2490,20 +2468,17 @@ void SidebarClass::Zoom_Mode_Control(void)
if (!Spy_Next_House()) {
Zoom_Mode(Coord_Cell(TacticalCoord));
}
}
else {
} else {
if (!Spying_On_House() && !Is_Player_Names()) {
Player_Names(1);
}
else {
} else {
Player_Names(0);
if (!Spy_Next_House()) {
Zoom_Mode(Coord_Cell(TacticalCoord));
}
}
}
}
else {
} else {
if (Session.Type!=GAME_NORMAL) {
Player_Names(Is_Player_Names()==0);
}