globals.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef AGS_GLOBALS_H
#define AGS_GLOBALS_H
 
#include "ags/shared/core/platform.h"
#define AGS_PLATFORM_DEFINES_PSP_VARS (AGS_PLATFORM_OS_IOS || AGS_PLATFORM_OS_ANDROID)
 
#include "common/std/queue.h"
#include "ags/shared/ac/game_version.h"
#include "ags/shared/ac/keycode.h"
#include "ags/shared/util/stdio_compat.h"
#include "ags/shared/util/string.h"
#include "ags/shared/util/string_types.h"
#include "ags/shared/util/version.h"
#include "ags/shared/font/wfn_font.h"
#include "ags/shared/gui/gui_main.h"
#include "ags/shared/script/cc_script.h"
#include "ags/engine/ac/dynobj/script_game.h"
#include "ags/engine/ac/dynobj/script_user_object.h"
#include "ags/engine/ac/event.h"
#include "ags/engine/ac/file.h"
#include "ags/engine/ac/runtime_defines.h"
#include "ags/engine/ac/walk_behind.h"
#include "ags/engine/main/engine.h"
#include "ags/engine/main/graphics_mode.h"
#include "ags/engine/media/audio/audio_defines.h"
#include "ags/engine/script/script.h"
#include "ags/engine/script/script_runtime.h"
#include "common/std/array.h"
#include "common/std/chrono.h"
#include "common/std/memory.h"
#include "common/std/set.h"
#include "ags/lib/allegro/color.h"
#include "ags/lib/allegro/fixed.h"
#include "ags/lib/allegro/aintern.h"
#include "common/events.h"
 
namespace Common {
class DumpFile;
}
 
namespace AGS3 {
 
#define MAXCURSORS 20
 
using String = AGS::Shared::String;
using Version = AGS::Shared::Version;
 
namespace AGS {
namespace Shared {
 
class AssetManager;
class Bitmap;
class DebugManager;
struct Font;
class GUIButton;
class GUIInvWindow;
class GUILabel;
class GUIListBox;
class GUISlider;
class GUITextBox;
struct InteractionVariable;
struct PlaneScaling;
class RoomStruct;
class SpriteCache;
struct Translation;
 
} // namespace Shared
 
namespace Engine {
 
class ConsoleOutputTarget;
struct GfxFilterInfo;
class IDriverDependantBitmap;
class IGfxDriverFactory;
class IGraphicsDriver;
class LogFile;
class MessageBuffer;
 
} // namespace Engine
} // namespace AGS
 
namespace Plugins {
namespace Core {
class EngineExports;
} // namespace Core
} // namespace Plugins
 
class IRouteFinder;
class Navigation;
class SplitLines;
class TTFFontRenderer;
class WFNFontRenderer;
 
struct AGSCCStaticObject;
struct AGSDeSerializer;
struct AGSPlatformDriver;
struct AmbientSound;
struct AnimatingGUIButton;
struct CachedActSpsData;
struct CCAudioChannel;
struct CCAudioClip;
struct CCCharacter;
struct CCDialog;
struct CCDynamicArray;
struct CCGUI;
struct CCGUIObject;
struct CCHotspot;
struct ccInstance;
struct CCInventory;
struct CCObject;
struct CCRegion;
struct CharacterCache;
struct CharacterExtras;
struct CharacterInfo;
struct color;
struct COLOR_MAP;
struct CSCIMessage;
struct DialogTopic;
struct DirtyRects;
struct EnginePlugin;
struct ExecutingScript;
struct EventHappened;
struct GameSetup;
struct GameSetupStruct;
struct GameState;
struct IAGSEditorDebugger;
struct ICCStringClass;
struct ManagedObjectPool;
struct Mouse;
struct MoveList;
struct NewControl;
struct NonBlockingScriptFunction;
struct ObjectCache;
struct OnScreenWindow;
struct PluginObjectReader;
struct Point;
struct ResourcePaths;
struct RGB_MAP;
struct RoomCameraDrawData;
struct RoomObject;
struct RoomStatus;
struct RuntimeScriptValue;
struct ScreenOverlay;
struct ScriptAudioChannel;
struct ScriptDialog;
struct ScriptDialogOptionsRendering;
struct ScriptDrawingSurface;
struct ScriptError;
struct ScriptGUI;
struct ScriptHotspot;
struct ScriptInvItem;
struct ScriptMouse;
struct ScriptObject;
struct ScriptPosition;
struct ScriptRegion;
struct ScriptString;
struct ScriptSystem;
struct SOUNDCLIP;
struct SpeechLipSyncLine;
struct SpriteListEntry;
struct StaticArray;
struct CCStaticArray;
struct StaticGame;
struct SystemImports;
struct TopBarSettings;
struct ViewStruct;
 
class Globals {
public:
    enum SimdFlags : uint {
        SIMD_NONE = 0,
        SIMD_NEON = (1 << 0),
        SIMD_SSE2 = (1 << 1),
        SIMD_AVX2 = (1 << 2),
    };
 
    int _errnum = 0;
    int *_allegro_errno = &_errnum;
 
    int __color_depth = 0;
    int __rgb_r_shift_15 = DEFAULT_RGB_R_SHIFT_15;     /* truecolor pixel format */
    int __rgb_g_shift_15 = DEFAULT_RGB_G_SHIFT_15;
    int __rgb_b_shift_15 = DEFAULT_RGB_B_SHIFT_15;
    int __rgb_r_shift_16 = DEFAULT_RGB_R_SHIFT_16;
    int __rgb_g_shift_16 = DEFAULT_RGB_G_SHIFT_16;
    int __rgb_b_shift_16 = DEFAULT_RGB_B_SHIFT_16;
    int __rgb_r_shift_24 = DEFAULT_RGB_R_SHIFT_24;
    int __rgb_g_shift_24 = DEFAULT_RGB_G_SHIFT_24;
    int __rgb_b_shift_24 = DEFAULT_RGB_B_SHIFT_24;
    int __rgb_r_shift_32 = DEFAULT_RGB_R_SHIFT_32;
    int __rgb_g_shift_32 = DEFAULT_RGB_G_SHIFT_32;
    int __rgb_b_shift_32 = DEFAULT_RGB_B_SHIFT_32;
    int __rgb_a_shift_32 = DEFAULT_RGB_A_SHIFT_32;
 
    RGB_MAP *_rgb_map = nullptr;
    COLOR_MAP *_color_map = nullptr;
    int _trans_blend_alpha = 0;
    int _trans_blend_red = 0;
    int _trans_blend_green = 0;
    int _trans_blend_blue = 0;
    BlenderMode __blender_mode = kRgbToRgbBlender;
    uint _simd_flags = SIMD_NONE;
    /* current format information and worker routines */
    int _utype = U_UTF8;
 
    /* default palette structures */
    PALETTE _black_palette;
    PALETTE _current_palette;
    PALETTE _prev_current_palette;
 
    volatile int _mouse_x = 0;  // X position
    volatile int _mouse_y = 0;  // Y position
    volatile int _mouse_z = 0;  // Mouse wheel vertical
    volatile int _mouse_b = 0;  // Mouse buttons bitflags
    volatile int _mouse_pos = 0;    // X position in upper 16 bits, Y in lower 16
 
    // Accumulated absolute and relative mouse device motion.
    // May be retrieved by calling *acquire_absxy and *acquire_relxy functions,
    // after which these are reset, until next motion event is received.
    volatile int _sys_mouse_x = 0; // mouse x position
    volatile int _sys_mouse_y = 0; // mouse y position
    volatile int _sys_mouse_z = 0; // mouse wheel position
 
    volatile int _freeze_mouse_flag = 0;
 
    // Relative x and y deltas
    int _mouse_accum_relx = 0, _mouse_accum_rely = 0;
 
    int _mouse_button_state = 0;
    int _mouse_accum_button_state = 0;
    uint32 _mouse_clear_at_time = 0;
    eAGSMouseButton _wasbutdown = kMouseNone;
    int _wasongui = 0;
 
    std::unique_ptr<Shared::AssetManager> *_AssetMgr;
 
    // We don't have many places where we delay longer than a frame, but where we
    // do, we should give the audio layer a chance to update.
    // 16 milliseconds is rough period for 60fps
    const std::chrono::milliseconds _MaximumDelayBetweenPolling = std::chrono::milliseconds(16);
 
    AGS::Shared::Bitmap *_glVirtualScreenWrap;
    std::vector<PluginObjectReader> *_pluginReaders;
 
    AGSCCStaticObject *_GlobalStaticManager;
    CCScriptGame      *_GameStaticManager;
 
    std::array<SOUNDCLIP *> *_audioChannels;
    std::array<AmbientSound> *_ambient;
 
    ScriptAudioChannel *_scrAudioChannel;
    int _reserved_channel_count = 0;
 
    // This is an indicator of a music played by an old audio system
    // (to distinguish from the new system API)
    int _current_music_type = 0;
    // _G(crossFading) is >0 (channel number of new track), or -1 (old
    // track fading out, no new track)
    int _crossFading = 0, _crossFadeVolumePerStep = 0, _crossFadeStep = 0;
    int _crossFadeVolumeAtStart = 0;
    SOUNDCLIP *_cachedQueuedMusic = nullptr;
 
    // Music update is scheduled when the voice speech stops;
    // we do a small delay before reverting any volume adjustments
    bool _music_update_scheduled = false;
    uint32 _music_update_at = 0;
 
    std::vector<AnimatingGUIButton> *_animbuts;
 
    CCDynamicArray *_globalDynamicArray;
 
    ICCStringClass *_stringClassImpl = nullptr;
 
    ScriptError *_ccError;
 
    // Instance thread stack holds a list of running or suspended script instances;
    // In AGS currently only one thread is running, others are waiting in the queue.
    // An example situation is repeatedly_execute_always callback running while
    // another instance is waiting at the blocking action or Wait().
    std::deque<ccInstance *> *_InstThreads;
    // [IKM] 2012-10-21:
    // NOTE: This is temporary solution (*sigh*, one of many) which allows certain
    // exported functions return value as a RuntimeScriptValue object;
    // Of 2012-12-20: now used only for plugin exports
    RuntimeScriptValue *_GlobalReturnValue;
    Common::DumpFile *_scriptDumpFile = nullptr;
 
    int _ccCompOptions;
 
    // currently executed line
    int _currentline = 0;
    // script file format signature
    const char *_scfilesig = "SCOM";
 
    AGSDeSerializer *_ccUnserializer;
 
    int _use_cdplayer = 0;
    bool _triedToUseCdAudioCommand = false;
    int _need_to_stop_cd = 0;
 
    CharacterInfo *_playerchar = nullptr;
    int32_t _sc_PlayerCharPtr = 0;
    int _char_lowest_yp = 0;
 
    // Sierra-style speech settings
    int _face_talking = -1, _facetalkview = 0, _facetalkwait = 0, _facetalkframe = 0;
    int _facetalkloop = 0, _facetalkrepeat = 0, _facetalkAllowBlink = 1;
    int _facetalkBlinkLoop = 0;
    CharacterInfo *_facetalkchar = nullptr;
    // Do override default portrait position during QFG4-style speech overlay update
    bool _facetalk_qfg4_override_placement_x = false;
    bool _facetalk_qfg4_override_placement_y = false;
 
    // lip-sync speech settings
    int _loops_per_character = 0, _text_lips_offset = 0, _char_speaking = -1;
    int _char_thinking = -1;
    const char *_text_lips_text = nullptr;
    std::vector<SpeechLipSyncLine> *_splipsync;
    int _numLipLines = 0, _curLipLine = -1, _curLipLinePhoneme = 0;
 
    int _windowbackgroundcolor, _pushbuttondarkcolor;
    int _pushbuttonlightcolor;
    int _topwindowhandle = -1;
    int _cbuttfont = 0;
    int _acdialog_font = 0;
    int _smcode = 0;
    int _controlid = 0;
    NewControl **_vobjs;
    OnScreenWindow *_oswi;
 
    int _windowcount = 0, _curswas = 0;
    int _win_x = 0, _win_y = 0, _win_width = 0, _win_height = 0;
 
    int _editor_debugging_enabled = 0;
    int _editor_debugging_initialized = 0;
    char _editor_debugger_instance_token[100];
    IAGSEditorDebugger *_editor_debugger = nullptr;
    int _break_on_next_script_step = 0;
    volatile int _game_paused_in_debugger = 0;
 
    struct Breakpoint {
        char scriptName[80] = { 0 };
        int lineNumber = 0;
    };
 
    std::vector<Breakpoint> _breakpoints;
 
    int _debug_flags = 0;
 
    int _display_fps;
    std::unique_ptr<AGS::Engine::MessageBuffer> *_DebugMsgBuff;
    std::unique_ptr<AGS::Engine::LogFile> *_DebugLogFile;
 
    AGS::Shared::DebugManager *_DbgMgr;
 
    std::vector<DialogTopic> _dialog;
    ScriptDialogOptionsRendering *_ccDialogOptionsRendering;
    ScriptDrawingSurface *_dialogOptionsRenderingSurface = nullptr;
 
    // identifier (username) of the voice pak
    String _VoicePakName;
    // parent part to use when making voice asset names
    String _VoiceAssetPath;
    int _said_speech_line = 0; // used while in dialog to track whether screen needs updating
    int _said_text = 0;
    int _longestline = 0;
    // Old dialog support
    std::vector<std::vector<uint8_t>> _old_dialog_scripts;
    std::vector<String> _old_speech_lines;
 
    int _display_message_aschar = 0;
    int _source_text_length = -1;
 
    TopBarSettings *_topBar;
    struct DisplayVars {
        int lineheight = 0;    // font's height of single line
        int linespacing = 0;   // font's line spacing
        int fulltxtheight = 0; // total height of all the text
    } _disp;
 
    std::vector<RoomCameraDrawData> *_CameraDrawData;
    // Two lists of sprites to push into renderer during next render pass
    // thingsToDrawList - is the main list, unsorted, drawn in the index order
    std::vector<SpriteListEntry> *_thingsToDrawList;
    std::vector<SpriteListEntry> *_sprlist;
 
    AGS::Engine::IGraphicsDriver *_gfxDriver = nullptr;
    AGS::Engine::IDriverDependantBitmap *_blankImage = nullptr;
    AGS::Engine::IDriverDependantBitmap *_blankSidebarImage = nullptr;
 
    // actsps is used for temporary storage of the bitamp and texture
    // of the latest version of the sprite (room objects and characters);
    // objects sprites begin with index 0, characters are after ACTSP_OBJSOFF
    std::vector<ObjTexture> *_actsps;
    // Walk-behind textures (3D renderers only)
    std::vector<ObjTexture> *_walkbehindobj;
    // GUI surfaces
    std::vector<ObjTexture> *_guibg;
    // GUI control surfaces
    std::vector<ObjTexture> *_guiobjbg;
    // first control texture index of each GUI
    std::vector<int> *_guiobjddbref;
    // Overlays textures
    std::vector<ObjTexture> *_overtxs;
    // For debugging room masks
    ObjTexture *_debugRoomMaskObj;
    ObjTexture *_debugMoveListObj;
    RoomAreaMask _debugRoomMask = kRoomAreaNone;
    int _debugMoveListChar = -1;
    // For in-game "console" surface
    AGS::Shared::Bitmap *_debugConsoleBuffer;
    // Whether room bg was modified
    bool _current_background_is_dirty = false;
    // Room background sprite
    AGS::Engine::IDriverDependantBitmap *_roomBackgroundBmp = nullptr;
    // whether there are currently remnants of a DisplaySpeech
    bool _screen_is_dirty = false;
    std::unique_ptr<Shared::Bitmap> _raw_saved_screen;
    std::unique_ptr<Shared::Bitmap> *_dynamicallyCreatedSurfaces;
    color *_palette;
    COLOR_MAP *_maincoltable;
 
    std::vector<Engine::IDriverDependantBitmap *> *_guiobjddb;
    std::vector<Point> *_guiobjoff; // because surface may be larger than logical position
 
    DrawState _drawstate;
    DrawFPS _gl_DrawFPS;
 
    // Dirty rects for the game screen background (black screen);
    // these are used when the room viewport does not cover whole screen,
    // so that we know when to paint black after mouse cursor and gui.
    DirtyRects *_BlackRects;
    Point *_GlobalOffs;
    // Dirty rects object for the single room camera
    std::vector<DirtyRects> *_RoomCamRects;
    // Saved room camera offsets to know if we must invalidate whole surface.
    // TODO: if we support rotation then we also need to compare full transform!
    std::vector<std::pair<int, int> > *_RoomCamPositions;
 
    bool _check_dynamic_sprites_at_exit = true;
 
    ResourcePaths *_ResPaths;
    t_engine_pre_init_callback _engine_pre_init_callback = nullptr;
 
    int _convert_16bit_bgr = 0;
 
    int _in_enters_screen = 0, _done_es_error = 0;
    int _in_leaves_screen = -1;
 
    std::vector<EventHappened> *_events;
 
    int _inside_processevent = 0;
    int _eventClaimed = 0;
 
    const char *_tsnames[kTS_Num] = { nullptr, REP_EXEC_NAME, "on_key_press", "on_mouse_click", "on_text_input" };
 
    // TODO: the asset path configuration should certainly be revamped at some
    // point, with uniform method of configuring auxiliary paths and packages.
    // Installation directory, may contain absolute or relative path
    String _installDirectory;
    // Installation directory, containing audio files
    String _installAudioDirectory;
    // Installation directory, containing voice-over files
    String _installVoiceDirectory;
 
    ScriptFileHandle _valid_handles[MAX_OPEN_SCRIPT_FILES + 1];
    // [IKM] NOTE: this is not precisely the number of files opened at this moment,
    // but rather maximal number of handles that were used simultaneously during game run
    int _num_open_script_files = 0;
 
    std::vector<AGS::Shared::Font> *_fonts;
    TTFFontRenderer *_ttfRenderer;
    WFNFontRenderer *_wfnRenderer;
    SplitLines *_Lines;
    const WFNChar _emptyChar; // a dummy character to substitute bad symbols
    Shared::Bitmap _wputblock_wrapper; // [IKM] argh! :[
 
    GameSetupStruct *_game;
    GameState *_play;
    AGS::Shared::SpriteCache *_spriteset;
    AGS::Shared::RoomStruct *_thisroom;
    RoomStatus *_troom; // used for non-saveable rooms, eg. intro
 
    std::vector<AGS::Shared::GUIMain> *_guis;
    CCGUIObject *_ccDynamicGUIObject;
    CCCharacter *_ccDynamicCharacter;
    CCHotspot *_ccDynamicHotspot;
    CCRegion *_ccDynamicRegion;
    CCInventory *_ccDynamicInv;
    CCGUI *_ccDynamicGUI;
    CCObject *_ccDynamicObject;
    CCDialog *_ccDynamicDialog;
    CCAudioClip *_ccDynamicAudioClip;
    CCAudioChannel *_ccDynamicAudio;
    ScriptObject *_scrObj;
    std::vector<ScriptGUI> *_scrGui;
    ScriptHotspot *_scrHotspot;
    ScriptRegion *_scrRegion;
    ScriptInvItem *_scrInv;
    std::vector<ScriptDialog> *_scrDialog;
 
    std::vector<ViewStruct> *_views;
 
    // Draw cache: keep record of all kinds of things related to the previous drawing state
    // Cached character and object states, used to determine
    // whether these require texture update
    std::vector<ObjectCache> *_charcache;
    ObjectCache *_objcache;
    std::vector<Point> *_overcache;
    std::vector<CharacterExtras> *_charextra;
    // MoveLists for characters and room objects; NOTE: 1-based array!
    // object sprites begin with index 1, characters are after MAX_ROOM_OBJECTS + 1
    std::vector<MoveList> *_mls;
 
    GameSetup *_usetup;
    AGS::Shared::String _saveGameDirectory;
    AGS::Shared::String _saveGameSuffix;
    bool _want_exit = false;
    bool _abort_engine = false;
    AGSPlatformDriver *_platform = nullptr;
 
    RoomObject *_objs = nullptr;
    RoomStatus *_croom = nullptr;
 
    volatile int _switching_away_from_game = 0;
    volatile bool _switched_away = false;
    int _frames_per_second = 40;
    int _displayed_room = -10, _starting_room = -1;
    int _in_new_room = 0, _new_room_was = 0; // 1 in new room, 2 first time in new room, 3 loading saved game
    int _new_room_pos = 0;
    int _new_room_x = SCR_NO_VALUE, _new_room_y = SCR_NO_VALUE;
    int _new_room_loop = SCR_NO_VALUE;
    bool _proper_exit = true;
    int _our_eip = 0;
 
    int _oldmouse = 0;
    // Data format version of the loaded game
    GameDataVersion _loaded_game_file_version = kGameVersion_Undefined;
    // The version of the engine the loaded game was compiled for (if available)
    Version _game_compiled_version;
    int _game_paused = 0;
    unsigned int _load_new_game = 0;
    int _load_new_game_restore = -1;
    // TODO: refactor these global vars into function arguments
    int _getloctype_index = 0, _getloctype_throughgui = 0;
    char _gamefilenamebuf[200] = { 0 };
    int _gameHasBeenRestored = 0;
    int _oldeip = 0;
    int _game_update_suspend = 0;
    bool _new_room_placeonwalkable = false;
 
    CCStaticArray *_StaticCharacterArray;
    CCStaticArray *_StaticObjectArray;
    CCStaticArray *_StaticGUIArray;
    CCStaticArray *_StaticHotspotArray;
    CCStaticArray *_StaticRegionArray;
    CCStaticArray *_StaticInventoryArray;
    CCStaticArray *_StaticDialogArray;
 
     // Following struct instructs the engine to run game loops until
     // certain condition is not fulfilled.
    struct RestrictUntil {
        int type = 0; // type of condition, UNTIL_* constant
        int disabled_for = 0; // FOR_* constant
        // pointer to the test variable
        const void *data_ptr = nullptr;
        // other values used for a test, depend on type
        int data1 = 0;
        int data2 = 0;
    } _restrict_until;
 
    float _fps;
    unsigned int _loopcounter = 0;
    unsigned int _lastcounter = 0;
    int _numEventsAtStartOfFunction = 0;
    uint32 _t1 = 0; // timer for FPS
    int _old_key_shifts = 0; // for saving shift modes
 
    const AGS::Engine::GfxFilterInfo *_aad3dFilterInfo;
 
    const AGS::Engine::GfxFilterInfo *_allegroFilterInfo;
    AGS::Engine::GfxFilterInfo *_scummvmGfxFilter;
 
    const AGS::Engine::GfxFilterInfo *_hqxFilterInfo;
 
    const AGS::Engine::GfxFilterInfo *_d3dFilterInfo;
 
    ScriptPosition *_last_in_dialog_request_script_pos;
 
    ScriptPosition *_last_cutscene_script_pos;
 
    // Used for deciding whether a char or obj was closer
    int _obj_lowest_yp = 0;
 
    AGS::Engine::IGfxDriverFactory *_GfxFactory = nullptr;
 
    // Last saved fullscreen and windowed configs; they are used when switching
    // between between fullscreen and windowed modes at runtime.
    // If particular mode is modified, e.g. by script command, related config should be overwritten.
    ActiveDisplaySetting *_SavedFullscreenSetting;
    ActiveDisplaySetting *_SavedWindowedSetting;
    // Current frame scaling setup
    FrameScaleDef _CurFrameSetup = kFrame_Undefined;
    // The game-to-screen transformation
    AGS::Shared::PlaneScaling *_GameScaling;
 
    int _ifacepopped = -1; // currently displayed pop-up GUI (-1 if none)
    int _mouse_on_iface = -1; // mouse cursor is over this interface
    int _mouse_ifacebut_xoffs = -1, _mouse_ifacebut_yoffs = -1;
    int _eip_guinum = 0, _eip_guiobj = 0;
 
    std::vector<AGS::Shared::GUIButton> *_guibuts;
 
    // TODO: store drawing surface inside old gui classes instead
    int _windowPosX = 0, _windowPosY = 0, _windowPosWidth = 0, _windowPosHeight = 0;
    AGS::Shared::Bitmap *_windowBuffer = nullptr;
    AGS::Engine::IDriverDependantBitmap *_dialogDDB = nullptr;
 
#define MAXSAVEGAMES_20 20
    int _myscrnwid = 320, _myscrnhit = 200;
    char *_lpTemp = nullptr, *_lpTemp2 = nullptr;
    int _numsaves = 0, _toomanygames = 0;
    int _filenumbers[MAXSAVEGAMES_20];
    unsigned long _filedates[MAXSAVEGAMES_20];
    char _bufTemp[260], _buffer2[260];
    char _buff[200];
    CSCIMessage *_smes;
 
    std::vector<AGS::Shared::GUIInvWindow> *_guiinv;
 
    std::vector<AGS::Shared::GUILabel> *_guilabels;
 
    std::vector<AGS::Shared::GUIListBox> *_guilist;
 
    int _guis_need_update = 1;
    AGS::Shared::GuiDisableStyle _all_buttons_disabled = AGS::Shared::kGuiDis_Undefined;
    int _gui_inv_pic = -1;
 
    std::vector<AGS::Shared::GUISlider> *_guislider;
 
    std::vector<AGS::Shared::GUITextBox> *_guitext;
 
    AGS::Shared::InteractionVariable *_globalvars;
    int _numGlobalVars = 1;
 
    int _in_inv_screen = 0, _inv_screen_newroom = -1;
 
    uint8_t *_lzbuffer = nullptr;
    int *_node = nullptr;
    int _pos = 0;
    size_t _outbytes = 0;
 
    String _appPath;
    String _appDirectory; // Needed for library loading
    String _cmdGameDataPath;
 
    // Startup flags, set from parameters to engine
    int _override_start_room = 0;
    bool _justDisplayHelp = false;
    bool _justDisplayVersion = false;
    bool _justRunSetup = false;
    bool _justTellInfo = false;
    std::set<String> _tellInfoKeys;
    int _loadSaveGameOnStartup = -1;
 
    // ScummVM GUIO-controlled flags
    bool _saveThumbnail = true;     // capture a screenshot when saving (used for saves thumbnails)
    bool _noScummAutosave = false;  // disable ScummVM autosaves
    bool _noScummSaveLoad = false;  // disable ScummVM GMM save/load
 
#if 0
    int _psp_rotation = 0;
    int _psp_gfx_renderer = 0;
    int _psp_gfx_scaling = 1;
    int _psp_gfx_smoothing = 0;
    int _psp_gfx_super_sampling = 1;
    int _psp_gfx_smooth_sprites = 0;
#endif
 
    // Current engine version
    Version _EngineVersion;
 
    ManagedObjectPool *_pool;
 
    // virtual mouse cursor coordinates
    int _mousex = 0, _mousey = 0, _numcurso = -1, _hotx = 0, _hoty = 0;
    // real mouse coordinates and bounds (in window coords)
    int _real_mouse_x = 0, _real_mouse_y = 0;
    int _boundx1 = 0, _boundx2 = 99999, _boundy1 = 0, _boundy2 = 99999;
    int _ignore_bounds = 0; // FIXME: this currently works as a counter, not bool?
    AGS::Shared::Bitmap *_mousecurs[MAXCURSORS];
 
    ScriptMouse *_scmouse;
    int _cur_mode = 0, _cur_cursor = 0;
    int _mouse_frame = 0, _mouse_delay = 0;
    int _lastmx = -1, _lastmy = -1;
    int8 _alpha_blend_cursor = 0;
    AGS::Shared::Bitmap *_dotted_mouse_cursor = nullptr;
    AGS::Engine::IDriverDependantBitmap *_mouseCursor = nullptr;
    AGS::Shared::Bitmap *_blank_mouse_cursor = nullptr;
 
    int _butwas = 0;
    int _hotxwas = 0, _hotywas = 0;
    Mouse *_mouse;
 
    std::vector<ScreenOverlay> *_screenover;
    std::queue<int32_t> *_over_free_ids;
    int _is_complete_overlay = 0;
 
    bool _handledErrorInEditor = false;
    char _return_to_roomedit[30] = { '\0' };
    char _return_to_room[150] = { '\0' };
    char _quit_message[256] = { '\0' };
 
    RGB_MAP *_rgb_table;  // for 256-col antialiasing
    int _new_room_flags = 0;
    int _gs_to_newroom = -1;
    int _bg_just_changed = 0;
    std::unique_ptr<RoomStatus> _room_statuses[MAX_ROOMS];
 
    Point *_navpoints;
    Navigation *_nav;
    int _num_navpoints = 0;
    AGS::Shared::Bitmap *_wallscreen = nullptr;
    fixed _move_speed_x, _move_speed_y;
    int _lastcx = 0, _lastcy = 0;
    std::unique_ptr<IRouteFinder> *_route_finder_impl;
 
    // Screenshot made in the last room, used during some of the transition effects
    AGS::Shared::Bitmap *_saved_viewport_bitmap = nullptr;
    color *_old_palette;
 
    ExecutingScript *_scripts;
    ExecutingScript *_curscript = nullptr;
 
    PScript *_gamescript;
    PScript *_dialogScriptsScript;
    UInstance _gameinst;
    UInstance _roominst;
    UInstance _dialogScriptsInst;
    UInstance _gameinstFork;
    UInstance _roominstFork;
 
    int _num_scripts = 0;
    int _post_script_cleanup_stack = 0;
 
    int _inside_script = 0, _in_graph_script = 0;
    int _no_blocking_functions = 0; // set to 1 while in rep_Exec_always
 
    NonBlockingScriptFunction *_repExecAlways;
    NonBlockingScriptFunction *_lateRepExecAlways;
    NonBlockingScriptFunction *_getDialogOptionsDimensionsFunc;
    NonBlockingScriptFunction *_renderDialogOptionsFunc;
    NonBlockingScriptFunction *_getDialogOptionUnderCursorFunc;
    NonBlockingScriptFunction *_runDialogOptionMouseClickHandlerFunc;
    NonBlockingScriptFunction *_runDialogOptionKeyPressHandlerFunc;
    NonBlockingScriptFunction *_runDialogOptionTextInputHandlerFunc;
    NonBlockingScriptFunction *_runDialogOptionRepExecFunc;
    NonBlockingScriptFunction *_runDialogOptionCloseFunc;
 
    ScriptSystem *_scsystem;
 
    std::vector<PScript> *_scriptModules;
    std::vector<UInstance> *_moduleInst;
    std::vector<UInstance> *_moduleInstFork;
    std::vector<RuntimeScriptValue> *_moduleRepExecAddr;
    size_t _numScriptModules = 0;
 
    new_line_hook_type _new_line_hook = nullptr;
    // Minimal timeout: how much time may pass without any engine update
    // before we want to check on the situation and do system poll
    unsigned _timeoutCheckMs = 60u;
    // Critical timeout: how much time may pass without any engine update
    // before we abort or post a warning
    unsigned _timeoutAbortMs = 0u;
    // Maximal while loops without any engine update in between,
    // after which the interpreter will abort
    unsigned _maxWhileLoops = 0u;
    ccInstance *_loadedInstances[MAX_LOADED_INSTANCES];
    ScriptString *_myScriptStringImpl;
    ScriptUserObject _globalDynamicStruct;
 
    SystemImports *_simp;
    SystemImports *_simp_for_plugin;
 
    Plugins::Core::EngineExports *_engineExports;
    Common::Array<EnginePlugin> *_plugins;
    int _pluginsWantingDebugHooks = 0;
    long _pl_file_handle = -1;
    AGS::Shared::Stream *_pl_file_stream = nullptr;
 
    eAGSMouseButton _simulatedClick = kMouseNone;
    int _mouse_z_was = 0;
 
    std::chrono::microseconds _tick_duration = std::chrono::microseconds(1000000LL / 40);
    bool _framerate_maxed = false;
    int _framerate = 0;
 
    uint32 _last_tick_time = 0; // AGS_Clock::now();
    uint32 _next_frame_timestamp = 0; // AGS_Clock::now();
 
    AGS::Shared::Translation *_trans;
    AGS::Shared::StringMap *_transtree = nullptr;
    String _trans_name, _trans_filename;
    long _lang_offs_start = 0;
    char _transFileName[MAX_PATH_SZ] = { 0 };
    std::vector<uint16> _wcsbuf; // widechar buffer
    std::vector<char> _mbbuf;  // utf8 buffer
 
    AGS::Shared::Bitmap *_walkareabackup = nullptr, *_walkable_areas_temp = nullptr;
 
    char *_walkBehindExists = nullptr;  // whether a WB area is in this column
    int *_walkBehindStartY = nullptr, *_walkBehindEndY = nullptr;
    int8 _noWalkBehindsAtAll = 0;
    int _walkBehindLeft[MAX_WALK_BEHINDS], _walkBehindTop[MAX_WALK_BEHINDS];
    int _walkBehindRight[MAX_WALK_BEHINDS], _walkBehindBottom[MAX_WALK_BEHINDS];
    AGS::Engine::IDriverDependantBitmap *_walkBehindBitmap[MAX_WALK_BEHINDS];
    int _walkBehindsCachedForBgNum = -1;
    int _walk_behind_baselines_changed = 0;
    Rect _walkBehindAABB[MAX_WALK_BEHINDS]; // WB bounding box
    std::vector<WalkBehindColumn> _walkBehindCols; // precalculated WB positions
 
    const char *_passwencstring = "Avis Durgan";
 
public:
    Globals();
    ~Globals();
};
 
extern Globals *g_globals;
 
// Macro for accessing a globals member
#define _G(FIELD) (::AGS3::g_globals->_##FIELD)
// Macro for accessing a globals member that was an object in the original,
// but is a pointer to the object in ScummVM, so that we don't need to
// provide the full class/struct definition here in the header file
#define _GP(FIELD) (*::AGS3::g_globals->_##FIELD)
 
} // namespace AGS3
 
#endif