You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
226 lines
6.8 KiB
C++
226 lines
6.8 KiB
C++
9 years ago
|
/*
|
||
|
* This file is part of OpenTTD.
|
||
|
* OpenTTD 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, version 2.
|
||
|
* OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
|
||
|
*/
|
||
|
|
||
|
/** @file tracerestrict_sl.cpp Code handling saving and loading of trace restrict programs */
|
||
|
|
||
|
#include "../stdafx.h"
|
||
|
#include "../tracerestrict.h"
|
||
9 years ago
|
#include "../strings_func.h"
|
||
|
#include "../string_func.h"
|
||
9 years ago
|
#include "saveload.h"
|
||
|
#include <vector>
|
||
|
|
||
|
static const SaveLoad _trace_restrict_mapping_desc[] = {
|
||
|
SLE_VAR(TraceRestrictMappingItem, program_id, SLE_UINT32),
|
||
|
};
|
||
|
|
||
9 years ago
|
/**
|
||
|
* Load mappings
|
||
|
*/
|
||
9 years ago
|
static void Load_TRRM()
|
||
|
{
|
||
|
int index;
|
||
|
while ((index = SlIterateArray()) != -1) {
|
||
|
TraceRestrictMappingItem &item = _tracerestrictprogram_mapping[index];
|
||
|
SlObject(&item, _trace_restrict_mapping_desc);
|
||
|
}
|
||
|
}
|
||
|
|
||
9 years ago
|
/**
|
||
|
* Save mappings
|
||
|
*/
|
||
9 years ago
|
static void Save_TRRM()
|
||
|
{
|
||
|
for (TraceRestrictMapping::iterator iter = _tracerestrictprogram_mapping.begin();
|
||
|
iter != _tracerestrictprogram_mapping.end(); ++iter) {
|
||
|
SlSetArrayIndex(iter->first);
|
||
|
SlObject(&(iter->second), _trace_restrict_mapping_desc);
|
||
|
}
|
||
|
}
|
||
|
|
||
9 years ago
|
/** program length save header struct */
|
||
9 years ago
|
struct TraceRestrictProgramStub {
|
||
|
uint32 length;
|
||
|
};
|
||
|
|
||
|
static const SaveLoad _trace_restrict_program_stub_desc[] = {
|
||
|
SLE_VAR(TraceRestrictProgramStub, length, SLE_UINT32),
|
||
|
};
|
||
|
|
||
9 years ago
|
/**
|
||
|
* Load program pool
|
||
|
*/
|
||
9 years ago
|
static void Load_TRRP()
|
||
|
{
|
||
|
int index;
|
||
|
TraceRestrictProgramStub stub;
|
||
|
while ((index = SlIterateArray()) != -1) {
|
||
|
TraceRestrictProgram *prog = new (index) TraceRestrictProgram();
|
||
|
SlObject(&stub, _trace_restrict_program_stub_desc);
|
||
|
prog->items.resize(stub.length);
|
||
3 years ago
|
if (stub.length > 0) SlArray(prog->items.data(), stub.length, SLE_UINT32);
|
||
5 years ago
|
if (SlXvIsFeaturePresent(XSLFI_JOKERPP)) {
|
||
|
for (size_t i = 0; i < prog->items.size(); i++) {
|
||
|
TraceRestrictItem &item = prog->items[i]; // note this is a reference,
|
||
|
if (GetTraceRestrictType(item) == 19 || GetTraceRestrictType(item) == 20) {
|
||
|
SetTraceRestrictType(item, (TraceRestrictItemType)(GetTraceRestrictType(item) + 2));
|
||
|
}
|
||
|
if (IsTraceRestrictDoubleItem(item)) i++;
|
||
|
}
|
||
|
}
|
||
9 years ago
|
CommandCost validation_result = prog->Validate();
|
||
|
if (validation_result.Failed()) {
|
||
|
char str[4096];
|
||
|
char *strend = str + seprintf(str, lastof(str), "Trace restrict program %d: %s\nProgram dump:",
|
||
|
index, GetStringPtr(validation_result.GetErrorMessage()));
|
||
1 year ago
|
uint fail_offset = validation_result.HasResultData() ? validation_result.GetResultData() : UINT32_MAX;
|
||
2 years ago
|
for (uint i = 0; i < (uint)prog->items.size(); i++) {
|
||
|
if ((i % 3) == 0) {
|
||
|
strend += seprintf(strend, lastof(str), "\n%4u:", i);
|
||
9 years ago
|
}
|
||
2 years ago
|
strend += seprintf(strend, lastof(str), (i == fail_offset) ? " [%08X]" : " %08X", prog->items[i]);
|
||
9 years ago
|
}
|
||
|
SlErrorCorrupt(str);
|
||
|
}
|
||
9 years ago
|
}
|
||
|
}
|
||
|
|
||
9 years ago
|
/**
|
||
|
* Save a program, used by SlAutolength
|
||
|
*/
|
||
9 years ago
|
static void RealSave_TRRP(TraceRestrictProgram *prog)
|
||
|
{
|
||
|
TraceRestrictProgramStub stub;
|
||
3 years ago
|
stub.length = (uint32)prog->items.size();
|
||
9 years ago
|
SlObject(&stub, _trace_restrict_program_stub_desc);
|
||
3 years ago
|
SlArray(prog->items.data(), stub.length, SLE_UINT32);
|
||
9 years ago
|
}
|
||
|
|
||
9 years ago
|
/**
|
||
|
* Save program pool
|
||
|
*/
|
||
9 years ago
|
static void Save_TRRP()
|
||
|
{
|
||
5 years ago
|
for (TraceRestrictProgram *prog : TraceRestrictProgram::Iterate()) {
|
||
9 years ago
|
SlSetArrayIndex(prog->index);
|
||
|
SlAutolength((AutolengthProc*) RealSave_TRRP, prog);
|
||
|
}
|
||
|
}
|
||
|
|
||
8 years ago
|
/** program length save header struct */
|
||
|
struct TraceRestrictSlotStub {
|
||
|
uint32 length;
|
||
|
};
|
||
|
|
||
|
static const SaveLoad _trace_restrict_slot_stub_desc[] = {
|
||
|
SLE_VAR(TraceRestrictSlotStub, length, SLE_UINT32),
|
||
|
};
|
||
|
|
||
|
static const SaveLoad _trace_restrict_slot_desc[] = {
|
||
|
SLE_VAR(TraceRestrictSlot, max_occupancy, SLE_UINT32),
|
||
4 years ago
|
SLE_SSTR(TraceRestrictSlot, name, SLF_ALLOW_CONTROL),
|
||
8 years ago
|
SLE_VAR(TraceRestrictSlot, owner, SLE_UINT8),
|
||
3 years ago
|
SLE_CONDVAR_X(TraceRestrictSlot, vehicle_type, SLE_UINT8, SL_MIN_VERSION, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_TRACE_RESTRICT, 13)),
|
||
8 years ago
|
};
|
||
|
|
||
|
/**
|
||
|
* Load slot pool
|
||
|
*/
|
||
|
static void Load_TRRS()
|
||
|
{
|
||
|
int index;
|
||
|
TraceRestrictSlotStub stub;
|
||
|
while ((index = SlIterateArray()) != -1) {
|
||
|
TraceRestrictSlot *slot = new (index) TraceRestrictSlot();
|
||
|
SlObject(slot, _trace_restrict_slot_desc);
|
||
|
SlObject(&stub, _trace_restrict_slot_stub_desc);
|
||
|
slot->occupants.resize(stub.length);
|
||
3 years ago
|
if (stub.length) SlArray(slot->occupants.data(), stub.length, SLE_UINT32);
|
||
8 years ago
|
}
|
||
|
TraceRestrictSlot::RebuildVehicleIndex();
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Save a slot, used by SlAutolength
|
||
|
*/
|
||
|
static void RealSave_TRRS(TraceRestrictSlot *slot)
|
||
|
{
|
||
|
SlObject(slot, _trace_restrict_slot_desc);
|
||
|
TraceRestrictSlotStub stub;
|
||
3 years ago
|
stub.length = (uint32)slot->occupants.size();
|
||
8 years ago
|
SlObject(&stub, _trace_restrict_slot_stub_desc);
|
||
3 years ago
|
if (stub.length) SlArray(slot->occupants.data(), stub.length, SLE_UINT32);
|
||
8 years ago
|
}
|
||
|
|
||
|
/**
|
||
|
* Save slot pool
|
||
|
*/
|
||
|
static void Save_TRRS()
|
||
|
{
|
||
5 years ago
|
for (TraceRestrictSlot *slot : TraceRestrictSlot::Iterate()) {
|
||
8 years ago
|
SlSetArrayIndex(slot->index);
|
||
|
SlAutolength((AutolengthProc*) RealSave_TRRS, slot);
|
||
|
}
|
||
|
}
|
||
|
|
||
4 years ago
|
static const SaveLoad _trace_restrict_counter_desc[] = {
|
||
|
SLE_VAR(TraceRestrictCounter, value, SLE_INT32),
|
||
|
SLE_SSTR(TraceRestrictCounter, name, SLF_ALLOW_CONTROL),
|
||
|
SLE_VAR(TraceRestrictCounter, owner, SLE_UINT8),
|
||
|
};
|
||
|
|
||
|
/**
|
||
|
* Load counter pool
|
||
|
*/
|
||
|
static void Load_TRRC()
|
||
|
{
|
||
|
int index;
|
||
|
while ((index = SlIterateArray()) != -1) {
|
||
|
TraceRestrictCounter *ctr = new (index) TraceRestrictCounter();
|
||
|
SlObject(ctr, _trace_restrict_counter_desc);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Save a counter, used by SlAutolength
|
||
|
*/
|
||
|
static void RealSave_TRRC(TraceRestrictCounter *ctr)
|
||
|
{
|
||
|
SlObject(ctr, _trace_restrict_counter_desc);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Save counter pool
|
||
|
*/
|
||
|
static void Save_TRRC()
|
||
|
{
|
||
|
for (TraceRestrictCounter *ctr : TraceRestrictCounter::Iterate()) {
|
||
|
SlSetArrayIndex(ctr->index);
|
||
|
SlAutolength((AutolengthProc*) RealSave_TRRC, ctr);
|
||
|
}
|
||
|
}
|
||
|
|
||
9 years ago
|
/**
|
||
|
* Update program reference counts from just-loaded mapping
|
||
|
*/
|
||
9 years ago
|
void AfterLoadTraceRestrict()
|
||
|
{
|
||
|
for (TraceRestrictMapping::iterator iter = _tracerestrictprogram_mapping.begin();
|
||
|
iter != _tracerestrictprogram_mapping.end(); ++iter) {
|
||
2 years ago
|
_tracerestrictprogram_pool.Get(iter->second.program_id)->IncrementRefCount(iter->first);
|
||
9 years ago
|
}
|
||
|
}
|
||
|
|
||
3 years ago
|
extern const ChunkHandler trace_restrict_chunk_handlers[] = {
|
||
|
{ 'TRRM', Save_TRRM, Load_TRRM, nullptr, nullptr, CH_SPARSE_ARRAY }, // Trace Restrict Mapping chunk
|
||
|
{ 'TRRP', Save_TRRP, Load_TRRP, nullptr, nullptr, CH_ARRAY }, // Trace Restrict Mapping Program Pool chunk
|
||
|
{ 'TRRS', Save_TRRS, Load_TRRS, nullptr, nullptr, CH_ARRAY }, // Trace Restrict Slot Pool chunk
|
||
|
{ 'TRRC', Save_TRRC, Load_TRRC, nullptr, nullptr, CH_ARRAY }, // Trace Restrict Counter Pool chunk
|
||
9 years ago
|
};
|
||
3 years ago
|
|
||
|
extern const ChunkHandlerTable _trace_restrict_chunk_handlers(trace_restrict_chunk_handlers);
|