[openjk] 61/130: JO: Fix loading/saving of GHOUL2 and timers
Simon McVittie
smcv at debian.org
Fri Oct 28 11:09:19 UTC 2016
This is an automated email from the git hooks/post-receive script.
smcv pushed a commit to branch debian/master
in repository openjk.
commit 4142bd9460b40822ce610e532cc3910d2cdcfe39
Author: bibendovsky <bibendovsky at hotmail.com>
Date: Sun Jul 31 20:03:59 2016 +0300
JO: Fix loading/saving of GHOUL2 and timers
---
code/game/G_Timer.cpp | 2 +
code/qcommon/q_shared.h | 35 +
code/rd-vanilla/G2_misc.cpp | 21 +-
codeJK2/game/G_Timer.cpp | 2 +
shared/qcommon/ojk_i_saved_game.h | 763 ++++++++++-----------
shared/qcommon/ojk_i_saved_game_fwd.h | 418 +++++------
shared/qcommon/ojk_saved_game.cpp | 1219 +++++++++++++++++----------------
shared/qcommon/ojk_saved_game.h | 228 +++---
8 files changed, 1388 insertions(+), 1300 deletions(-)
diff --git a/code/game/G_Timer.cpp b/code/game/G_Timer.cpp
index e66ae8c..c7f7b44 100644
--- a/code/game/G_Timer.cpp
+++ b/code/game/G_Timer.cpp
@@ -244,6 +244,8 @@ void TIMER_Load( void )
sg_buffer_size,
tempBuffer);
+ tempBuffer[sg_buffer_size] = '\0';
+
::gi.saved_game->read_chunk<int32_t>(
INT_ID('T','D','T','A'),
time);
diff --git a/code/qcommon/q_shared.h b/code/qcommon/q_shared.h
index ed87688..83a92dd 100644
--- a/code/qcommon/q_shared.h
+++ b/code/qcommon/q_shared.h
@@ -1378,14 +1378,24 @@ typedef struct {
#define MAX_MODELS 256
+
+#ifdef JK2_MODE
+#define MAX_SOUNDS (256)
+#else
#define MAX_SOUNDS 380
+#endif // JK2_MODE
#define MAX_SUB_BSP 32
#define MAX_SUBMODELS 512 // nine bits
#define MAX_FX 128
+
+#ifdef JK2_MODE
+#define MAX_WORLD_FX (4)
+#else
#define MAX_WORLD_FX 66 // was 16 // was 4
+#endif // JK2_MODE
/*
Ghoul2 Insert Start
@@ -1395,7 +1405,11 @@ Ghoul2 Insert Start
Ghoul2 Insert End
*/
+#ifdef JK2_MODE
+#define MAX_CONFIGSTRINGS (1024)
+#else
#define MAX_CONFIGSTRINGS 1300//1024 //rww - I had to up this for terrains
+#endif // JK2_MODE
// these are the only configstrings that the system reserves, all the
// other ones are strictly for servergame to clientgame communication
@@ -1416,19 +1430,40 @@ Ghoul2 Insert End
#define CS_MODELS 10
+#ifndef JK2_MODE
#define CS_SKYBOXORG (CS_MODELS+MAX_MODELS) //rww - skybox info
+#endif // !JK2_MODE
+#ifdef JK2_MODE
+#define CS_SOUNDS (CS_MODELS + MAX_MODELS)
+#else
#define CS_SOUNDS (CS_SKYBOXORG+1)
+#endif // JK2_MODE
+
+#ifdef JK2_MODE
+#define CS_PLAYERS (CS_SOUNDS + MAX_SOUNDS)
+#else
#ifdef BASE_SAVE_COMPAT
#define CS_RESERVED1 (CS_SOUNDS+MAX_SOUNDS) // reserved field for base compat from immersion removal
#define CS_PLAYERS (CS_RESERVED1 + 96)
#else
#define CS_PLAYERS (CS_SOUNDS+MAX_SOUNDS)
#endif
+#endif // JK2_MODE
+
#define CS_LIGHT_STYLES (CS_PLAYERS+MAX_CLIENTS)
+
+#ifndef JK2_MODE
#define CS_TERRAINS (CS_LIGHT_STYLES + (MAX_LIGHT_STYLES*3))
#define CS_BSP_MODELS (CS_TERRAINS + MAX_TERRAINS)
+#endif // !JK2_MODE
+
+#ifdef JK2_MODE
+#define CS_EFFECTS (CS_LIGHT_STYLES + (MAX_LIGHT_STYLES * 3))
+#else
#define CS_EFFECTS (CS_BSP_MODELS + MAX_SUB_BSP)//(CS_LIGHT_STYLES + (MAX_LIGHT_STYLES*3))
+#endif // JK2_MODE
+
/*
Ghoul2 Insert Start
*/
diff --git a/code/rd-vanilla/G2_misc.cpp b/code/rd-vanilla/G2_misc.cpp
index 6a0111c..436c4a6 100644
--- a/code/rd-vanilla/G2_misc.cpp
+++ b/code/rd-vanilla/G2_misc.cpp
@@ -1788,13 +1788,16 @@ void G2_SaveGhoul2Models(
// is there anything to save?
if (!ghoul2.IsValid() || ghoul2.size() == 0) {
+ const int zero_size = 0;
+
#ifdef JK2_MODE
+ ::ri.saved_game->write<int32_t>(
+ zero_size);
+
::ri.saved_game->write_chunk_and_size<int32_t>(
- INT_ID('G', 'L', 'S', '2'),
+ INT_ID('G', 'L', '2', 'S'),
INT_ID('G', 'H', 'L', '2'));
#else
- const int zero_size = 0;
-
::ri.saved_game->write_chunk<int32_t>(
INT_ID('G', 'H', 'L', '2'),
zero_size); //write out a zero buffer
@@ -1855,7 +1858,7 @@ void G2_SaveGhoul2Models(
#ifdef JK2_MODE
::ri.saved_game->write_chunk_and_size<int32_t>(
- INT_ID('G', 'L', 'S', '2'),
+ INT_ID('G', 'L', '2', 'S'),
INT_ID('G', 'H', 'L', '2'));
#else
::ri.saved_game->write_chunk(
@@ -1873,9 +1876,19 @@ void G2_LoadGhoul2Model(
// first thing, lets see how many ghoul2 models we have, and resize our buffers accordingly
auto model_count = 0;
+#ifdef JK2_MODE
+ if (::ri.saved_game->get_buffer_size() > 0)
+ {
+#endif // JK2_MODE
+
::ri.saved_game->read<int32_t>(
model_count);
+#ifdef JK2_MODE
+ }
+#endif // JK2_MODE
+
+
ghoul2.resize(
model_count);
diff --git a/codeJK2/game/G_Timer.cpp b/codeJK2/game/G_Timer.cpp
index 1896e48..34246ea 100644
--- a/codeJK2/game/G_Timer.cpp
+++ b/codeJK2/game/G_Timer.cpp
@@ -259,6 +259,8 @@ void TIMER_Load( void )
tempBuffer,
length);
+ tempBuffer[length] = '\0';
+
::gi.saved_game->read_chunk<int32_t>(
INT_ID('T','D','T','A'),
time);
diff --git a/shared/qcommon/ojk_i_saved_game.h b/shared/qcommon/ojk_i_saved_game.h
index cb83e41..ed8eaed 100644
--- a/shared/qcommon/ojk_i_saved_game.h
+++ b/shared/qcommon/ojk_i_saved_game.h
@@ -13,7 +13,8 @@
#include "ojk_scope_guard.h"
-namespace ojk {
+namespace ojk
+{
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
@@ -36,32 +37,32 @@ inline ISavedGame::~ISavedGame()
template<typename TSrc, typename TDst>
void ISavedGame::read_chunk(
- const ChunkId chunk_id,
- TDst& dst_value)
+ const ChunkId chunk_id,
+ TDst& dst_value)
{
- read_chunk(
- chunk_id);
+ read_chunk(
+ chunk_id);
- read<TSrc>(
- dst_value);
+ read<TSrc>(
+ dst_value);
- ensure_all_data_read();
+ ensure_all_data_read();
}
template<typename TSrc, typename TDst>
void ISavedGame::read_chunk(
- const ChunkId chunk_id,
- TDst* dst_values,
- int dst_count)
+ const ChunkId chunk_id,
+ TDst* dst_values,
+ int dst_count)
{
- read_chunk(
- chunk_id);
+ read_chunk(
+ chunk_id);
- read<TSrc>(
- dst_values,
- dst_count);
+ read<TSrc>(
+ dst_values,
+ dst_count);
- ensure_all_data_read();
+ ensure_all_data_read();
}
// read_chunk
@@ -73,53 +74,53 @@ void ISavedGame::read_chunk(
template<typename TSize>
void ISavedGame::write_chunk_and_size(
- const ChunkId size_chunk_id,
- const ChunkId data_chunk_id)
+ const ChunkId size_chunk_id,
+ const ChunkId data_chunk_id)
{
- save_buffer();
+ save_buffer();
- auto data_size = get_buffer_size();
+ auto data_size = get_buffer_size();
- reset_buffer();
+ reset_buffer();
- write_chunk<TSize>(
- size_chunk_id,
- data_size);
+ write_chunk<TSize>(
+ size_chunk_id,
+ data_size);
- load_buffer();
+ load_buffer();
- write_chunk(
- data_chunk_id);
+ write_chunk(
+ data_chunk_id);
}
template<typename TDst, typename TSrc>
void ISavedGame::write_chunk(
- const ChunkId chunk_id,
- const TSrc& src_value)
+ const ChunkId chunk_id,
+ const TSrc& src_value)
{
- reset_buffer();
+ reset_buffer();
- write<TDst>(
- src_value);
+ write<TDst>(
+ src_value);
- write_chunk(
- chunk_id);
+ write_chunk(
+ chunk_id);
}
template<typename TDst, typename TSrc>
void ISavedGame::write_chunk(
- const ChunkId chunk_id,
- const TSrc* src_values,
- int src_count)
+ const ChunkId chunk_id,
+ const TSrc* src_values,
+ int src_count)
{
- reset_buffer();
+ reset_buffer();
- write<TDst>(
- src_values,
- src_count);
+ write<TDst>(
+ src_values,
+ src_count);
- write_chunk(
- chunk_id);
+ write_chunk(
+ chunk_id);
}
// write_chunk
@@ -131,137 +132,137 @@ void ISavedGame::write_chunk(
template<typename TSrc, typename TDst>
void ISavedGame::read(
- TDst& dst_value)
+ TDst& dst_value)
{
- using Tag = typename std::conditional<
- std::is_same<TDst, bool>::value,
- BooleanTag,
- typename std::conditional<
- std::is_arithmetic<TDst>::value || std::is_enum<TDst>::value,
- NumericTag,
- typename std::conditional<
- std::is_pointer<TDst>::value,
- PointerTag,
- typename std::conditional<
- std::is_class<TDst>::value,
- ClassTag,
- typename std::conditional<
- std::rank<TDst>::value == 1,
- Array1dTag,
- typename std::conditional<
- std::rank<TDst>::value == 2,
- Array2dTag,
- void
- >::type
- >::type
- >::type
- >::type
- >::type
- >::type;
-
- static_assert(
- !std::is_same<Tag, void>::value,
- "Unsupported type.");
-
- read<TSrc>(
- dst_value,
- Tag());
+ using Tag = typename std::conditional <
+ std::is_same<TDst, bool>::value,
+ BooleanTag,
+ typename std::conditional<
+ std::is_arithmetic<TDst>::value || std::is_enum<TDst>::value,
+ NumericTag,
+ typename std::conditional<
+ std::is_pointer<TDst>::value,
+ PointerTag,
+ typename std::conditional<
+ std::is_class<TDst>::value,
+ ClassTag,
+ typename std::conditional<
+ std::rank<TDst>::value == 1,
+ Array1dTag,
+ typename std::conditional<
+ std::rank<TDst>::value == 2,
+ Array2dTag,
+ void
+ >::type
+ >::type
+ >::type
+ >::type
+ >::type
+ > ::type;
+
+ static_assert(
+ !std::is_same<Tag, void>::value,
+ "Unsupported type.");
+
+ read<TSrc>(
+ dst_value,
+ Tag());
}
template<typename TSrc, typename TDst>
void ISavedGame::read(
- TDst& dst_value,
- BooleanTag)
+ TDst& dst_value,
+ BooleanTag)
{
- constexpr auto src_size = static_cast<int>(sizeof(TSrc));
+ constexpr auto src_size = static_cast<int>(sizeof(TSrc));
- TSrc src_value;
+ TSrc src_value;
- raw_read(
- &src_value,
- static_cast<int>(sizeof(TSrc)));
+ raw_read(
+ &src_value,
+ static_cast<int>(sizeof(TSrc)));
- // FIXME Byte order
- //
+ // FIXME Byte order
+ //
- dst_value = (src_value != 0);
+ dst_value = (src_value != 0);
}
template<typename TSrc, typename TDst>
void ISavedGame::read(
- TDst& dst_value,
- NumericTag)
+ TDst& dst_value,
+ NumericTag)
{
- constexpr auto src_size = static_cast<int>(sizeof(TSrc));
+ constexpr auto src_size = static_cast<int>(sizeof(TSrc));
- TSrc src_value;
+ TSrc src_value;
- raw_read(
- &src_value,
- src_size);
+ raw_read(
+ &src_value,
+ src_size);
- // FIXME Byte order
- //
+ // FIXME Byte order
+ //
- dst_value = static_cast<TDst>(src_value);
+ dst_value = static_cast<TDst>(src_value);
}
template<typename TSrc, typename TDst>
void ISavedGame::read(
- TDst*& dst_value,
- PointerTag)
+ TDst*& dst_value,
+ PointerTag)
{
- static_assert(
- std::is_arithmetic<TSrc>::value &&
- !std::is_same<TSrc, bool>::value,
- "Unsupported types.");
+ static_assert(
+ std::is_arithmetic<TSrc>::value &&
+ !std::is_same<TSrc, bool>::value,
+ "Unsupported types.");
- using DstNumeric = typename std::conditional<
- std::is_signed<TSrc>::value,
- std::intptr_t,
- std::uintptr_t
- >::type;
+ using DstNumeric = typename std::conditional<
+ std::is_signed<TSrc>::value,
+ std::intptr_t,
+ std::uintptr_t
+ >::type;
- auto dst_number = DstNumeric();
+ auto dst_number = DstNumeric();
- read<TSrc>(
- dst_number,
- NumericTag());
+ read<TSrc>(
+ dst_number,
+ NumericTag());
- dst_value = reinterpret_cast<TDst*>(dst_number);
+ dst_value = reinterpret_cast<TDst*>(dst_number);
}
template<typename TSrc, typename TDst>
void ISavedGame::read(
- TDst& dst_value,
- ClassTag)
+ TDst& dst_value,
+ ClassTag)
{
- static_assert(
- std::is_same<TSrc, void>::value,
- "Unsupported types.");
+ static_assert(
+ std::is_same<TSrc, void>::value,
+ "Unsupported types.");
- dst_value.sg_import(
- this);
+ dst_value.sg_import(
+ this);
}
template<typename TSrc, typename TDst, int TCount>
void ISavedGame::read(
- TDst (&dst_values)[TCount],
- Array1dTag)
+ TDst(&dst_values)[TCount],
+ Array1dTag)
{
- read<TSrc>(
- &dst_values[0],
- TCount);
+ read<TSrc>(
+ &dst_values[0],
+ TCount);
}
template<typename TSrc, typename TDst, int TCount1, int TCount2>
void ISavedGame::read(
- TDst(&dst_values)[TCount1][TCount2],
- Array2dTag)
+ TDst(&dst_values)[TCount1][TCount2],
+ Array2dTag)
{
- read<TSrc>(
- &dst_values[0][0],
- TCount1 * TCount2);
+ read<TSrc>(
+ &dst_values[0][0],
+ TCount1 * TCount2);
}
// read
@@ -273,27 +274,27 @@ void ISavedGame::read(
template<typename TSrc, typename TDst>
bool ISavedGame::try_read(
- TDst& dst_value)
+ TDst& dst_value)
{
- ScopeGuard scope_guard(
- [this]()
- {
- this->allow_read_overflow(
- true);
- },
+ ScopeGuard scope_guard(
+ [this]()
+ {
+ this->allow_read_overflow(
+ true);
+ },
- [this]()
- {
- this->allow_read_overflow(
- false);
- }
- );
+ [this]()
+ {
+ this->allow_read_overflow(
+ false);
+ }
+ );
- read<TSrc>(
- dst_value);
+ read<TSrc>(
+ dst_value);
- return is_all_data_read();
+ return is_all_data_read();
}
// try_read
@@ -305,103 +306,103 @@ bool ISavedGame::try_read(
template<typename TSrc, typename TDst>
void ISavedGame::read(
- TDst* dst_values,
- int dst_count)
+ TDst* dst_values,
+ int dst_count)
{
- static_assert(
- (std::is_arithmetic<TDst>::value &&
- !std::is_same<TDst, bool>::value &&
- !std::is_enum<TDst>::value) ||
- std::is_pointer<TDst>::value ||
- std::is_class<TDst>::value,
- "Unsupported types.");
-
- using Src = typename std::conditional<
- std::is_same<TSrc, void>::value,
- TDst,
- TSrc
- >::type;
-
- constexpr auto is_src_pure_numeric =
- std::is_arithmetic<Src>::value &&
- (!std::is_same<Src, bool>::value) &&
- (!std::is_enum<Src>::value);
-
- constexpr auto is_dst_pure_numeric =
- std::is_arithmetic<TDst>::value &&
- (!std::is_same<TDst, bool>::value) &&
- (!std::is_enum<TDst>::value);
-
- constexpr auto is_src_float_point =
- std::is_floating_point<Src>::value;
-
- constexpr auto is_dst_float_point =
- std::is_floating_point<TDst>::value;
-
- constexpr auto has_same_size =
- (sizeof(Src) == sizeof(TDst));
-
- constexpr auto use_inplace =
- is_src_pure_numeric &&
- is_dst_pure_numeric &&
- ((!is_src_float_point && !is_dst_float_point) ||
- (is_src_float_point && is_dst_float_point)) &&
- has_same_size;
-
- using Tag = typename std::conditional<
- use_inplace,
- InplaceTag,
- CastTag
- >::type;
-
- read<TSrc>(
- dst_values,
- dst_count,
- Tag());
+ static_assert(
+ (std::is_arithmetic<TDst>::value &&
+ !std::is_same<TDst, bool>::value &&
+ !std::is_enum<TDst>::value) ||
+ std::is_pointer<TDst>::value ||
+ std::is_class<TDst>::value,
+ "Unsupported types.");
+
+ using Src = typename std::conditional<
+ std::is_same<TSrc, void>::value,
+ TDst,
+ TSrc
+ >::type;
+
+ constexpr auto is_src_pure_numeric =
+ std::is_arithmetic<Src>::value &&
+ (!std::is_same<Src, bool>::value) &&
+ (!std::is_enum<Src>::value);
+
+ constexpr auto is_dst_pure_numeric =
+ std::is_arithmetic<TDst>::value &&
+ (!std::is_same<TDst, bool>::value) &&
+ (!std::is_enum<TDst>::value);
+
+ constexpr auto is_src_float_point =
+ std::is_floating_point<Src>::value;
+
+ constexpr auto is_dst_float_point =
+ std::is_floating_point<TDst>::value;
+
+ constexpr auto has_same_size =
+ (sizeof(Src) == sizeof(TDst));
+
+ constexpr auto use_inplace =
+ is_src_pure_numeric &&
+ is_dst_pure_numeric &&
+ ((!is_src_float_point && !is_dst_float_point) ||
+ (is_src_float_point && is_dst_float_point)) &&
+ has_same_size;
+
+ using Tag = typename std::conditional<
+ use_inplace,
+ InplaceTag,
+ CastTag
+ >::type;
+
+ read<TSrc>(
+ dst_values,
+ dst_count,
+ Tag());
}
template<typename TSrc, typename TDst>
void ISavedGame::read(
- TDst* dst_values,
- int dst_count,
- InplaceTag)
+ TDst* dst_values,
+ int dst_count,
+ InplaceTag)
{
- const auto dst_size = dst_count * static_cast<int>(sizeof(TDst));
+ const auto dst_size = dst_count * static_cast<int>(sizeof(TDst));
- raw_read(
- dst_values,
- dst_size);
+ raw_read(
+ dst_values,
+ dst_size);
- // FIXME Byte order
- //
+ // FIXME Byte order
+ //
}
template<typename TSrc, typename TDst>
void ISavedGame::read(
- TDst* dst_values,
- int dst_count,
- CastTag)
+ TDst* dst_values,
+ int dst_count,
+ CastTag)
{
- using Tag = typename std::conditional<
- std::is_arithmetic<TDst>::value,
- NumericTag,
- typename std::conditional<
- std::is_pointer<TDst>::value,
- PointerTag,
- typename std::conditional<
- std::is_class<TDst>::value,
- ClassTag,
- void
- >::type
- >::type
- >::type;
-
- for (int i = 0; i < dst_count; ++i)
- {
- read<TSrc>(
- dst_values[i],
- Tag());
- }
+ using Tag = typename std::conditional<
+ std::is_arithmetic<TDst>::value,
+ NumericTag,
+ typename std::conditional<
+ std::is_pointer<TDst>::value,
+ PointerTag,
+ typename std::conditional<
+ std::is_class<TDst>::value,
+ ClassTag,
+ void
+ >::type
+ >::type
+ >::type;
+
+ for (int i = 0; i < dst_count; ++i)
+ {
+ read<TSrc>(
+ dst_values[i],
+ Tag());
+ }
}
// read (C-array)
@@ -413,105 +414,105 @@ void ISavedGame::read(
template<typename TDst, typename TSrc>
void ISavedGame::write(
- const TSrc& src_value)
+ const TSrc& src_value)
{
- using Tag = typename std::conditional<
- std::is_arithmetic<TSrc>::value || std::is_enum<TSrc>::value,
- NumericTag,
- typename std::conditional<
- std::is_pointer<TSrc>::value,
- PointerTag,
- typename std::conditional<
- std::is_class<TSrc>::value,
- ClassTag,
- typename std::conditional<
- std::rank<TSrc>::value == 1,
- Array1dTag,
- typename std::conditional<
- std::rank<TSrc>::value == 2,
- Array2dTag,
- void
- >::type
- >::type
- >::type
- >::type
- >::type;
-
- static_assert(
- !std::is_same<Tag, void>::value,
- "Unsupported type.");
-
- write<TDst>(
- src_value,
- Tag());
+ using Tag = typename std::conditional<
+ std::is_arithmetic<TSrc>::value || std::is_enum<TSrc>::value,
+ NumericTag,
+ typename std::conditional<
+ std::is_pointer<TSrc>::value,
+ PointerTag,
+ typename std::conditional<
+ std::is_class<TSrc>::value,
+ ClassTag,
+ typename std::conditional<
+ std::rank<TSrc>::value == 1,
+ Array1dTag,
+ typename std::conditional<
+ std::rank<TSrc>::value == 2,
+ Array2dTag,
+ void
+ >::type
+ >::type
+ >::type
+ >::type
+ >::type;
+
+ static_assert(
+ !std::is_same<Tag, void>::value,
+ "Unsupported type.");
+
+ write<TDst>(
+ src_value,
+ Tag());
}
template<typename TDst, typename TSrc>
void ISavedGame::write(
- const TSrc& src_value,
- NumericTag)
+ const TSrc& src_value,
+ NumericTag)
{
- constexpr auto dst_size = static_cast<int>(sizeof(TDst));
+ constexpr auto dst_size = static_cast<int>(sizeof(TDst));
- auto dst_value = static_cast<TDst>(src_value);
+ auto dst_value = static_cast<TDst>(src_value);
- // FIXME Byte order
- //
+ // FIXME Byte order
+ //
- raw_write(
- &dst_value,
- dst_size);
+ raw_write(
+ &dst_value,
+ dst_size);
}
template<typename TDst, typename TSrc>
void ISavedGame::write(
- const TSrc* src_value,
- PointerTag)
+ const TSrc* src_value,
+ PointerTag)
{
- using DstNumeric = typename std::conditional<
- std::is_signed<TSrc>::value,
- std::intptr_t,
- std::uintptr_t
- >::type;
+ using DstNumeric = typename std::conditional<
+ std::is_signed<TSrc>::value,
+ std::intptr_t,
+ std::uintptr_t
+ >::type;
- auto dst_number = reinterpret_cast<DstNumeric>(src_value);
+ auto dst_number = reinterpret_cast<DstNumeric>(src_value);
- write<TDst>(
- dst_number,
- NumericTag());
+ write<TDst>(
+ dst_number,
+ NumericTag());
}
template<typename TDst, typename TSrc>
void ISavedGame::write(
- const TSrc& src_value,
- ClassTag)
+ const TSrc& src_value,
+ ClassTag)
{
- static_assert(
- std::is_same<TDst, void>::value,
- "Unsupported types.");
+ static_assert(
+ std::is_same<TDst, void>::value,
+ "Unsupported types.");
- src_value.sg_export(
- this);
+ src_value.sg_export(
+ this);
}
template<typename TDst, typename TSrc, int TCount>
void ISavedGame::write(
- const TSrc (&src_values)[TCount],
- Array1dTag)
+ const TSrc(&src_values)[TCount],
+ Array1dTag)
{
- write<TDst>(
- &src_values[0],
- TCount);
+ write<TDst>(
+ &src_values[0],
+ TCount);
}
template<typename TDst, typename TSrc, int TCount1, int TCount2>
void ISavedGame::write(
- const TSrc (&src_values)[TCount1][TCount2],
- Array2dTag)
+ const TSrc(&src_values)[TCount1][TCount2],
+ Array2dTag)
{
- write<TDst>(
- &src_values[0][0],
- TCount1 * TCount2);
+ write<TDst>(
+ &src_values[0][0],
+ TCount1 * TCount2);
}
// write
@@ -523,102 +524,102 @@ void ISavedGame::write(
template<typename TDst, typename TSrc>
void ISavedGame::write(
- const TSrc* src_values,
- int src_count)
+ const TSrc* src_values,
+ int src_count)
{
- static_assert(
- (std::is_arithmetic<TSrc>::value &&
- !std::is_same<TSrc, bool>::value &&
- !std::is_enum<TSrc>::value) ||
- std::is_pointer<TSrc>::value ||
- std::is_class<TSrc>::value,
- "Unsupported types.");
-
- using Dst = typename std::conditional<
- std::is_same<TDst, void>::value,
- TSrc,
- TDst>::type;
-
- constexpr auto is_src_pure_numeric =
- std::is_arithmetic<TSrc>::value &&
- (!std::is_same<TSrc, bool>::value) &&
- (!std::is_enum<TSrc>::value);
-
- constexpr auto is_dst_pure_numeric =
- std::is_arithmetic<Dst>::value &&
- (!std::is_same<Dst, bool>::value) &&
- (!std::is_enum<Dst>::value);
-
- constexpr auto is_src_float_point =
- std::is_floating_point<TSrc>::value;
-
- constexpr auto is_dst_float_point =
- std::is_floating_point<Dst>::value;
-
- constexpr auto has_same_size =
- (sizeof(TSrc) == sizeof(Dst));
-
- constexpr auto use_inplace =
- is_src_pure_numeric &&
- is_dst_pure_numeric &&
- ((!is_src_float_point && !is_dst_float_point) ||
- (is_src_float_point && is_dst_float_point)) &&
- has_same_size;
-
- using Tag = typename std::conditional<
- use_inplace,
- InplaceTag,
- CastTag
- >::type;
-
- write<TDst>(
- src_values,
- src_count,
- Tag());
+ static_assert(
+ (std::is_arithmetic<TSrc>::value &&
+ !std::is_same<TSrc, bool>::value &&
+ !std::is_enum<TSrc>::value) ||
+ std::is_pointer<TSrc>::value ||
+ std::is_class<TSrc>::value,
+ "Unsupported types.");
+
+ using Dst = typename std::conditional<
+ std::is_same<TDst, void>::value,
+ TSrc,
+ TDst>::type;
+
+ constexpr auto is_src_pure_numeric =
+ std::is_arithmetic<TSrc>::value &&
+ (!std::is_same<TSrc, bool>::value) &&
+ (!std::is_enum<TSrc>::value);
+
+ constexpr auto is_dst_pure_numeric =
+ std::is_arithmetic<Dst>::value &&
+ (!std::is_same<Dst, bool>::value) &&
+ (!std::is_enum<Dst>::value);
+
+ constexpr auto is_src_float_point =
+ std::is_floating_point<TSrc>::value;
+
+ constexpr auto is_dst_float_point =
+ std::is_floating_point<Dst>::value;
+
+ constexpr auto has_same_size =
+ (sizeof(TSrc) == sizeof(Dst));
+
+ constexpr auto use_inplace =
+ is_src_pure_numeric &&
+ is_dst_pure_numeric &&
+ ((!is_src_float_point && !is_dst_float_point) ||
+ (is_src_float_point && is_dst_float_point)) &&
+ has_same_size;
+
+ using Tag = typename std::conditional<
+ use_inplace,
+ InplaceTag,
+ CastTag
+ >::type;
+
+ write<TDst>(
+ src_values,
+ src_count,
+ Tag());
}
template<typename TDst, typename TSrc>
void ISavedGame::write(
- const TSrc* src_values,
- int src_count,
- InplaceTag)
+ const TSrc* src_values,
+ int src_count,
+ InplaceTag)
{
- const auto src_size = src_count * static_cast<int>(sizeof(TSrc));
+ const auto src_size = src_count * static_cast<int>(sizeof(TSrc));
- raw_write(
- src_values,
- src_size);
+ raw_write(
+ src_values,
+ src_size);
- // FIXME Byte order
- //
+ // FIXME Byte order
+ //
}
template<typename TDst, typename TSrc>
void ISavedGame::write(
- const TSrc* src_values,
- int src_count,
- CastTag)
+ const TSrc* src_values,
+ int src_count,
+ CastTag)
{
- using Tag = typename std::conditional<
- std::is_arithmetic<TSrc>::value,
- NumericTag,
- typename std::conditional<
- std::is_pointer<TSrc>::value,
- PointerTag,
- typename std::conditional<
- std::is_class<TSrc>::value,
- ClassTag,
- void
- >::type
- >::type
- >::type;
-
- for (int i = 0; i < src_count; ++i)
- {
- write<TDst>(
- src_values[i],
- Tag());
- }
+ using Tag = typename std::conditional<
+ std::is_arithmetic<TSrc>::value,
+ NumericTag,
+ typename std::conditional<
+ std::is_pointer<TSrc>::value,
+ PointerTag,
+ typename std::conditional<
+ std::is_class<TSrc>::value,
+ ClassTag,
+ void
+ >::type
+ >::type
+ >::type;
+
+ for (int i = 0; i < src_count; ++i)
+ {
+ write<TDst>(
+ src_values[i],
+ Tag());
+ }
}
// write (C-array)
diff --git a/shared/qcommon/ojk_i_saved_game_fwd.h b/shared/qcommon/ojk_i_saved_game_fwd.h
index 91a7e61..7a3bb59 100644
--- a/shared/qcommon/ojk_i_saved_game_fwd.h
+++ b/shared/qcommon/ojk_i_saved_game_fwd.h
@@ -19,245 +19,269 @@ namespace ojk
class ISavedGame
{
public:
- using ChunkId = uint32_t;
+ using ChunkId = uint32_t;
- ISavedGame();
+ ISavedGame();
- ISavedGame(
- const ISavedGame& that) = delete;
+ ISavedGame(
+ const ISavedGame& that) = delete;
- ISavedGame& operator=(
- const ISavedGame& that) = delete;
+ ISavedGame& operator=(
+ const ISavedGame& that) = delete;
- virtual ~ISavedGame();
+ virtual ~ISavedGame();
- // Returns true if the saved game opened for reading.
- virtual bool is_readable() const = 0;
+ // Returns true if the saved game opened for reading.
+ virtual bool is_readable() const = 0;
- // Returns true if the saved game opened for writing.
- virtual bool is_writable() const = 0;
+ // Returns true if the saved game opened for writing.
+ virtual bool is_writable() const = 0;
- // Reads a chunk from the file into the internal buffer.
- virtual void read_chunk(
- const ChunkId chunk_id) = 0;
+ // Reads a chunk from the file into the internal buffer.
+ virtual void read_chunk(
+ const ChunkId chunk_id) = 0;
- // Reads a value or an array of values from the file via
- // the internal buffer.
- template<typename TSrc = void, typename TDst = void>
- void read_chunk(
- const ChunkId chunk_id,
- TDst& dst_value);
+ // Reads a value or an array of values from the file via
+ // the internal buffer.
+ template<typename TSrc = void, typename TDst = void>
+ void read_chunk(
+ const ChunkId chunk_id,
+ TDst& dst_value);
- // Reads an array of values with specified count from
- // the file via the internal buffer.
- template<typename TSrc = void, typename TDst = void>
- void read_chunk(
- const ChunkId chunk_id,
- TDst* dst_values,
- int dst_count);
+ // Reads an array of values with specified count from
+ // the file via the internal buffer.
+ template<typename TSrc = void, typename TDst = void>
+ void read_chunk(
+ const ChunkId chunk_id,
+ TDst* dst_values,
+ int dst_count);
- // Returns true if all data read from the internal buffer.
- virtual bool is_all_data_read() const = 0;
+ // Returns true if all data read from the internal buffer.
+ virtual bool is_all_data_read() const = 0;
- // Throws an exception if all data not read.
- virtual void ensure_all_data_read() const = 0;
+ // Throws an exception if all data not read.
+ virtual void ensure_all_data_read() const = 0;
- // Writes a chunk into the file from the internal buffer.
- virtual void write_chunk(
- const ChunkId chunk_id) = 0;
+ // Writes a chunk into the file from the internal buffer.
+ virtual void write_chunk(
+ const ChunkId chunk_id) = 0;
- // Writes a data-chunk into the file from the internal buffer
- // prepended with a size-chunk that holds a size of the data-chunk.
- template<typename TSize>
- void write_chunk_and_size(
- const ChunkId size_chunk_id,
- const ChunkId data_chunk_id);
+ // Writes a data-chunk into the file from the internal buffer
+ // prepended with a size-chunk that holds a size of the data-chunk.
+ template<typename TSize>
+ void write_chunk_and_size(
+ const ChunkId size_chunk_id,
+ const ChunkId data_chunk_id);
- // Writes a value or an array of values into the file via
- // the internal buffer.
- template<typename TDst = void, typename TSrc = void>
- void write_chunk(
- const ChunkId chunk_id,
- const TSrc& src_value);
+ // Writes a value or an array of values into the file via
+ // the internal buffer.
+ template<typename TDst = void, typename TSrc = void>
+ void write_chunk(
+ const ChunkId chunk_id,
+ const TSrc& src_value);
- // Writes an array of values with specified count into
- // the file via the internal buffer.
- template<typename TDst = void, typename TSrc = void>
- void write_chunk(
- const ChunkId chunk_id,
- const TSrc* src_values,
- int src_count);
+ // Writes an array of values with specified count into
+ // the file via the internal buffer.
+ template<typename TDst = void, typename TSrc = void>
+ void write_chunk(
+ const ChunkId chunk_id,
+ const TSrc* src_values,
+ int src_count);
- // Reads a raw data from the internal buffer.
- virtual void raw_read(
- void* dst_data,
- int dst_size) = 0;
+ // Reads a raw data from the internal buffer.
+ virtual void raw_read(
+ void* dst_data,
+ int dst_size) = 0;
- // Reads a value or array of values from the internal buffer.
- template<typename TSrc = void, typename TDst = void>
- void read(
- TDst& dst_value);
+ // Reads a value or array of values from the internal buffer.
+ template<typename TSrc = void, typename TDst = void>
+ void read(
+ TDst& dst_value);
- // Reads an array of values with specificed count from the internal buffer.
- template<typename TSrc = void, typename TDst = void>
- void read(
- TDst* dst_values,
- int dst_count);
+ // Reads an array of values with specificed count from the internal buffer.
+ template<typename TSrc = void, typename TDst = void>
+ void read(
+ TDst* dst_values,
+ int dst_count);
- // Tries to read a value or array of values from the internal buffer.
- // Returns true on success or false otherwise.
- template<typename TSrc = void, typename TDst = void>
- bool try_read(
- TDst& dst_value);
+ // Tries to read a value or array of values from the internal buffer.
+ // Returns true on success or false otherwise.
+ template<typename TSrc = void, typename TDst = void>
+ bool try_read(
+ TDst& dst_value);
- // Writes a raw data into the internal buffer.
- virtual void raw_write(
- const void* src_data,
- int src_size) = 0;
+ // Writes a raw data into the internal buffer.
+ virtual void raw_write(
+ const void* src_data,
+ int src_size) = 0;
- // Writes a value or array of values into the internal buffer.
- template<typename TDst = void, typename TSrc = void>
- void write(
- const TSrc& src_value);
+ // Writes a value or array of values into the internal buffer.
+ template<typename TDst = void, typename TSrc = void>
+ void write(
+ const TSrc& src_value);
- // Writes an array of values with specificed count into the internal buffer.
- template<typename TDst = void, typename TSrc = void>
- void write(
- const TSrc* src_values,
- int src_count);
+ // Writes an array of values with specificed count into the internal buffer.
+ template<typename TDst = void, typename TSrc = void>
+ void write(
+ const TSrc* src_values,
+ int src_count);
- // Increments buffer's offset by the specified non-negative count.
- virtual void skip(
- int count) = 0;
+ // Increments buffer's offset by the specified non-negative count.
+ virtual void skip(
+ int count) = 0;
- // Stores current I/O buffer and it's position.
- virtual void save_buffer() = 0;
+ // Stores current I/O buffer and it's position.
+ virtual void save_buffer() = 0;
- // Restores saved I/O buffer and it's position.
- virtual void load_buffer() = 0;
+ // Restores saved I/O buffer and it's position.
+ virtual void load_buffer() = 0;
- // Returns a pointer to data in the I/O buffer.
- virtual const void* get_buffer_data() const = 0;
+ // Returns a pointer to data in the I/O buffer.
+ virtual const void* get_buffer_data() const = 0;
- // Returns a current size of the I/O buffer.
- virtual int get_buffer_size() const = 0;
+ // Returns a current size of the I/O buffer.
+ virtual int get_buffer_size() const = 0;
- // Clears buffer and resets it's offset to the beginning.
- virtual void reset_buffer() = 0;
+ // Clears buffer and resets it's offset to the beginning.
+ virtual void reset_buffer() = 0;
- // Resets buffer offset to the beginning.
- virtual void reset_buffer_offset() = 0;
+ // Resets buffer offset to the beginning.
+ virtual void reset_buffer_offset() = 0;
protected:
- // Tags for dispatching.
- class BooleanTag { public: };
- class NumericTag { public: };
- class PointerTag { public: };
- class ClassTag { public: };
- class Array1dTag { public: };
- class Array2dTag { public: };
- class InplaceTag { public: };
- class CastTag { public: };
-
-
- // If true won't throw an exception when buffer offset is beyond it's size.
- // Although, no data will be read beyond the buffer.
- virtual void allow_read_overflow(
- bool value) = 0;
-
-
- template<typename TSrc, typename TDst>
- void read(
- TDst& dst_value,
- BooleanTag);
-
- template<typename TSrc, typename TDst>
- void read(
- TDst& dst_value,
- NumericTag);
-
- template<typename TSrc, typename TDst>
- void read(
- TDst*& dst_value,
- PointerTag);
-
- template<typename TSrc, typename TDst>
- void read(
- TDst& dst_value,
- ClassTag);
-
- template<typename TSrc, typename TDst, int TCount>
- void read(
- TDst (&dst_values)[TCount],
- Array1dTag);
-
- template<typename TSrc, typename TDst, int TCount1, int TCount2>
- void read(
- TDst (&dst_values)[TCount1][TCount2],
- Array2dTag);
-
-
- template<typename TSrc, typename TDst>
- void read(
- TDst* dst_values,
- int dst_count,
- InplaceTag);
-
- template<typename TSrc, typename TDst>
- void read(
- TDst* dst_values,
- int dst_count,
- CastTag);
-
-
- template<typename TDst, typename TSrc>
- void write(
- const TSrc& src_value,
- NumericTag);
-
- template<typename TDst, typename TSrc>
- void write(
- const TSrc* src_value,
- PointerTag);
-
- template<typename TDst, typename TSrc>
- void write(
- const TSrc& src_value,
- ClassTag);
-
- template<typename TDst, typename TSrc, int TCount>
- void write(
- const TSrc (&src_values)[TCount],
- Array1dTag);
-
- template<typename TDst, typename TSrc, int TCount1, int TCount2>
- void write(
- const TSrc (&src_values)[TCount1][TCount2],
- Array2dTag);
-
-
- template<typename TDst, typename TSrc>
- void write(
- const TSrc* src_values,
- int src_count,
- InplaceTag);
-
- template<typename TDst, typename TSrc>
- void write(
- const TSrc* src_values,
- int src_count,
- CastTag);
+ // Tags for dispatching.
+ class BooleanTag
+ {
+ public:
+ };
+ class NumericTag
+ {
+ public:
+ };
+ class PointerTag
+ {
+ public:
+ };
+ class ClassTag
+ {
+ public:
+ };
+ class Array1dTag
+ {
+ public:
+ };
+ class Array2dTag
+ {
+ public:
+ };
+ class InplaceTag
+ {
+ public:
+ };
+ class CastTag
+ {
+ public:
+ };
+
+
+ // If true won't throw an exception when buffer offset is beyond it's size.
+ // Although, no data will be read beyond the buffer.
+ virtual void allow_read_overflow(
+ bool value) = 0;
+
+
+ template<typename TSrc, typename TDst>
+ void read(
+ TDst& dst_value,
+ BooleanTag);
+
+ template<typename TSrc, typename TDst>
+ void read(
+ TDst& dst_value,
+ NumericTag);
+
+ template<typename TSrc, typename TDst>
+ void read(
+ TDst*& dst_value,
+ PointerTag);
+
+ template<typename TSrc, typename TDst>
+ void read(
+ TDst& dst_value,
+ ClassTag);
+
+ template<typename TSrc, typename TDst, int TCount>
+ void read(
+ TDst(&dst_values)[TCount],
+ Array1dTag);
+
+ template<typename TSrc, typename TDst, int TCount1, int TCount2>
+ void read(
+ TDst(&dst_values)[TCount1][TCount2],
+ Array2dTag);
+
+
+ template<typename TSrc, typename TDst>
+ void read(
+ TDst* dst_values,
+ int dst_count,
+ InplaceTag);
+
+ template<typename TSrc, typename TDst>
+ void read(
+ TDst* dst_values,
+ int dst_count,
+ CastTag);
+
+
+ template<typename TDst, typename TSrc>
+ void write(
+ const TSrc& src_value,
+ NumericTag);
+
+ template<typename TDst, typename TSrc>
+ void write(
+ const TSrc* src_value,
+ PointerTag);
+
+ template<typename TDst, typename TSrc>
+ void write(
+ const TSrc& src_value,
+ ClassTag);
+
+ template<typename TDst, typename TSrc, int TCount>
+ void write(
+ const TSrc(&src_values)[TCount],
+ Array1dTag);
+
+ template<typename TDst, typename TSrc, int TCount1, int TCount2>
+ void write(
+ const TSrc(&src_values)[TCount1][TCount2],
+ Array2dTag);
+
+
+ template<typename TDst, typename TSrc>
+ void write(
+ const TSrc* src_values,
+ int src_count,
+ InplaceTag);
+
+ template<typename TDst, typename TSrc>
+ void write(
+ const TSrc* src_values,
+ int src_count,
+ CastTag);
}; // ISavedGame
diff --git a/shared/qcommon/ojk_saved_game.cpp b/shared/qcommon/ojk_saved_game.cpp
index d10cecc..c4a270f 100644
--- a/shared/qcommon/ojk_saved_game.cpp
+++ b/shared/qcommon/ojk_saved_game.cpp
@@ -10,846 +10,857 @@ namespace ojk
SavedGame::SavedGame() :
- file_handle_(),
- io_buffer_(),
- saved_io_buffer_(),
- io_buffer_offset_(),
- saved_io_buffer_offset_(),
- rle_buffer_(),
- is_readable_(),
- is_writable_(),
- is_write_failed_(),
- is_read_overflow_allowed_()
+ file_handle_(),
+ io_buffer_(),
+ saved_io_buffer_(),
+ io_buffer_offset_(),
+ saved_io_buffer_offset_(),
+ rle_buffer_(),
+ is_readable_(),
+ is_writable_(),
+ is_write_failed_(),
+ is_read_overflow_allowed_()
{
}
SavedGame::~SavedGame()
{
- close();
+ close();
}
bool SavedGame::open(
- const std::string& base_file_name)
+ const std::string& base_file_name)
{
- close();
+ close();
- const auto&& file_path = generate_path(
- base_file_name);
+ const auto&& file_path = generate_path(
+ base_file_name);
- auto is_succeed = true;
+ auto is_succeed = true;
- if (is_succeed)
- {
- ::FS_FOpenFileRead(
- file_path.c_str(),
- &file_handle_,
- qtrue);
+ static_cast<void>(::FS_FOpenFileRead(
+ file_path.c_str(),
+ &file_handle_,
+ true));
- if (file_handle_ == 0)
- {
- is_succeed = false;
+ if (file_handle_ == 0)
+ {
+ is_succeed = false;
- const auto&& error_message =
- S_COLOR_RED "Failed to open a saved game file: \"" +
- file_path + "\".";
+ const auto&& error_message =
+ S_COLOR_RED "Failed to open a saved game file: \"" +
+ file_path + "\".";
- ::Com_DPrintf(
- "%s\n",
- error_message.c_str());
- }
- }
+ ::Com_DPrintf(
+ "%s\n",
+ error_message.c_str());
+ }
- if (is_succeed)
- {
- is_readable_ = true;
- }
+ if (is_succeed)
+ {
+ is_readable_ = true;
+ }
- auto sg_version = -1;
+ auto sg_version = -1;
- if (is_succeed)
- {
- static_cast<void>(read_chunk<int32_t>(
- INT_ID('_', 'V', 'E', 'R'),
- sg_version));
+ if (is_succeed)
+ {
+ static_cast<void>(read_chunk<int32_t>(
+ INT_ID('_', 'V', 'E', 'R'),
+ sg_version));
- if (sg_version != iSAVEGAME_VERSION)
- {
- is_succeed = false;
+ if (sg_version != iSAVEGAME_VERSION)
+ {
+ is_succeed = false;
- ::Com_Printf(
- S_COLOR_RED "File \"%s\" has version # %d (expecting %d)\n",
- base_file_name.c_str(),
- sg_version,
- iSAVEGAME_VERSION);
- }
- }
+ ::Com_Printf(
+ S_COLOR_RED "File \"%s\" has version # %d (expecting %d)\n",
+ base_file_name.c_str(),
+ sg_version,
+ iSAVEGAME_VERSION);
+ }
+ }
- if (!is_succeed)
- {
- close();
- }
+ if (!is_succeed)
+ {
+ close();
+ }
- return is_succeed;
+ return is_succeed;
}
bool SavedGame::create(
- const std::string& base_file_name)
+ const std::string& base_file_name)
{
- close();
+ close();
- remove(
- base_file_name);
+ remove(
+ base_file_name);
- const auto&& file_path = generate_path(
- base_file_name);
+ const auto&& file_path = generate_path(
+ base_file_name);
- file_handle_ = ::FS_FOpenFileWrite(
- file_path.c_str());
+ file_handle_ = ::FS_FOpenFileWrite(
+ file_path.c_str());
- if (file_handle_ == 0)
- {
- const auto&& error_message =
- S_COLOR_RED "Failed to create a saved game file: \"" +
- file_path + "\".";
+ if (file_handle_ == 0)
+ {
+ const auto&& error_message =
+ S_COLOR_RED "Failed to create a saved game file: \"" +
+ file_path + "\".";
- ::Com_Printf(
- "%s\n",
- error_message.c_str());
+ ::Com_Printf(
+ "%s\n",
+ error_message.c_str());
- return false;
- }
+ return false;
+ }
- is_writable_ = true;
+ is_writable_ = true;
- const auto sg_version = iSAVEGAME_VERSION;
+ const auto sg_version = iSAVEGAME_VERSION;
- write_chunk<int32_t>(
- INT_ID('_', 'V', 'E', 'R'),
- sg_version);
+ write_chunk<int32_t>(
+ INT_ID('_', 'V', 'E', 'R'),
+ sg_version);
- return true;
+ return true;
}
void SavedGame::close()
{
- if (file_handle_ != 0)
- {
- ::FS_FCloseFile(file_handle_);
- file_handle_ = 0;
- }
+ if (file_handle_ != 0)
+ {
+ ::FS_FCloseFile(file_handle_);
+ file_handle_ = 0;
+ }
- io_buffer_.clear();
- io_buffer_offset_ = 0;
+ io_buffer_.clear();
+ io_buffer_offset_ = 0;
- is_readable_ = false;
- is_writable_ = false;
- is_write_failed_ = false;
+ is_readable_ = false;
+ is_writable_ = false;
+ is_write_failed_ = false;
}
bool SavedGame::is_readable() const
{
- return is_readable_;
+ return is_readable_;
}
bool SavedGame::is_writable() const
{
- return is_writable_;
+ return is_writable_;
}
void SavedGame::read_chunk(
- const SavedGame::ChunkId chunk_id)
+ const SavedGame::ChunkId chunk_id)
{
- io_buffer_offset_ = 0;
+ io_buffer_offset_ = 0;
- const auto&& chunk_id_string = get_chunk_id_string(
- chunk_id);
+ const auto&& chunk_id_string = get_chunk_id_string(
+ chunk_id);
- ::Com_DPrintf(
- "Attempting read of chunk %s\n",
- chunk_id_string.c_str());
+ ::Com_DPrintf(
+ "Attempting read of chunk %s\n",
+ chunk_id_string.c_str());
- uint32_t ulLoadedChid = 0;
- uint32_t uiLoadedLength = 0;
+ uint32_t ulLoadedChid = 0;
+ uint32_t uiLoadedLength = 0;
- auto uiLoaded = ::FS_Read(
- &ulLoadedChid,
- static_cast<int>(sizeof(ulLoadedChid)),
- file_handle_);
+ auto uiLoaded = ::FS_Read(
+ &ulLoadedChid,
+ static_cast<int>(sizeof(ulLoadedChid)),
+ file_handle_);
- uiLoaded += ::FS_Read(
- &uiLoadedLength,
- static_cast<int>(sizeof(uiLoadedLength)),
- file_handle_);
+ uiLoaded += ::FS_Read(
+ &uiLoadedLength,
+ static_cast<int>(sizeof(uiLoadedLength)),
+ file_handle_);
- const auto bBlockIsCompressed = (static_cast<int32_t>(uiLoadedLength) < 0);
+ const auto bBlockIsCompressed = (static_cast<int32_t>(uiLoadedLength) < 0);
- if (bBlockIsCompressed)
- {
- uiLoadedLength = -static_cast<int32_t>(uiLoadedLength);
- }
+ if (bBlockIsCompressed)
+ {
+ uiLoadedLength = -static_cast<int32_t>(uiLoadedLength);
+ }
- // Make sure we are loading the correct chunk...
- //
- if (ulLoadedChid != chunk_id)
- {
- const auto&& loaded_chunk_id_string = get_chunk_id_string(
- ulLoadedChid);
+ // Make sure we are loading the correct chunk...
+ //
+ if (ulLoadedChid != chunk_id)
+ {
+ const auto&& loaded_chunk_id_string = get_chunk_id_string(
+ ulLoadedChid);
- const auto&& error_message =
- "Loaded chunk ID (" +
- loaded_chunk_id_string +
- ") does not match requested chunk ID (" +
- chunk_id_string +
- ").";
+ const auto&& error_message =
+ "Loaded chunk ID (" +
+ loaded_chunk_id_string +
+ ") does not match requested chunk ID (" +
+ chunk_id_string +
+ ").";
- throw_error(
- error_message);
- }
+ throw_error(
+ error_message);
+ }
- uint32_t uiLoadedCksum = 0;
+ uint32_t uiLoadedCksum = 0;
#ifdef JK2_MODE
- // Get checksum...
- //
- uiLoaded += ::FS_Read(
- &uiLoadedCksum,
- static_cast<int>(sizeof(uiLoadedCksum)),
- file_handle_);
+ // Get checksum...
+ //
+ uiLoaded += ::FS_Read(
+ &uiLoadedCksum,
+ static_cast<int>(sizeof(uiLoadedCksum)),
+ file_handle_);
#endif // JK2_MODE
- // Load in data and magic number...
- //
- uint32_t uiCompressedLength = 0;
-
- if (bBlockIsCompressed)
- {
- uiLoaded += ::FS_Read(
- &uiCompressedLength,
- static_cast<int>(sizeof(uiCompressedLength)),
- file_handle_);
-
- rle_buffer_.resize(
- uiCompressedLength);
-
- uiLoaded += ::FS_Read(
- rle_buffer_.data(),
- uiCompressedLength,
- file_handle_);
-
- io_buffer_.resize(
- uiLoadedLength);
-
- decompress(
- rle_buffer_,
- io_buffer_);
- }
- else
- {
- io_buffer_.resize(
- uiLoadedLength);
-
- uiLoaded += ::FS_Read(
- io_buffer_.data(),
- uiLoadedLength,
- file_handle_);
- }
+ // Load in data and magic number...
+ //
+ uint32_t uiCompressedLength = 0;
+
+ if (bBlockIsCompressed)
+ {
+ uiLoaded += ::FS_Read(
+ &uiCompressedLength,
+ static_cast<int>(sizeof(uiCompressedLength)),
+ file_handle_);
+
+ rle_buffer_.resize(
+ uiCompressedLength);
+
+ uiLoaded += ::FS_Read(
+ rle_buffer_.data(),
+ uiCompressedLength,
+ file_handle_);
+
+ io_buffer_.resize(
+ uiLoadedLength);
+
+ decompress(
+ rle_buffer_,
+ io_buffer_);
+ }
+ else
+ {
+ io_buffer_.resize(
+ uiLoadedLength);
+
+ uiLoaded += ::FS_Read(
+ io_buffer_.data(),
+ uiLoadedLength,
+ file_handle_);
+ }
#ifdef JK2_MODE
- uint32_t uiLoadedMagic = 0;
+ uint32_t uiLoadedMagic = 0;
- uiLoaded += ::FS_Read(
- &uiLoadedMagic,
- static_cast<int>(sizeof(uiLoadedMagic)),
- file_handle_);
+ uiLoaded += ::FS_Read(
+ &uiLoadedMagic,
+ static_cast<int>(sizeof(uiLoadedMagic)),
+ file_handle_);
- if (uiLoadedMagic != get_jo_magic_value())
- {
- const auto&& error_message =
- "Bad saved game magic for chunk " + chunk_id_string + ".";
+ if (uiLoadedMagic != get_jo_magic_value())
+ {
+ const auto&& error_message =
+ "Bad saved game magic for chunk " + chunk_id_string + ".";
- throw_error(
- error_message);
- }
+ throw_error(
+ error_message);
+ }
#endif // JK2_MODE
#ifndef JK2_MODE
- // Get checksum...
- //
- uiLoaded += ::FS_Read(
- &uiLoadedCksum,
- static_cast<int>(sizeof(uiLoadedCksum)),
- file_handle_);
+ // Get checksum...
+ //
+ uiLoaded += ::FS_Read(
+ &uiLoadedCksum,
+ static_cast<int>(sizeof(uiLoadedCksum)),
+ file_handle_);
#endif // !JK2_MODE
- // Make sure the checksums match...
- //
- const auto uiCksum = ::Com_BlockChecksum(
- io_buffer_.data(),
- static_cast<int>(io_buffer_.size()));
-
- if (uiLoadedCksum != uiCksum)
- {
- const auto&& error_message =
- "Failed checksum check for chunk " + chunk_id_string + ".";
-
- throw_error(
- error_message);
- }
-
- // Make sure we didn't encounter any read errors...
- if (uiLoaded !=
- sizeof(ulLoadedChid) +
- sizeof(uiLoadedLength) +
- sizeof(uiLoadedCksum) +
- (bBlockIsCompressed ? sizeof(uiCompressedLength) : 0) +
- (bBlockIsCompressed ? uiCompressedLength : io_buffer_.size()) +
+ // Make sure the checksums match...
+ //
+ const auto uiCksum = ::Com_BlockChecksum(
+ io_buffer_.data(),
+ static_cast<int>(io_buffer_.size()));
+
+ if (uiLoadedCksum != uiCksum)
+ {
+ const auto&& error_message =
+ "Failed checksum check for chunk " + chunk_id_string + ".";
+
+ throw_error(
+ error_message);
+ }
+
+ // Make sure we didn't encounter any read errors...
+ if (uiLoaded !=
+ sizeof(ulLoadedChid) +
+ sizeof(uiLoadedLength) +
+ sizeof(uiLoadedCksum) +
+ (bBlockIsCompressed ? sizeof(uiCompressedLength) : 0) +
+ (bBlockIsCompressed ? uiCompressedLength : io_buffer_.size()) +
#ifdef JK2_MODE
- sizeof(uiLoadedMagic) +
+ sizeof(uiLoadedMagic) +
#endif
- 0)
- {
- const auto&& error_message =
- "Error during loading chunk " + chunk_id_string + ".";
+ 0)
+ {
+ const auto&& error_message =
+ "Error during loading chunk " + chunk_id_string + ".";
- throw_error(
- error_message);
- }
+ throw_error(
+ error_message);
+ }
}
bool SavedGame::is_all_data_read() const
{
- return io_buffer_.size() == io_buffer_offset_;
+ return io_buffer_.size() == io_buffer_offset_;
}
void SavedGame::ensure_all_data_read() const
{
- if (!is_all_data_read())
- {
- throw_error(
- "Not all expected data read.");
- }
+ if (!is_all_data_read())
+ {
+ throw_error(
+ "Not all expected data read.");
+ }
}
void SavedGame::write_chunk(
- const SavedGame::ChunkId chunk_id)
+ const SavedGame::ChunkId chunk_id)
{
- const auto&& chunk_id_string = get_chunk_id_string(
- chunk_id);
+ const auto&& chunk_id_string = get_chunk_id_string(
+ chunk_id);
- ::Com_DPrintf(
- "Attempting write of chunk %s\n",
- chunk_id_string.c_str());
+ ::Com_DPrintf(
+ "Attempting write of chunk %s\n",
+ chunk_id_string.c_str());
- if (::sv_testsave->integer != 0)
- {
- return;
- }
+ if (::sv_testsave->integer != 0)
+ {
+ return;
+ }
- const auto src_size = static_cast<int>(io_buffer_.size());
+ const auto src_size = static_cast<int>(io_buffer_.size());
- const auto uiCksum = Com_BlockChecksum(
- io_buffer_.data(),
- src_size);
+ const auto uiCksum = Com_BlockChecksum(
+ io_buffer_.data(),
+ src_size);
- uint32_t uiSaved = ::FS_Write(
- &chunk_id,
- static_cast<int>(sizeof(chunk_id)),
- file_handle_);
+ uint32_t uiSaved = ::FS_Write(
+ &chunk_id,
+ static_cast<int>(sizeof(chunk_id)),
+ file_handle_);
-#ifdef JK2_MODE
- uiSaved += ::FS_Write(
- &uiCksum,
- static_cast<int>(sizeof(uiCksum)),
- file_handle_);
-#endif // JK2_MODE
+#ifndef JK2_MODE
+ uiSaved += ::FS_Write(
+ &uiCksum,
+ static_cast<int>(sizeof(uiCksum)),
+ file_handle_);
+#endif // !JK2_MODE
- auto iCompressedLength = -1;
+ auto iCompressedLength = -1;
- if (::sv_compress_saved_games->integer != 0)
- {
- compress(
- io_buffer_,
- rle_buffer_);
+ if (::sv_compress_saved_games->integer != 0)
+ {
+ compress(
+ io_buffer_,
+ rle_buffer_);
- if (rle_buffer_.size() < io_buffer_.size())
- {
- iCompressedLength = static_cast<int>(rle_buffer_.size());
- }
- }
+ if (rle_buffer_.size() < io_buffer_.size())
+ {
+ iCompressedLength = static_cast<int>(rle_buffer_.size());
+ }
+ }
#ifdef JK2_MODE
- const auto uiMagic = get_jo_magic_value();
+ const auto uiMagic = get_jo_magic_value();
#endif // JK2_MODE
- if (iCompressedLength > 0)
- {
- const auto iLength = -static_cast<int>(io_buffer_.size());
+ if (iCompressedLength > 0)
+ {
+ const auto iLength = -static_cast<int>(io_buffer_.size());
- uiSaved += ::FS_Write(
- &iLength,
- static_cast<int>(sizeof(iLength)),
- file_handle_);
+ uiSaved += ::FS_Write(
+ &iLength,
+ static_cast<int>(sizeof(iLength)),
+ file_handle_);
- uiSaved += ::FS_Write(
- &iCompressedLength,
- static_cast<int>(sizeof(iCompressedLength)),
- file_handle_);
+#ifdef JK2_MODE
+ uiSaved += ::FS_Write(
+ &uiCksum,
+ static_cast<int>(sizeof(uiCksum)),
+ file_handle_);
+#endif // JK2_MODE
- uiSaved += ::FS_Write(
- rle_buffer_.data(),
- iCompressedLength,
- file_handle_);
+ uiSaved += ::FS_Write(
+ &iCompressedLength,
+ static_cast<int>(sizeof(iCompressedLength)),
+ file_handle_);
+
+ uiSaved += ::FS_Write(
+ rle_buffer_.data(),
+ iCompressedLength,
+ file_handle_);
#ifdef JK2_MODE
- uiSaved += ::FS_Write(
- &uiMagic,
- static_cast<int>(sizeof(uiMagic)),
- file_handle_);
+ uiSaved += ::FS_Write(
+ &uiMagic,
+ static_cast<int>(sizeof(uiMagic)),
+ file_handle_);
#endif // JK2_MODE
#ifndef JK2_MODE
- uiSaved += ::FS_Write(
- &uiCksum,
- static_cast<int>(sizeof(uiCksum)),
- file_handle_);
+ uiSaved += ::FS_Write(
+ &uiCksum,
+ static_cast<int>(sizeof(uiCksum)),
+ file_handle_);
#endif // !JK2_MODE
- if (uiSaved !=
- sizeof(chunk_id) +
- sizeof(iLength) +
- sizeof(uiCksum) +
- sizeof(iCompressedLength) +
- iCompressedLength +
+ if (uiSaved !=
+ sizeof(chunk_id) +
+ sizeof(iLength) +
+ sizeof(uiCksum) +
+ sizeof(iCompressedLength) +
+ iCompressedLength +
#ifdef JK2_MODE
- sizeof(uiMagic) +
+ sizeof(uiMagic) +
#endif // JK2_MODE
- 0)
- {
- is_write_failed_ = true;
-
- ::Com_Printf(
- S_COLOR_RED "Failed to write %s chunk\n",
- chunk_id_string.c_str());
-
- return;
- }
- }
- else
- {
- const auto iLength = static_cast<uint32_t>(io_buffer_.size());
-
- uiSaved += ::FS_Write(
- &iLength,
- static_cast<int>(sizeof(iLength)),
- file_handle_);
-
- uiSaved += ::FS_Write(
- io_buffer_.data(),
- iLength,
- file_handle_);
+ 0)
+ {
+ is_write_failed_ = true;
+
+ ::Com_Printf(
+ S_COLOR_RED "Failed to write %s chunk\n",
+ chunk_id_string.c_str());
+
+ return;
+ }
+ }
+ else
+ {
+ const auto iLength = static_cast<uint32_t>(io_buffer_.size());
+
+ uiSaved += ::FS_Write(
+ &iLength,
+ static_cast<int>(sizeof(iLength)),
+ file_handle_);
#ifdef JK2_MODE
- uiSaved += ::FS_Write(
- &uiMagic,
- static_cast<int>(sizeof(uiMagic)),
- file_handle_);
+ uiSaved += ::FS_Write(
+ &uiCksum,
+ static_cast<int>(sizeof(uiCksum)),
+ file_handle_);
#endif // JK2_MODE
+ uiSaved += ::FS_Write(
+ io_buffer_.data(),
+ iLength,
+ file_handle_);
+
#ifdef JK2_MODE
- uiSaved += ::FS_Write(
- &uiCksum,
- static_cast<int>(sizeof(uiCksum)),
- file_handle_);
+ uiSaved += ::FS_Write(
+ &uiMagic,
+ static_cast<int>(sizeof(uiMagic)),
+ file_handle_);
#endif // JK2_MODE
- if (uiSaved !=
- sizeof(chunk_id) +
- sizeof(iLength) +
- sizeof(uiCksum) +
- iLength +
+#ifndef JK2_MODE
+ uiSaved += ::FS_Write(
+ &uiCksum,
+ static_cast<int>(sizeof(uiCksum)),
+ file_handle_);
+#endif // !JK2_MODE
+
+ if (uiSaved !=
+ sizeof(chunk_id) +
+ sizeof(iLength) +
+ sizeof(uiCksum) +
+ iLength +
#ifdef JK2_MODE
- sizeof(uiMagic) +
+ sizeof(uiMagic) +
#endif // JK2_MODE
- 0)
- {
- is_write_failed_ = true;
+ 0)
+ {
+ is_write_failed_ = true;
- ::Com_Printf(
- S_COLOR_RED "Failed to write %s chunk\n",
- chunk_id_string.c_str());
+ ::Com_Printf(
+ S_COLOR_RED "Failed to write %s chunk\n",
+ chunk_id_string.c_str());
- return;
- }
- }
+ return;
+ }
+ }
}
void SavedGame::raw_read(
- void* dst_data,
- int dst_size)
-{
- if (!dst_data)
- {
- throw_error(
- "Null pointer.");
- }
-
- if (dst_size < 0)
- {
- throw_error(
- "Negative size.");
- }
-
- if (!is_readable_)
- {
- throw_error(
- "Not readable.");
- }
-
- if (dst_size == 0)
- {
- return;
- }
-
- auto is_overflowed = ((io_buffer_offset_ + dst_size) > io_buffer_.size());
-
- if (is_overflowed)
- {
- if (!is_read_overflow_allowed_)
- {
- throw_error(
- "Not enough data.");
- }
- }
-
- if (!is_overflowed)
- {
- std::uninitialized_copy_n(
- &io_buffer_[io_buffer_offset_],
- dst_size,
- static_cast<uint8_t*>(dst_data));
- }
-
- io_buffer_offset_ += dst_size;
+ void* dst_data,
+ int dst_size)
+{
+ if (!dst_data)
+ {
+ throw_error(
+ "Null pointer.");
+ }
+
+ if (dst_size < 0)
+ {
+ throw_error(
+ "Negative size.");
+ }
+
+ if (!is_readable_)
+ {
+ throw_error(
+ "Not readable.");
+ }
+
+ if (dst_size == 0)
+ {
+ return;
+ }
+
+ auto is_overflowed = ((io_buffer_offset_ + dst_size) > io_buffer_.size());
+
+ if (is_overflowed)
+ {
+ if (!is_read_overflow_allowed_)
+ {
+ throw_error(
+ "Not enough data.");
+ }
+ }
+
+ if (!is_overflowed)
+ {
+ std::uninitialized_copy_n(
+ &io_buffer_[io_buffer_offset_],
+ dst_size,
+ static_cast<uint8_t*>(dst_data));
+ }
+
+ io_buffer_offset_ += dst_size;
}
void SavedGame::raw_write(
- const void* src_data,
- int src_size)
+ const void* src_data,
+ int src_size)
{
- if (!src_data)
- {
- throw_error(
- "Null pointer.");
- }
+ if (!src_data)
+ {
+ throw_error(
+ "Null pointer.");
+ }
- if (src_size < 0)
- {
- throw_error(
- "Negative size.");
- }
+ if (src_size < 0)
+ {
+ throw_error(
+ "Negative size.");
+ }
- if (!is_writable_)
- {
- throw_error(
- "Not writable.");
- }
+ if (!is_writable_)
+ {
+ throw_error(
+ "Not writable.");
+ }
- if (src_size == 0)
- {
- return;
- }
+ if (src_size == 0)
+ {
+ return;
+ }
- const auto new_buffer_size = io_buffer_offset_ + src_size;
+ const auto new_buffer_size = io_buffer_offset_ + src_size;
- io_buffer_.resize(
- new_buffer_size);
+ io_buffer_.resize(
+ new_buffer_size);
- std::uninitialized_copy_n(
- static_cast<const uint8_t*>(src_data),
- src_size,
- &io_buffer_[io_buffer_offset_]);
+ std::uninitialized_copy_n(
+ static_cast<const uint8_t*>(src_data),
+ src_size,
+ &io_buffer_[io_buffer_offset_]);
- io_buffer_offset_ = new_buffer_size;
+ io_buffer_offset_ = new_buffer_size;
}
bool SavedGame::is_write_failed() const
{
- return is_write_failed_;
+ return is_write_failed_;
}
void SavedGame::skip(
- int count)
-{
- if (!is_readable_ && !is_writable_)
- {
- throw_error(
- "Not open or created.");
- }
-
- if (count < 0)
- {
- throw_error(
- "Negative count.");
- }
-
- if (count == 0)
- {
- return;
- }
-
- const auto new_offset = io_buffer_offset_ + count;
- const auto buffer_size = io_buffer_.size();
-
- if (new_offset > buffer_size)
- {
- if (is_readable_)
- {
- throw_error(
- "Not enough data.");
- }
- else if (is_writable_)
- {
- if (new_offset > buffer_size)
- {
- io_buffer_.resize(
- new_offset);
- }
- }
- }
-
- io_buffer_offset_ = new_offset;
+ int count)
+{
+ if (!is_readable_ && !is_writable_)
+ {
+ throw_error(
+ "Not open or created.");
+ }
+
+ if (count < 0)
+ {
+ throw_error(
+ "Negative count.");
+ }
+
+ if (count == 0)
+ {
+ return;
+ }
+
+ const auto new_offset = io_buffer_offset_ + count;
+ const auto buffer_size = io_buffer_.size();
+
+ if (new_offset > buffer_size)
+ {
+ if (is_readable_)
+ {
+ throw_error(
+ "Not enough data.");
+ }
+ else if (is_writable_)
+ {
+ if (new_offset > buffer_size)
+ {
+ io_buffer_.resize(
+ new_offset);
+ }
+ }
+ }
+
+ io_buffer_offset_ = new_offset;
}
void SavedGame::save_buffer()
{
- saved_io_buffer_ = io_buffer_;
- saved_io_buffer_offset_ = io_buffer_offset_;
+ saved_io_buffer_ = io_buffer_;
+ saved_io_buffer_offset_ = io_buffer_offset_;
}
void SavedGame::load_buffer()
{
- io_buffer_ = saved_io_buffer_;
- io_buffer_offset_ = saved_io_buffer_offset_;
+ io_buffer_ = saved_io_buffer_;
+ io_buffer_offset_ = saved_io_buffer_offset_;
}
const void* SavedGame::get_buffer_data() const
{
- return io_buffer_.data();
+ return io_buffer_.data();
}
int SavedGame::get_buffer_size() const
{
- return static_cast<int>(io_buffer_.size());
+ return static_cast<int>(io_buffer_.size());
}
void SavedGame::rename(
- const std::string& old_base_file_name,
- const std::string& new_base_file_name)
+ const std::string& old_base_file_name,
+ const std::string& new_base_file_name)
{
- const auto&& old_path = generate_path(
- old_base_file_name);
+ const auto&& old_path = generate_path(
+ old_base_file_name);
- const auto&& new_path = generate_path(
- new_base_file_name);
+ const auto&& new_path = generate_path(
+ new_base_file_name);
- const auto rename_result = ::FS_MoveUserGenFile(
- old_path.c_str(),
- new_path.c_str());
+ const auto rename_result = ::FS_MoveUserGenFile(
+ old_path.c_str(),
+ new_path.c_str());
- if (rename_result == 0)
- {
- ::Com_Printf(
- S_COLOR_RED "Error during savegame-rename."
- " Check \"%s\" for write-protect or disk full!\n",
- new_path.c_str());
- }
+ if (rename_result == 0)
+ {
+ ::Com_Printf(
+ S_COLOR_RED "Error during savegame-rename."
+ " Check \"%s\" for write-protect or disk full!\n",
+ new_path.c_str());
+ }
}
void SavedGame::remove(
- const std::string& base_file_name)
+ const std::string& base_file_name)
{
- const auto&& path = generate_path(
- base_file_name);
+ const auto&& path = generate_path(
+ base_file_name);
- ::FS_DeleteUserGenFile(
- path.c_str());
+ ::FS_DeleteUserGenFile(
+ path.c_str());
}
SavedGame& SavedGame::get_instance()
{
- static SavedGame result;
- return result;
+ static SavedGame result;
+ return result;
}
void SavedGame::allow_read_overflow(
- bool value)
+ bool value)
{
- is_read_overflow_allowed_ = value;
+ is_read_overflow_allowed_ = value;
}
void SavedGame::throw_error(
- const char* message)
+ const char* message)
{
- throw SavedGameException(
- message);
+ throw SavedGameException(
+ message);
}
void SavedGame::throw_error(
- const std::string& message)
+ const std::string& message)
{
- throw SavedGameException(
- message);
+ throw SavedGameException(
+ message);
}
void SavedGame::compress(
- const Buffer& src_buffer,
- Buffer& dst_buffer)
-{
- const auto src_size = static_cast<int>(src_buffer.size());
-
- dst_buffer.resize(2 * src_size);
-
- auto src_count = 0;
- auto dst_index = 0;
-
- while (src_count < src_size)
- {
- auto src_index = src_count;
- auto b = src_buffer[src_index++];
-
- while (src_index < src_size &&
- (src_index - src_count) < 127 &&
- src_buffer[src_index] == b)
- {
- src_index += 1;
- }
-
- if ((src_index - src_count) == 1)
- {
- while (src_index < src_size &&
- (src_index - src_count) < 127 && (
- src_buffer[src_index] != src_buffer[src_index - 1] || (
- src_index > 1 &&
- src_buffer[src_index] != src_buffer[src_index - 2])))
- {
- src_index += 1;
- }
-
- while (src_index < src_size &&
- src_buffer[src_index] == src_buffer[src_index - 1])
- {
- src_index -= 1;
- }
-
- dst_buffer[dst_index++] =
- static_cast<uint8_t>(src_count - src_index);
-
- for (auto i = src_count; i < src_index; ++i)
- {
- dst_buffer[dst_index++] = src_buffer[i];
- }
- }
- else
- {
- dst_buffer[dst_index++] =
- static_cast<uint8_t>(src_index - src_count);
-
- dst_buffer[dst_index++] = b;
- }
-
- src_count = src_index;
- }
-
- dst_buffer.resize(
- dst_index);
+ const Buffer& src_buffer,
+ Buffer& dst_buffer)
+{
+ const auto src_size = static_cast<int>(src_buffer.size());
+
+ dst_buffer.resize(2 * src_size);
+
+ auto src_count = 0;
+ auto dst_index = 0;
+
+ while (src_count < src_size)
+ {
+ auto src_index = src_count;
+ auto b = src_buffer[src_index++];
+
+ while (src_index < src_size &&
+ (src_index - src_count) < 127 &&
+ src_buffer[src_index] == b)
+ {
+ src_index += 1;
+ }
+
+ if ((src_index - src_count) == 1)
+ {
+ while (src_index < src_size &&
+ (src_index - src_count) < 127 && (
+ src_buffer[src_index] != src_buffer[src_index - 1] || (
+ src_index > 1 &&
+ src_buffer[src_index] != src_buffer[src_index - 2])))
+ {
+ src_index += 1;
+ }
+
+ while (src_index < src_size &&
+ src_buffer[src_index] == src_buffer[src_index - 1])
+ {
+ src_index -= 1;
+ }
+
+ dst_buffer[dst_index++] =
+ static_cast<uint8_t>(src_count - src_index);
+
+ for (auto i = src_count; i < src_index; ++i)
+ {
+ dst_buffer[dst_index++] = src_buffer[i];
+ }
+ }
+ else
+ {
+ dst_buffer[dst_index++] =
+ static_cast<uint8_t>(src_index - src_count);
+
+ dst_buffer[dst_index++] = b;
+ }
+
+ src_count = src_index;
+ }
+
+ dst_buffer.resize(
+ dst_index);
}
void SavedGame::decompress(
- const Buffer& src_buffer,
- Buffer& dst_buffer)
+ const Buffer& src_buffer,
+ Buffer& dst_buffer)
{
- auto src_index = 0;
- auto dst_index = 0;
+ auto src_index = 0;
+ auto dst_index = 0;
- auto remain_size = static_cast<int>(dst_buffer.size());
+ auto remain_size = static_cast<int>(dst_buffer.size());
- while (remain_size > 0)
- {
- auto count = static_cast<int8_t>(src_buffer[src_index++]);
+ while (remain_size > 0)
+ {
+ auto count = static_cast<int8_t>(src_buffer[src_index++]);
- if (count > 0)
- {
- std::uninitialized_fill_n(
- &dst_buffer[dst_index],
- count,
- src_buffer[src_index++]);
- }
- else
- {
- if (count < 0)
- {
- count = -count;
+ if (count > 0)
+ {
+ std::uninitialized_fill_n(
+ &dst_buffer[dst_index],
+ count,
+ src_buffer[src_index++]);
+ }
+ else
+ {
+ if (count < 0)
+ {
+ count = -count;
- std::uninitialized_copy_n(
- &src_buffer[src_index],
- count,
- &dst_buffer[dst_index]);
+ std::uninitialized_copy_n(
+ &src_buffer[src_index],
+ count,
+ &dst_buffer[dst_index]);
- src_index += count;
- }
- }
+ src_index += count;
+ }
+ }
- dst_index += count;
- remain_size -= count;
- }
+ dst_index += count;
+ remain_size -= count;
+ }
}
std::string SavedGame::generate_path(
- const std::string& base_file_name)
+ const std::string& base_file_name)
{
- auto normalized_file_name = base_file_name;
+ auto normalized_file_name = base_file_name;
- std::replace(
- normalized_file_name.begin(),
- normalized_file_name.end(),
- '/',
- '_');
+ std::replace(
+ normalized_file_name.begin(),
+ normalized_file_name.end(),
+ '/',
+ '_');
- auto&& path = "saves/" + normalized_file_name + ".sav";
+ auto&& path = "saves/" + normalized_file_name + ".sav";
- return path;
+ return path;
}
std::string SavedGame::get_chunk_id_string(
- uint32_t chunk_id)
+ uint32_t chunk_id)
{
- std::string result(4, '\0');
+ std::string result(4, '\0');
- result[0] = static_cast<char>((chunk_id >> 24) & 0xFF);
- result[1] = static_cast<char>((chunk_id >> 16) & 0xFF);
- result[2] = static_cast<char>((chunk_id >> 8) & 0xFF);
- result[3] = static_cast<char>((chunk_id >> 0) & 0xFF);
+ result[0] = static_cast<char>((chunk_id >> 24) & 0xFF);
+ result[1] = static_cast<char>((chunk_id >> 16) & 0xFF);
+ result[2] = static_cast<char>((chunk_id >> 8) & 0xFF);
+ result[3] = static_cast<char>((chunk_id >> 0) & 0xFF);
- return result;
+ return result;
}
void SavedGame::reset_buffer()
{
- io_buffer_.clear();
- reset_buffer_offset();
+ io_buffer_.clear();
+ reset_buffer_offset();
}
void SavedGame::reset_buffer_offset()
{
- io_buffer_offset_ = 0;
+ io_buffer_offset_ = 0;
}
constexpr uint32_t SavedGame::get_jo_magic_value()
{
- return 0x1234ABCD;
+ return 0x1234ABCD;
}
diff --git a/shared/qcommon/ojk_saved_game.h b/shared/qcommon/ojk_saved_game.h
index 8b5a9b6..6e874a4 100644
--- a/shared/qcommon/ojk_saved_game.h
+++ b/shared/qcommon/ojk_saved_game.h
@@ -19,193 +19,193 @@ namespace ojk
class SavedGame :
- public ISavedGame
+ public ISavedGame
{
public:
- using ChunkId = uint32_t;
+ using ChunkId = uint32_t;
- SavedGame();
+ SavedGame();
- SavedGame(
- const SavedGame& that) = delete;
+ SavedGame(
+ const SavedGame& that) = delete;
- SavedGame& operator=(
- const SavedGame& that) = delete;
+ SavedGame& operator=(
+ const SavedGame& that) = delete;
- virtual ~SavedGame();
+ virtual ~SavedGame();
- // Creates a new saved game file for writing.
- bool create(
- const std::string& base_file_name);
+ // Creates a new saved game file for writing.
+ bool create(
+ const std::string& base_file_name);
- // Opens an existing saved game file for reading.
- bool open(
- const std::string& base_file_name);
+ // Opens an existing saved game file for reading.
+ bool open(
+ const std::string& base_file_name);
- // Closes the current saved game file.
- void close();
+ // Closes the current saved game file.
+ void close();
- // Returns true if the saved game opened for reading.
- bool is_readable() const override;
+ // Returns true if the saved game opened for reading.
+ bool is_readable() const override;
- // Returns true if the saved game opened for writing.
- bool is_writable() const override;
+ // Returns true if the saved game opened for writing.
+ bool is_writable() const override;
- // Reads a chunk from the file into the internal buffer.
- void read_chunk(
- const ChunkId chunk_id) override;
+ // Reads a chunk from the file into the internal buffer.
+ void read_chunk(
+ const ChunkId chunk_id) override;
- using ISavedGame::read_chunk;
+ using ISavedGame::read_chunk;
- // Returns true if all data read from the internal buffer.
- bool is_all_data_read() const override;
+ // Returns true if all data read from the internal buffer.
+ bool is_all_data_read() const override;
- // Throws an exception if all data not read.
- void ensure_all_data_read() const override;
+ // Throws an exception if all data not read.
+ void ensure_all_data_read() const override;
- // Writes a chunk into the file from the internal buffer.
- void write_chunk(
- const ChunkId chunk_id) override;
+ // Writes a chunk into the file from the internal buffer.
+ void write_chunk(
+ const ChunkId chunk_id) override;
- using ISavedGame::write_chunk;
+ using ISavedGame::write_chunk;
- // Reads a raw data from the internal buffer.
- void raw_read(
- void* dst_data,
- int dst_size) override;
+ // Reads a raw data from the internal buffer.
+ void raw_read(
+ void* dst_data,
+ int dst_size) override;
- using ISavedGame::read;
+ using ISavedGame::read;
- // Writes a raw data into the internal buffer.
- void raw_write(
- const void* src_data,
- int src_size) override;
+ // Writes a raw data into the internal buffer.
+ void raw_write(
+ const void* src_data,
+ int src_size) override;
- using ISavedGame::write;
+ using ISavedGame::write;
- bool is_write_failed() const;
+ bool is_write_failed() const;
- // Increments buffer's offset by the specified non-negative count.
- void skip(
- int count) override;
+ // Increments buffer's offset by the specified non-negative count.
+ void skip(
+ int count) override;
- // Stores current I/O buffer and it's position.
- void save_buffer() override;
+ // Stores current I/O buffer and it's position.
+ void save_buffer() override;
- // Restores saved I/O buffer and it's position.
- void load_buffer() override;
+ // Restores saved I/O buffer and it's position.
+ void load_buffer() override;
- // Returns a pointer to data in the I/O buffer.
- const void* get_buffer_data() const override;
+ // Returns a pointer to data in the I/O buffer.
+ const void* get_buffer_data() const override;
- // Returns a current size of the I/O buffer.
- int get_buffer_size() const override;
+ // Returns a current size of the I/O buffer.
+ int get_buffer_size() const override;
- // Clears buffer and resets it's offset to the beginning.
- void reset_buffer() override;
+ // Clears buffer and resets it's offset to the beginning.
+ void reset_buffer() override;
- // Resets buffer offset to the beginning.
- void reset_buffer_offset() override;
+ // Resets buffer offset to the beginning.
+ void reset_buffer_offset() override;
- // Renames a saved game file.
- static void rename(
- const std::string& old_base_file_name,
- const std::string& new_base_file_name);
+ // Renames a saved game file.
+ static void rename(
+ const std::string& old_base_file_name,
+ const std::string& new_base_file_name);
- // Remove a saved game file.
- static void remove(
- const std::string& base_file_name);
+ // Remove a saved game file.
+ static void remove(
+ const std::string& base_file_name);
- // Returns a default instance of the class.
- static SavedGame& get_instance();
+ // Returns a default instance of the class.
+ static SavedGame& get_instance();
protected:
- // If true won't throw an exception when buffer offset is beyond it's size.
- // Although, no data will be read beyond the buffer.
- void allow_read_overflow(
- bool value) override;
+ // If true won't throw an exception when buffer offset is beyond it's size.
+ // Although, no data will be read beyond the buffer.
+ void allow_read_overflow(
+ bool value) override;
private:
- using Buffer = std::vector<uint8_t>;
- using BufferOffset = Buffer::size_type;
- using Paths = std::vector<std::string>;
+ using Buffer = std::vector<uint8_t>;
+ using BufferOffset = Buffer::size_type;
+ using Paths = std::vector<std::string>;
- // A handle to a file.
- int32_t file_handle_;
+ // A handle to a file.
+ int32_t file_handle_;
- // I/O buffer.
- Buffer io_buffer_;
+ // I/O buffer.
+ Buffer io_buffer_;
- // Saved copy of the I/O buffer.
- Buffer saved_io_buffer_;
+ // Saved copy of the I/O buffer.
+ Buffer saved_io_buffer_;
- // A current offset inside the I/O buffer.
- BufferOffset io_buffer_offset_;
+ // A current offset inside the I/O buffer.
+ BufferOffset io_buffer_offset_;
- // Saved I/O buffer offset.
- BufferOffset saved_io_buffer_offset_;
+ // Saved I/O buffer offset.
+ BufferOffset saved_io_buffer_offset_;
- // RLE codec buffer.
- Buffer rle_buffer_;
+ // RLE codec buffer.
+ Buffer rle_buffer_;
- // True if saved game opened for reading.
- bool is_readable_;
+ // True if saved game opened for reading.
+ bool is_readable_;
- // True if saved game opened for writing.
- bool is_writable_;
+ // True if saved game opened for writing.
+ bool is_writable_;
- // True if any previous write operation failed.
- bool is_write_failed_;
+ // True if any previous write operation failed.
+ bool is_write_failed_;
- // Controls exception throw on read overflow.
- bool is_read_overflow_allowed_;
+ // Controls exception throw on read overflow.
+ bool is_read_overflow_allowed_;
- // Throws an exception.
- static void throw_error(
- const char* message);
+ // Throws an exception.
+ static void throw_error(
+ const char* message);
- // Throws an exception.
- static void throw_error(
- const std::string& message);
+ // Throws an exception.
+ static void throw_error(
+ const std::string& message);
- // Compresses data.
- static void compress(
- const Buffer& src_buffer,
- Buffer& dst_buffer);
+ // Compresses data.
+ static void compress(
+ const Buffer& src_buffer,
+ Buffer& dst_buffer);
- // Decompresses data.
- static void decompress(
- const Buffer& src_buffer,
- Buffer& dst_buffer);
+ // Decompresses data.
+ static void decompress(
+ const Buffer& src_buffer,
+ Buffer& dst_buffer);
- static std::string generate_path(
- const std::string& base_file_name);
+ static std::string generate_path(
+ const std::string& base_file_name);
- // Returns a string representation of a chunk id.
- static std::string get_chunk_id_string(
- uint32_t chunk_id);
+ // Returns a string representation of a chunk id.
+ static std::string get_chunk_id_string(
+ uint32_t chunk_id);
- static constexpr uint32_t get_jo_magic_value();
+ static constexpr uint32_t get_jo_magic_value();
}; // SavedGame
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-games/openjk.git
More information about the Pkg-games-commits
mailing list