888 lines
30 KiB
C++
888 lines
30 KiB
C++
/* 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/>.
|
|
*
|
|
*/
|
|
|
|
#include "common/std/algorithm.h"
|
|
#include "ags/engine/ac/draw.h"
|
|
#include "ags/shared/ac/game_version.h"
|
|
#include "ags/engine/ac/game_state.h"
|
|
#include "ags/shared/ac/game_setup_struct.h"
|
|
#include "ags/engine/ac/timer.h"
|
|
#include "ags/engine/ac/dynobj/script_camera.h"
|
|
#include "ags/engine/ac/dynobj/script_system.h"
|
|
#include "ags/engine/ac/dynobj/script_viewport.h"
|
|
#include "ags/engine/ac/dynobj/dynobj_manager.h"
|
|
#include "ags/engine/debugging/debug_log.h"
|
|
#include "ags/engine/device/mouse_w32.h"
|
|
#include "ags/shared/game/custom_properties.h"
|
|
#include "ags/shared/game/room_struct.h"
|
|
#include "ags/engine/game/savegame_internal.h"
|
|
#include "ags/engine/main/engine.h"
|
|
#include "ags/engine/media/audio/audio_system.h"
|
|
#include "ags/shared/util/string_utils.h"
|
|
#include "ags/globals.h"
|
|
|
|
namespace AGS3 {
|
|
|
|
using namespace AGS::Shared;
|
|
using namespace AGS::Engine;
|
|
|
|
GameState::GameState() {
|
|
}
|
|
|
|
bool GameState::IsAutoRoomViewport() const {
|
|
return _isAutoRoomViewport;
|
|
}
|
|
|
|
void GameState::SetAutoRoomViewport(bool on) {
|
|
_isAutoRoomViewport = on;
|
|
}
|
|
|
|
void GameState::SetMainViewport(const Rect &viewport) {
|
|
_mainViewport = viewport;
|
|
_GP(mouse).UpdateGraphicArea();
|
|
_GP(scsystem).viewport_width = game_to_data_coord(_mainViewport.GetWidth());
|
|
_GP(scsystem).viewport_height = game_to_data_coord(_mainViewport.GetHeight());
|
|
_mainViewportHasChanged = true;
|
|
}
|
|
|
|
const Rect &GameState::GetMainViewport() const {
|
|
return _mainViewport;
|
|
}
|
|
|
|
const Rect &GameState::GetUIViewport() const {
|
|
return _uiViewport;
|
|
}
|
|
|
|
SpriteTransform GameState::GetGlobalTransform(bool full_frame_rend) const {
|
|
// NOTE: shake_screen is not applied to the sprite batches,
|
|
// but only as a final render factor (optimization)
|
|
// TODO: also add global flip to the same transform, instead of passing separately?
|
|
return SpriteTransform(_mainViewport.Left, _mainViewport.Top +
|
|
shake_screen_yoff * static_cast<int>(full_frame_rend));
|
|
}
|
|
|
|
PViewport GameState::GetRoomViewport(int index) const {
|
|
return _roomViewports[index];
|
|
}
|
|
|
|
const std::vector<PViewport> &GameState::GetRoomViewportsZOrdered() const {
|
|
return _roomViewportsSorted;
|
|
}
|
|
|
|
PViewport GameState::GetRoomViewportAt(int x, int y) const {
|
|
// We iterate backwards, because in AGS low z-order means bottom
|
|
for (auto it = _roomViewportsSorted.rbegin(); it != _roomViewportsSorted.rend(); ++it)
|
|
if ((*it)->IsVisible() && (*it)->GetRect().IsInside(x, y))
|
|
return *it;
|
|
return nullptr;
|
|
}
|
|
|
|
Rect GameState::GetRoomViewportAbs(int index) const {
|
|
return Rect::MoveBy(_roomViewports[index]->GetRect(), _mainViewport.Left, _mainViewport.Top);
|
|
}
|
|
|
|
void GameState::SetUIViewport(const Rect &viewport) {
|
|
_uiViewport = viewport;
|
|
}
|
|
|
|
static bool ViewportZOrder(const PViewport e1, const PViewport e2) {
|
|
return e1->GetZOrder() < e2->GetZOrder();
|
|
}
|
|
|
|
void GameState::UpdateViewports() {
|
|
if (_mainViewportHasChanged) {
|
|
on_mainviewport_changed();
|
|
_mainViewportHasChanged = false;
|
|
}
|
|
if (_roomViewportZOrderChanged) {
|
|
auto old_sort = _roomViewportsSorted;
|
|
_roomViewportsSorted = _roomViewports;
|
|
std::sort(_roomViewportsSorted.begin(), _roomViewportsSorted.end(), ViewportZOrder);
|
|
for (size_t i = 0; i < _roomViewportsSorted.size(); ++i) {
|
|
if (i >= old_sort.size() || _roomViewportsSorted[i] != old_sort[i])
|
|
_roomViewportsSorted[i]->SetChangedVisible();
|
|
}
|
|
_roomViewportZOrderChanged = false;
|
|
}
|
|
size_t vp_changed = SIZE_MAX;
|
|
for (size_t i = _roomViewportsSorted.size(); i-- > 0;) {
|
|
auto vp = _roomViewportsSorted[i];
|
|
if (vp->HasChangedSize() || vp->HasChangedPosition() || vp->HasChangedVisible()) {
|
|
vp_changed = i;
|
|
on_roomviewport_changed(vp.get());
|
|
vp->ClearChangedFlags();
|
|
}
|
|
}
|
|
if (vp_changed != SIZE_MAX)
|
|
detect_roomviewport_overlaps(vp_changed);
|
|
for (auto cam : _roomCameras) {
|
|
if (cam->HasChangedSize() || cam->HasChangedPosition()) {
|
|
on_roomcamera_changed(cam.get());
|
|
cam->ClearChangedFlags();
|
|
}
|
|
}
|
|
}
|
|
|
|
void GameState::InvalidateViewportZOrder() {
|
|
_roomViewportZOrderChanged = true;
|
|
}
|
|
|
|
PCamera GameState::GetRoomCamera(int index) const {
|
|
return _roomCameras[index];
|
|
}
|
|
|
|
void GameState::UpdateRoomCameras() {
|
|
for (size_t i = 0; i < _roomCameras.size(); ++i)
|
|
UpdateRoomCamera(i);
|
|
}
|
|
|
|
void GameState::UpdateRoomCamera(int index) {
|
|
auto cam = _roomCameras[index];
|
|
const Rect &rc = cam->GetRect();
|
|
const Size real_room_sz = Size(data_to_game_coord(_GP(thisroom).Width), data_to_game_coord(_GP(thisroom).Height));
|
|
if ((real_room_sz.Width > rc.GetWidth()) || (real_room_sz.Height > rc.GetHeight())) {
|
|
// TODO: split out into Camera Behavior
|
|
if (!cam->IsLocked()) {
|
|
int x = data_to_game_coord(_G(playerchar)->x) - rc.GetWidth() / 2;
|
|
int y = data_to_game_coord(_G(playerchar)->y) - rc.GetHeight() / 2;
|
|
cam->SetAt(x, y);
|
|
}
|
|
}
|
|
}
|
|
|
|
Point GameState::RoomToScreen(int roomx, int roomy) {
|
|
return _roomViewports[0]->RoomToScreen(roomx, roomy, false).first;
|
|
}
|
|
|
|
int GameState::RoomToScreenX(int roomx) {
|
|
return _roomViewports[0]->RoomToScreen(roomx, 0, false).first.X;
|
|
}
|
|
|
|
int GameState::RoomToScreenY(int roomy) {
|
|
return _roomViewports[0]->RoomToScreen(0, roomy, false).first.Y;
|
|
}
|
|
|
|
VpPoint GameState::ScreenToRoomImpl(int scrx, int scry, int view_index, bool clip_viewport, bool convert_cam_to_data) {
|
|
PViewport view;
|
|
if (view_index < 0) {
|
|
view = GetRoomViewportAt(scrx, scry);
|
|
if (!view) {
|
|
if (clip_viewport)
|
|
return std::make_pair(Point(), -1);
|
|
view = _roomViewports[0]; // use primary viewport
|
|
}
|
|
} else {
|
|
view = _roomViewports[view_index];
|
|
}
|
|
return view->ScreenToRoom(scrx, scry, clip_viewport, convert_cam_to_data);
|
|
}
|
|
|
|
VpPoint GameState::ScreenToRoom(int scrx, int scry, bool restrict) {
|
|
if (_GP(game).options[OPT_BASESCRIPTAPI] >= kScriptAPI_v3507)
|
|
return ScreenToRoomImpl(scrx, scry, -1, restrict, false);
|
|
return ScreenToRoomImpl(scrx, scry, 0, false, false);
|
|
}
|
|
|
|
VpPoint GameState::ScreenToRoomDivDown(int scrx, int scry) {
|
|
if (_GP(game).options[OPT_BASESCRIPTAPI] >= kScriptAPI_v3507)
|
|
return ScreenToRoomImpl(scrx, scry, -1, true, true);
|
|
return ScreenToRoomImpl(scrx, scry, 0, false, true);
|
|
}
|
|
|
|
void GameState::CreatePrimaryViewportAndCamera() {
|
|
if (_roomViewports.size() == 0) {
|
|
_GP(play).CreateRoomViewport();
|
|
_GP(play).RegisterRoomViewport(0);
|
|
}
|
|
if (_roomCameras.size() == 0) {
|
|
_GP(play).CreateRoomCamera();
|
|
_GP(play).RegisterRoomCamera(0);
|
|
}
|
|
_roomViewports[0]->LinkCamera(_roomCameras[0]);
|
|
_roomCameras[0]->LinkToViewport(_roomViewports[0]);
|
|
}
|
|
|
|
PViewport GameState::CreateRoomViewport() {
|
|
int index = (int)_roomViewports.size();
|
|
PViewport viewport(new Viewport());
|
|
viewport->SetID(index);
|
|
viewport->SetRect(_mainViewport);
|
|
_roomViewports.push_back(viewport);
|
|
_scViewportHandles.push_back(0);
|
|
_roomViewportsSorted.push_back(viewport);
|
|
_roomViewportZOrderChanged = true;
|
|
on_roomviewport_created(index);
|
|
return viewport;
|
|
}
|
|
|
|
ScriptViewport *GameState::RegisterRoomViewport(int index, int32_t handle) {
|
|
if (index < 0 || (size_t)index >= _roomViewports.size())
|
|
return nullptr;
|
|
auto scview = new ScriptViewport(index);
|
|
if (handle == 0) {
|
|
handle = ccRegisterManagedObject(scview, scview);
|
|
ccAddObjectReference(handle); // one reference for the GameState
|
|
} else {
|
|
ccRegisterUnserializedObject(handle, scview, scview);
|
|
}
|
|
_scViewportHandles[index] = handle; // save handle for us
|
|
return scview;
|
|
}
|
|
|
|
void GameState::DeleteRoomViewport(int index) {
|
|
if (index < 0 || (size_t)index >= _roomViewports.size())
|
|
return;
|
|
auto handle = _scViewportHandles[index];
|
|
auto scobj = const_cast<ScriptViewport*>((const ScriptViewport*)ccGetObjectAddressFromHandle(handle));
|
|
if (scobj) {
|
|
scobj->Invalidate();
|
|
ccReleaseObjectReference(handle);
|
|
}
|
|
auto cam = _roomViewports[index]->GetCamera();
|
|
if (cam)
|
|
cam->UnlinkFromViewport(index);
|
|
_roomViewports.erase(_roomViewports.begin() + index);
|
|
_scViewportHandles.erase(_scViewportHandles.begin() + index);
|
|
for (size_t i = index; i < _roomViewports.size(); ++i) {
|
|
_roomViewports[i]->SetID(i);
|
|
handle = _scViewportHandles[index];
|
|
scobj = const_cast<ScriptViewport*>((const ScriptViewport*)ccGetObjectAddressFromHandle(handle));
|
|
if (scobj)
|
|
scobj->SetID(i);
|
|
}
|
|
for (size_t i = 0; i < _roomViewportsSorted.size(); ++i) {
|
|
if (_roomViewportsSorted[i]->GetID() == index) {
|
|
_roomViewportsSorted.erase(_roomViewportsSorted.begin() + i);
|
|
break;
|
|
}
|
|
}
|
|
on_roomviewport_deleted(index);
|
|
}
|
|
|
|
int GameState::GetRoomViewportCount() const {
|
|
return (int)_roomViewports.size();
|
|
}
|
|
|
|
PCamera GameState::CreateRoomCamera() {
|
|
int index = (int)_roomCameras.size();
|
|
PCamera camera(new Camera());
|
|
camera->SetID(index);
|
|
camera->SetAt(0, 0);
|
|
camera->SetSize(_mainViewport.GetSize());
|
|
_scCameraHandles.push_back(0);
|
|
_roomCameras.push_back(camera);
|
|
return camera;
|
|
}
|
|
|
|
ScriptCamera *GameState::RegisterRoomCamera(int index, int32_t handle) {
|
|
if (index < 0 || (size_t)index >= _roomCameras.size())
|
|
return nullptr;
|
|
auto sccamera = new ScriptCamera(index);
|
|
if (handle == 0) {
|
|
handle = ccRegisterManagedObject(sccamera, sccamera);
|
|
ccAddObjectReference(handle); // one reference for the GameState
|
|
} else {
|
|
ccRegisterUnserializedObject(handle, sccamera, sccamera);
|
|
}
|
|
_scCameraHandles[index] = handle;
|
|
return sccamera;
|
|
}
|
|
|
|
void GameState::DeleteRoomCamera(int index) {
|
|
if (index < 0 || (size_t)index >= _roomCameras.size())
|
|
return;
|
|
auto handle = _scCameraHandles[index];
|
|
auto scobj = const_cast<ScriptCamera*>((const ScriptCamera*)ccGetObjectAddressFromHandle(handle));
|
|
if (scobj) {
|
|
scobj->Invalidate();
|
|
ccReleaseObjectReference(handle);
|
|
}
|
|
for (auto &viewref : _roomCameras[index]->GetLinkedViewports()) {
|
|
auto view = viewref.lock();
|
|
if (view)
|
|
view->LinkCamera(nullptr);
|
|
}
|
|
_roomCameras.erase(_roomCameras.begin() + index);
|
|
_scCameraHandles.erase(_scCameraHandles.begin() + index);
|
|
for (size_t i = index; i < _roomCameras.size(); ++i) {
|
|
_roomCameras[i]->SetID(i);
|
|
handle = _scCameraHandles[index];
|
|
scobj = const_cast<ScriptCamera*>((const ScriptCamera*)ccGetObjectAddressFromHandle(handle));
|
|
if (scobj)
|
|
scobj->SetID(i);
|
|
}
|
|
}
|
|
|
|
int GameState::GetRoomCameraCount() const {
|
|
return (int)_roomCameras.size();
|
|
}
|
|
|
|
ScriptViewport *GameState::GetScriptViewport(int index) {
|
|
if (index < 0 || (size_t)index >= _roomViewports.size())
|
|
return nullptr;
|
|
return const_cast<ScriptViewport*>((const ScriptViewport*)ccGetObjectAddressFromHandle(_scViewportHandles[index]));
|
|
}
|
|
|
|
ScriptCamera *GameState::GetScriptCamera(int index) {
|
|
if (index < 0 || (size_t)index >= _roomCameras.size())
|
|
return nullptr;
|
|
return const_cast<ScriptCamera*>((const ScriptCamera*)ccGetObjectAddressFromHandle(_scCameraHandles[index]));
|
|
}
|
|
|
|
bool GameState::IsIgnoringInput() const {
|
|
return AGS_Clock::now() < _ignoreUserInputUntilTime;
|
|
}
|
|
|
|
void GameState::SetIgnoreInput(int timeout_ms) {
|
|
if (AGS_Clock::now() + std::chrono::milliseconds(timeout_ms) > _ignoreUserInputUntilTime)
|
|
_ignoreUserInputUntilTime = AGS_Clock::now() + std::chrono::milliseconds(timeout_ms);
|
|
}
|
|
|
|
void GameState::ClearIgnoreInput() {
|
|
_ignoreUserInputUntilTime = AGS_Clock::now();
|
|
}
|
|
|
|
void GameState::SetWaitSkipResult(int how, int data) {
|
|
wait_counter = 0;
|
|
wait_skipped_by = how;
|
|
wait_skipped_by_data = data;
|
|
}
|
|
|
|
int GameState::GetWaitSkipResult() const {
|
|
// NOTE: we remove timer flag to make timeout reason = 0
|
|
return ((wait_skipped_by & ~SKIP_AUTOTIMER) << SKIP_RESULT_TYPE_SHIFT)
|
|
| (wait_skipped_by_data & SKIP_RESULT_DATA_MASK);
|
|
}
|
|
|
|
bool GameState::IsBlockingVoiceSpeech() const {
|
|
return speech_has_voice && speech_voice_blocking;
|
|
}
|
|
|
|
bool GameState::IsNonBlockingVoiceSpeech() const {
|
|
return speech_has_voice && !speech_voice_blocking;
|
|
}
|
|
|
|
bool GameState::ShouldPlayVoiceSpeech() const {
|
|
return !_GP(play).fast_forward &&
|
|
(_GP(play).speech_mode != kSpeech_TextOnly) && (_GP(play).voice_avail);
|
|
}
|
|
|
|
void GameState::ReadFromSavegame(Stream *in, GameDataVersion data_ver, GameStateSvgVersion svg_ver, RestoredData &r_data) {
|
|
const bool old_save = svg_ver < kGSSvgVersion_Initial;
|
|
const bool extended_old_save = old_save && (data_ver >= kGameVersion_340_4);
|
|
const bool do_align_pad = old_save;
|
|
|
|
score = in->ReadInt32();
|
|
usedmode = in->ReadInt32();
|
|
disabled_user_interface = in->ReadInt32();
|
|
gscript_timer = in->ReadInt32();
|
|
debug_mode = in->ReadInt32();
|
|
in->ReadArrayOfInt32(globalvars, MAXGLOBALVARS);
|
|
messagetime = in->ReadInt32();
|
|
usedinv = in->ReadInt32();
|
|
inv_top = in->ReadInt32();
|
|
inv_numdisp = in->ReadInt32();
|
|
inv_numorder = in->ReadInt32();
|
|
inv_numinline = in->ReadInt32();
|
|
text_speed = in->ReadInt32();
|
|
sierra_inv_color = in->ReadInt32();
|
|
talkanim_speed = in->ReadInt32();
|
|
inv_item_wid = in->ReadInt32();
|
|
inv_item_hit = in->ReadInt32();
|
|
speech_text_shadow = in->ReadInt32();
|
|
swap_portrait_side = in->ReadInt32();
|
|
speech_textwindow_gui = in->ReadInt32();
|
|
follow_change_room_timer = in->ReadInt32();
|
|
totalscore = in->ReadInt32();
|
|
skip_display = in->ReadInt32();
|
|
no_multiloop_repeat = in->ReadInt32();
|
|
roomscript_finished = in->ReadInt32();
|
|
used_inv_on = in->ReadInt32();
|
|
no_textbg_when_voice = in->ReadInt32();
|
|
max_dialogoption_width = in->ReadInt32();
|
|
no_hicolor_fadein = in->ReadInt32();
|
|
bgspeech_game_speed = in->ReadInt32();
|
|
bgspeech_stay_on_display = in->ReadInt32();
|
|
unfactor_speech_from_textlength = in->ReadInt32();
|
|
mp3_loop_before_end = in->ReadInt32();
|
|
speech_music_drop = in->ReadInt32();
|
|
in_cutscene = in->ReadInt32();
|
|
fast_forward = in->ReadInt32();
|
|
room_width = in->ReadInt32();
|
|
room_height = in->ReadInt32();
|
|
game_speed_modifier = in->ReadInt32();
|
|
score_sound = in->ReadInt32();
|
|
takeover_data = in->ReadInt32();
|
|
replay_hotkey_unused = in->ReadInt32();
|
|
dialog_options_x = in->ReadInt32();
|
|
dialog_options_y = in->ReadInt32();
|
|
narrator_speech = in->ReadInt32();
|
|
ambient_sounds_persist = in->ReadInt32();
|
|
lipsync_speed = in->ReadInt32();
|
|
close_mouth_speech_time = in->ReadInt32();
|
|
disable_antialiasing = in->ReadInt32();
|
|
text_speed_modifier = in->ReadInt32();
|
|
if (svg_ver < kGSSvgVersion_350)
|
|
text_align = ConvertLegacyScriptAlignment((LegacyScriptAlignment)in->ReadInt32());
|
|
else
|
|
text_align = (HorAlignment)in->ReadInt32();
|
|
speech_bubble_width = in->ReadInt32();
|
|
min_dialogoption_width = in->ReadInt32();
|
|
disable_dialog_parser = in->ReadInt32();
|
|
anim_background_speed = in->ReadInt32(); // the setting for this room
|
|
top_bar_backcolor = in->ReadInt32();
|
|
top_bar_textcolor = in->ReadInt32();
|
|
top_bar_bordercolor = in->ReadInt32();
|
|
top_bar_borderwidth = in->ReadInt32();
|
|
top_bar_ypos = in->ReadInt32();
|
|
screenshot_width = in->ReadInt32();
|
|
screenshot_height = in->ReadInt32();
|
|
top_bar_font = in->ReadInt32();
|
|
if (svg_ver < kGSSvgVersion_350)
|
|
speech_text_align = ConvertLegacyScriptAlignment((LegacyScriptAlignment)in->ReadInt32());
|
|
else
|
|
speech_text_align = (HorAlignment)in->ReadInt32();
|
|
auto_use_walkto_points = in->ReadInt32();
|
|
inventory_greys_out = in->ReadInt32();
|
|
skip_speech_specific_key = in->ReadInt32();
|
|
abort_key = in->ReadInt32();
|
|
fade_to_red = in->ReadInt32();
|
|
fade_to_green = in->ReadInt32();
|
|
fade_to_blue = in->ReadInt32();
|
|
show_single_dialog_option = in->ReadInt32();
|
|
keep_screen_during_instant_transition = in->ReadInt32();
|
|
read_dialog_option_colour = in->ReadInt32();
|
|
stop_dialog_at_end = in->ReadInt32();
|
|
speech_portrait_placement = in->ReadInt32();
|
|
speech_portrait_x = in->ReadInt32();
|
|
speech_portrait_y = in->ReadInt32();
|
|
speech_display_post_time_ms = in->ReadInt32();
|
|
dialog_options_highlight_color = in->ReadInt32();
|
|
if (old_save)
|
|
in->ReadArrayOfInt32(reserved, GAME_STATE_RESERVED_INTS);
|
|
// ** up to here is referenced in the script "game." object
|
|
if (old_save) {
|
|
in->ReadInt32(); // recording
|
|
in->ReadInt32(); // playback
|
|
in->ReadInt16(); // gamestep
|
|
in->ReadInt16(); // alignment padding to int32
|
|
}
|
|
randseed = in->ReadInt32(); // random seed
|
|
player_on_region = in->ReadInt32(); // player's current region
|
|
if (old_save)
|
|
in->ReadInt32(); // screen_is_faded_out
|
|
check_interaction_only = in->ReadInt32();
|
|
bg_frame = in->ReadInt32();
|
|
bg_anim_delay = in->ReadInt32(); // for animating backgrounds
|
|
music_vol_was = in->ReadInt32(); // before the volume drop
|
|
wait_counter = in->ReadInt16();
|
|
mboundx1 = in->ReadInt16();
|
|
mboundx2 = in->ReadInt16();
|
|
mboundy1 = in->ReadInt16();
|
|
mboundy2 = in->ReadInt16();
|
|
if (do_align_pad)
|
|
in->ReadInt16(); // alignment padding to int32
|
|
fade_effect = in->ReadInt32();
|
|
bg_frame_locked = in->ReadInt32();
|
|
in->ReadArrayOfInt32(globalscriptvars, MAXGSVALUES);
|
|
cur_music_number = in->ReadInt32();
|
|
music_repeat = in->ReadInt32();
|
|
music_master_volume = in->ReadInt32();
|
|
digital_master_volume = in->ReadInt32();
|
|
in->Read(walkable_areas_on, MAX_WALK_AREAS);
|
|
screen_flipped = in->ReadInt16();
|
|
if (svg_ver < kGSSvgVersion_350_10) {
|
|
short offsets_locked = in->ReadInt16();
|
|
if (offsets_locked != 0)
|
|
r_data.Camera0_Flags = kSvgCamPosLocked;
|
|
}
|
|
entered_at_x = in->ReadInt32();
|
|
entered_at_y = in->ReadInt32();
|
|
entered_edge = in->ReadInt32();
|
|
speech_mode = (SpeechMode)in->ReadInt32();
|
|
speech_skip_style = in->ReadInt32();
|
|
in->ReadArrayOfInt32(script_timers, MAX_TIMERS);
|
|
sound_volume = in->ReadInt32();
|
|
speech_volume = in->ReadInt32();
|
|
normal_font = in->ReadInt32();
|
|
speech_font = in->ReadInt32();
|
|
key_skip_wait = in->ReadInt8();
|
|
if (do_align_pad)
|
|
in->Seek(3); // alignment padding to int32
|
|
swap_portrait_lastchar = in->ReadInt32();
|
|
separate_music_lib = in->ReadInt32() != 0;
|
|
in_conversation = in->ReadInt32();
|
|
screen_tint = in->ReadInt32();
|
|
num_parsed_words = in->ReadInt32();
|
|
in->ReadArrayOfInt16(parsed_words, MAX_PARSED_WORDS);
|
|
in->Read(bad_parsed_word, 100);
|
|
if (do_align_pad)
|
|
in->ReadInt16(); // alignment padding to int32 (15 int16 + 100 int8 = 65 int16 -> 66)
|
|
raw_color = in->ReadInt32();
|
|
if (old_save)
|
|
in->ReadArrayOfInt32(raw_modified, MAX_ROOM_BGFRAMES);
|
|
in->ReadArrayOfInt16(filenumbers, MAXSAVEGAMES);
|
|
if (old_save)
|
|
in->ReadInt32(); // room_changes
|
|
mouse_cursor_hidden = in->ReadInt32();
|
|
silent_midi = in->ReadInt32();
|
|
silent_midi_channel = in->ReadInt32();
|
|
current_music_repeating = in->ReadInt32();
|
|
shakesc_delay = in->ReadInt32();
|
|
shakesc_amount = in->ReadInt32();
|
|
shakesc_length = in->ReadInt32();
|
|
rtint_red = in->ReadInt32();
|
|
rtint_green = in->ReadInt32();
|
|
rtint_blue = in->ReadInt32();
|
|
rtint_level = in->ReadInt32();
|
|
rtint_light = in->ReadInt32();
|
|
if (!old_save || extended_old_save) {
|
|
rtint_enabled = in->ReadBool();
|
|
if (do_align_pad)
|
|
in->Seek(3); // alignment padding to int32
|
|
} else {
|
|
rtint_enabled = rtint_level > 0;
|
|
}
|
|
end_cutscene_music = in->ReadInt32();
|
|
skip_until_char_stops = in->ReadInt32();
|
|
get_loc_name_last_time = in->ReadInt32();
|
|
get_loc_name_save_cursor = in->ReadInt32();
|
|
restore_cursor_mode_to = in->ReadInt32();
|
|
restore_cursor_image_to = in->ReadInt32();
|
|
music_queue_size = in->ReadInt16();
|
|
in->ReadArrayOfInt16(music_queue, MAX_QUEUED_MUSIC);
|
|
new_music_queue_size = in->ReadInt16();
|
|
if (!old_save) {
|
|
for (int i = 0; i < MAX_QUEUED_MUSIC; ++i) {
|
|
new_music_queue[i].ReadFromSavegame(in);
|
|
}
|
|
}
|
|
|
|
crossfading_out_channel = in->ReadInt16();
|
|
crossfade_step = in->ReadInt16();
|
|
crossfade_out_volume_per_step = in->ReadInt16();
|
|
crossfade_initial_volume_out = in->ReadInt16();
|
|
crossfading_in_channel = in->ReadInt16();
|
|
crossfade_in_volume_per_step = in->ReadInt16();
|
|
crossfade_final_volume_in = in->ReadInt16();
|
|
|
|
if (old_save) {
|
|
in->ReadInt16(); // alignment padding to int32 (before array of structs)
|
|
for (int i = 0; i < MAX_QUEUED_MUSIC; ++i) {
|
|
new_music_queue[i].ReadFromSavegame_v321(in);
|
|
}
|
|
}
|
|
|
|
in->Read(takeover_from, 50);
|
|
playmp3file_name.ReadCount(in, PLAYMP3FILE_MAX_FILENAME_LEN);
|
|
in->Read(globalstrings, MAXGLOBALSTRINGS * MAX_MAXSTRLEN);
|
|
in->Read(lastParserEntry, MAX_MAXSTRLEN);
|
|
if (svg_ver < kGSSvgVersion_361_14)
|
|
game_name.ReadCount(in, LEGACY_GAMESTATE_GAMENAMELENGTH);
|
|
else
|
|
game_name = StrUtil::ReadString(in);
|
|
ground_level_areas_disabled = in->ReadInt32();
|
|
next_screen_transition = in->ReadInt32();
|
|
in->ReadInt32(); // gamma_adjustment -- do not apply gamma level from savegame
|
|
temporarily_turned_off_character = in->ReadInt16();
|
|
inv_backwards_compatibility = in->ReadInt16();
|
|
if (old_save) {
|
|
in->ReadInt32(); // gui_draw_order
|
|
in->ReadInt32(); // do_once_tokens;
|
|
}
|
|
r_data.DoOnceCount = static_cast<uint32_t>(in->ReadInt32());
|
|
if (!old_save) {
|
|
for (size_t i = 0; i < r_data.DoOnceCount; ++i) {
|
|
do_once_tokens.insert(StrUtil::ReadString(in));
|
|
}
|
|
}
|
|
text_min_display_time_ms = in->ReadInt32();
|
|
ignore_user_input_after_text_timeout_ms = in->ReadInt32();
|
|
if (svg_ver < kGSSvgVersion_350_9)
|
|
in->ReadInt32(); // ignore_user_input_until_time -- do not apply from savegame
|
|
if (old_save)
|
|
in->ReadArrayOfInt32(default_audio_type_volumes, MAX_AUDIO_TYPES);
|
|
if (svg_ver >= kGSSvgVersion_350_9) {
|
|
int voice_speech_flags = in->ReadInt32();
|
|
speech_has_voice = voice_speech_flags != 0;
|
|
speech_voice_blocking = (voice_speech_flags & 0x02) != 0;
|
|
}
|
|
}
|
|
|
|
void GameState::WriteForSavegame(Stream *out) const {
|
|
// NOTE: following parameters are never saved:
|
|
// recording, playback, gamestep, screen_is_faded_out, room_changes
|
|
out->WriteInt32(score);
|
|
out->WriteInt32(usedmode);
|
|
out->WriteInt32(disabled_user_interface);
|
|
out->WriteInt32(gscript_timer);
|
|
out->WriteInt32(debug_mode);
|
|
out->WriteArrayOfInt32(globalvars, MAXGLOBALVARS);
|
|
out->WriteInt32(messagetime);
|
|
out->WriteInt32(usedinv);
|
|
out->WriteInt32(inv_top);
|
|
out->WriteInt32(inv_numdisp);
|
|
out->WriteInt32(inv_numorder);
|
|
out->WriteInt32(inv_numinline);
|
|
out->WriteInt32(text_speed);
|
|
out->WriteInt32(sierra_inv_color);
|
|
out->WriteInt32(talkanim_speed);
|
|
out->WriteInt32(inv_item_wid);
|
|
out->WriteInt32(inv_item_hit);
|
|
out->WriteInt32(speech_text_shadow);
|
|
out->WriteInt32(swap_portrait_side);
|
|
out->WriteInt32(speech_textwindow_gui);
|
|
out->WriteInt32(follow_change_room_timer);
|
|
out->WriteInt32(totalscore);
|
|
out->WriteInt32(skip_display);
|
|
out->WriteInt32(no_multiloop_repeat);
|
|
out->WriteInt32(roomscript_finished);
|
|
out->WriteInt32(used_inv_on);
|
|
out->WriteInt32(no_textbg_when_voice);
|
|
out->WriteInt32(max_dialogoption_width);
|
|
out->WriteInt32(no_hicolor_fadein);
|
|
out->WriteInt32(bgspeech_game_speed);
|
|
out->WriteInt32(bgspeech_stay_on_display);
|
|
out->WriteInt32(unfactor_speech_from_textlength);
|
|
out->WriteInt32(mp3_loop_before_end);
|
|
out->WriteInt32(speech_music_drop);
|
|
out->WriteInt32(in_cutscene);
|
|
out->WriteInt32(fast_forward);
|
|
out->WriteInt32(room_width);
|
|
out->WriteInt32(room_height);
|
|
out->WriteInt32(game_speed_modifier);
|
|
out->WriteInt32(score_sound);
|
|
out->WriteInt32(takeover_data);
|
|
out->WriteInt32(replay_hotkey_unused); // StartRecording: not supported
|
|
out->WriteInt32(dialog_options_x);
|
|
out->WriteInt32(dialog_options_y);
|
|
out->WriteInt32(narrator_speech);
|
|
out->WriteInt32(ambient_sounds_persist);
|
|
out->WriteInt32(lipsync_speed);
|
|
out->WriteInt32(close_mouth_speech_time);
|
|
out->WriteInt32(disable_antialiasing);
|
|
out->WriteInt32(text_speed_modifier);
|
|
out->WriteInt32(text_align);
|
|
out->WriteInt32(speech_bubble_width);
|
|
out->WriteInt32(min_dialogoption_width);
|
|
out->WriteInt32(disable_dialog_parser);
|
|
out->WriteInt32(anim_background_speed); // the setting for this room
|
|
out->WriteInt32(top_bar_backcolor);
|
|
out->WriteInt32(top_bar_textcolor);
|
|
out->WriteInt32(top_bar_bordercolor);
|
|
out->WriteInt32(top_bar_borderwidth);
|
|
out->WriteInt32(top_bar_ypos);
|
|
out->WriteInt32(screenshot_width);
|
|
out->WriteInt32(screenshot_height);
|
|
out->WriteInt32(top_bar_font);
|
|
out->WriteInt32(speech_text_align);
|
|
out->WriteInt32(auto_use_walkto_points);
|
|
out->WriteInt32(inventory_greys_out);
|
|
out->WriteInt32(skip_speech_specific_key);
|
|
out->WriteInt32(abort_key);
|
|
out->WriteInt32(fade_to_red);
|
|
out->WriteInt32(fade_to_green);
|
|
out->WriteInt32(fade_to_blue);
|
|
out->WriteInt32(show_single_dialog_option);
|
|
out->WriteInt32(keep_screen_during_instant_transition);
|
|
out->WriteInt32(read_dialog_option_colour);
|
|
out->WriteInt32(stop_dialog_at_end);
|
|
out->WriteInt32(speech_portrait_placement);
|
|
out->WriteInt32(speech_portrait_x);
|
|
out->WriteInt32(speech_portrait_y);
|
|
out->WriteInt32(speech_display_post_time_ms);
|
|
out->WriteInt32(dialog_options_highlight_color);
|
|
// ** up to here is referenced in the script "game." object
|
|
out->WriteInt32(randseed); // random seed
|
|
out->WriteInt32(player_on_region); // player's current region
|
|
out->WriteInt32(check_interaction_only);
|
|
out->WriteInt32(bg_frame);
|
|
out->WriteInt32(bg_anim_delay); // for animating backgrounds
|
|
out->WriteInt32(music_vol_was); // before the volume drop
|
|
out->WriteInt16(wait_counter);
|
|
out->WriteInt16(mboundx1);
|
|
out->WriteInt16(mboundx2);
|
|
out->WriteInt16(mboundy1);
|
|
out->WriteInt16(mboundy2);
|
|
out->WriteInt32(fade_effect);
|
|
out->WriteInt32(bg_frame_locked);
|
|
out->WriteArrayOfInt32(globalscriptvars, MAXGSVALUES);
|
|
out->WriteInt32(cur_music_number);
|
|
out->WriteInt32(music_repeat);
|
|
out->WriteInt32(music_master_volume);
|
|
out->WriteInt32(digital_master_volume);
|
|
out->Write(walkable_areas_on, MAX_WALK_AREAS);
|
|
out->WriteInt16(screen_flipped);
|
|
out->WriteInt32(entered_at_x);
|
|
out->WriteInt32(entered_at_y);
|
|
out->WriteInt32(entered_edge);
|
|
out->WriteInt32(speech_mode);
|
|
out->WriteInt32(speech_skip_style);
|
|
out->WriteArrayOfInt32(script_timers, MAX_TIMERS);
|
|
out->WriteInt32(sound_volume);
|
|
out->WriteInt32(speech_volume);
|
|
out->WriteInt32(normal_font);
|
|
out->WriteInt32(speech_font);
|
|
out->WriteInt8(key_skip_wait);
|
|
out->WriteInt32(swap_portrait_lastchar);
|
|
out->WriteInt32(separate_music_lib ? 1 : 0);
|
|
out->WriteInt32(in_conversation);
|
|
out->WriteInt32(screen_tint);
|
|
out->WriteInt32(num_parsed_words);
|
|
out->WriteArrayOfInt16(parsed_words, MAX_PARSED_WORDS);
|
|
out->Write(bad_parsed_word, 100);
|
|
out->WriteInt32(raw_color);
|
|
out->WriteArrayOfInt16(filenumbers, MAXSAVEGAMES);
|
|
out->WriteInt32(mouse_cursor_hidden);
|
|
out->WriteInt32(silent_midi);
|
|
out->WriteInt32(silent_midi_channel);
|
|
out->WriteInt32(current_music_repeating);
|
|
out->WriteInt32(shakesc_delay);
|
|
out->WriteInt32(shakesc_amount);
|
|
out->WriteInt32(shakesc_length);
|
|
out->WriteInt32(rtint_red);
|
|
out->WriteInt32(rtint_green);
|
|
out->WriteInt32(rtint_blue);
|
|
out->WriteInt32(rtint_level);
|
|
out->WriteInt32(rtint_light);
|
|
out->WriteBool(rtint_enabled);
|
|
out->WriteInt32(end_cutscene_music);
|
|
out->WriteInt32(skip_until_char_stops);
|
|
out->WriteInt32(get_loc_name_last_time);
|
|
out->WriteInt32(get_loc_name_save_cursor);
|
|
out->WriteInt32(restore_cursor_mode_to);
|
|
out->WriteInt32(restore_cursor_image_to);
|
|
out->WriteInt16(music_queue_size);
|
|
out->WriteArrayOfInt16(music_queue, MAX_QUEUED_MUSIC);
|
|
out->WriteInt16(new_music_queue_size);
|
|
for (int i = 0; i < MAX_QUEUED_MUSIC; ++i) {
|
|
new_music_queue[i].WriteToSavegame(out);
|
|
}
|
|
|
|
out->WriteInt16(crossfading_out_channel);
|
|
out->WriteInt16(crossfade_step);
|
|
out->WriteInt16(crossfade_out_volume_per_step);
|
|
out->WriteInt16(crossfade_initial_volume_out);
|
|
out->WriteInt16(crossfading_in_channel);
|
|
out->WriteInt16(crossfade_in_volume_per_step);
|
|
out->WriteInt16(crossfade_final_volume_in);
|
|
|
|
out->Write(takeover_from, 50);
|
|
playmp3file_name.WriteCount(out, PLAYMP3FILE_MAX_FILENAME_LEN);
|
|
out->Write(globalstrings, MAXGLOBALSTRINGS * MAX_MAXSTRLEN);
|
|
out->Write(lastParserEntry, MAX_MAXSTRLEN);
|
|
StrUtil::WriteString(game_name, out);
|
|
out->WriteInt32(ground_level_areas_disabled);
|
|
out->WriteInt32(next_screen_transition);
|
|
out->WriteInt32(gamma_adjustment);
|
|
out->WriteInt16(temporarily_turned_off_character);
|
|
out->WriteInt16(inv_backwards_compatibility);
|
|
out->WriteInt32(static_cast<uint32_t>(do_once_tokens.size()));
|
|
for (const auto &token : do_once_tokens) {
|
|
StrUtil::WriteString(token, out);
|
|
}
|
|
out->WriteInt32(text_min_display_time_ms);
|
|
out->WriteInt32(ignore_user_input_after_text_timeout_ms);
|
|
|
|
int voice_speech_flags = speech_has_voice ? 0x01 : 0;
|
|
if (speech_voice_blocking)
|
|
voice_speech_flags |= 0x02;
|
|
out->WriteInt32(voice_speech_flags);
|
|
}
|
|
|
|
void GameState::FreeProperties() {
|
|
for (auto &p : charProps)
|
|
p.clear();
|
|
for (auto &p : invProps)
|
|
p.clear();
|
|
}
|
|
|
|
void GameState::FreeViewportsAndCameras() {
|
|
_roomViewports.clear();
|
|
_roomViewportsSorted.clear();
|
|
for (auto handle : _scViewportHandles) {
|
|
auto scview = const_cast<ScriptViewport*>((const ScriptViewport*)ccGetObjectAddressFromHandle(handle));
|
|
if (scview) {
|
|
scview->Invalidate();
|
|
ccReleaseObjectReference(handle);
|
|
}
|
|
}
|
|
_scViewportHandles.clear();
|
|
_roomCameras.clear();
|
|
for (auto handle : _scCameraHandles) {
|
|
auto sccam = const_cast<ScriptCamera*>((const ScriptCamera*)ccGetObjectAddressFromHandle(handle));
|
|
if (sccam) {
|
|
sccam->Invalidate();
|
|
ccReleaseObjectReference(handle);
|
|
}
|
|
}
|
|
_scCameraHandles.clear();
|
|
}
|
|
|
|
void GameState::ReadCustomProperties_v340(Stream *in, GameDataVersion data_ver) {
|
|
if (data_ver >= kGameVersion_340_4) {
|
|
// After runtime property values were read we also copy missing default,
|
|
// because we do not keep defaults in the saved game, and also in case
|
|
// this save is made by an older game version which had different
|
|
// properties.
|
|
for (int i = 0; i < _GP(game).numcharacters; ++i)
|
|
Properties::ReadValues(charProps[i], in);
|
|
for (int i = 0; i < _GP(game).numinvitems; ++i)
|
|
Properties::ReadValues(invProps[i], in);
|
|
}
|
|
}
|
|
|
|
void GameState::WriteCustomProperties_v340(Stream *out, GameDataVersion data_ver) const {
|
|
if (data_ver >= kGameVersion_340_4) {
|
|
// We temporarily remove properties that kept default values
|
|
// just for the saving data time to avoid getting lots of
|
|
// redundant data into saved games
|
|
for (int i = 0; i < _GP(game).numcharacters; ++i)
|
|
Properties::WriteValues(charProps[i], out);
|
|
for (int i = 0; i < _GP(game).numinvitems; ++i)
|
|
Properties::WriteValues(invProps[i], out);
|
|
}
|
|
}
|
|
|
|
// Converts legacy alignment type used in script API
|
|
HorAlignment ConvertLegacyScriptAlignment(LegacyScriptAlignment align) {
|
|
switch (align) {
|
|
case kLegacyScAlignLeft:
|
|
return kHAlignLeft;
|
|
case kLegacyScAlignCentre:
|
|
return kHAlignCenter;
|
|
case kLegacyScAlignRight:
|
|
return kHAlignRight;
|
|
}
|
|
return kHAlignNone;
|
|
}
|
|
|
|
// Reads legacy alignment type from the value set in script depending on the
|
|
// current Script API level. This is made to make it possible to change
|
|
// Alignment constants in the Script API and still support old version.
|
|
HorAlignment ReadScriptAlignment(int32_t align) {
|
|
return _GP(game).options[OPT_BASESCRIPTAPI] < kScriptAPI_v350 ?
|
|
ConvertLegacyScriptAlignment((LegacyScriptAlignment)align) :
|
|
(HorAlignment)align;
|
|
}
|
|
|
|
} // namespace AGS3
|