From 3fb4003534dd66e7909568069e117438f88638b8 Mon Sep 17 00:00:00 2001 From: belugas Date: Tue, 15 May 2007 21:36:58 +0000 Subject: (svn r9850) -Codechange: Introduction of the Override/Substitute manager. Currently only used for newhouses. Basically, it is more a gathering of IDs from grf files and ingame data. --- src/newgrf_commons.cpp | 150 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 src/newgrf_commons.cpp (limited to 'src/newgrf_commons.cpp') diff --git a/src/newgrf_commons.cpp b/src/newgrf_commons.cpp new file mode 100644 index 000000000..f52c1442a --- /dev/null +++ b/src/newgrf_commons.cpp @@ -0,0 +1,150 @@ +/* $Id$ */ + +/** @file newgrf_commons.cpp Implementation of the class OverrideManagerBase + * and its descendance, present and futur + */ + +#include "stdafx.h" +#include "openttd.h" +#include "town.h" +#include "industry.h" +#include "newgrf.h" +#include "newgrf_commons.h" + +/** Constructor of generic class + * @param offset end of original data for this entity. i.e: houses = 110 + * @param maximum of entities this manager can deal with. i.e: houses = 512 + * @param invalid is the ID used to identify an invalid entity id + */ +OverrideManagerBase::OverrideManagerBase(uint16 offset, uint16 maximum, uint16 invalid) +{ + max_offset = offset; + max_new_entities = maximum; + invalid_ID = invalid; + + mapping_ID = CallocT(max_new_entities); + entity_overrides = MallocT(max_offset); + memset(entity_overrides, invalid, sizeof(entity_overrides)); +} + +/** Destructor of the generic class. + * Frees allocated memory of constructor + */ +OverrideManagerBase::~OverrideManagerBase() +{ + free(mapping_ID); + free(entity_overrides); +} + +/** Since the entity IDs defined by the GRF file does not necessarily correlate + * to those used by the game, the IDs used for overriding old entities must be + * translated when the entity spec is set. + * @param local_id id in grf file + * @param entity_type original entity type + */ +void OverrideManagerBase::Add(uint8 local_id, uint entity_type) +{ + assert(entity_type < max_offset); + entity_overrides[entity_type] = local_id; +} + +/** Resets the mapping, which is used while initializing game */ +void OverrideManagerBase::ResetMapping() +{ + memset(mapping_ID, 0, (max_new_entities - 1) * sizeof(EntityIDMapping)); +} + +/** Resets the override, which is used while initializing game */ +void OverrideManagerBase::ResetOverride() +{ + for (uint16 i = 0; i < max_offset; i++) { + entity_overrides[i] = invalid_ID; + } +} + +/** Return the ID (if ever available) of a previously inserted entity. + * @param grf_local_id ID of this enity withing the grfID + * @param grfid ID of the grf file + * @return the ID of the candidate, of the Invalid flag item ID + */ +uint16 OverrideManagerBase::GetID(uint8 grf_local_id, uint32 grfid) +{ + const EntityIDMapping *map; + + for (uint16 id = max_offset; id < max_new_entities; id++) { + map = &mapping_ID[id]; + if (map->entity_id == grf_local_id && map->grfid == grfid) { + return id; + } + } + return invalid_ID; +} + +/** Reserves a place in the mapping array for an entity to be installed + * @param grf_local_id is an arbitrary id given by the grf's author. Also known as setid + * @param grfid is the id of the grf file itself + * @param substitute_id is the original entity from which data is copied for the new one + * @return the proper usable slot id, or invalid marker if none is found + */ +uint16 OverrideManagerBase::AddEntityID(byte grf_local_id, uint32 grfid, byte substitute_id) +{ + uint16 id = this->GetID(grf_local_id, grfid); + EntityIDMapping *map; + + /* Look to see if this entity has already been added. This is done + * separately from the loop below in case a GRF has been deleted, and there + * are any gaps in the array. + */ + if (id != invalid_ID) { + return id; + } + + /* This entity hasn't been defined before, so give it an ID now. */ + for (id = max_offset; id < max_new_entities; id++) { + map = &mapping_ID[id]; + + if (map->entity_id == 0 && map->grfid == 0) { + map->entity_id = grf_local_id; + map->grfid = grfid; + map->substitute_id = substitute_id; + return id; + } + } + + return invalid_ID; +} + +/** Gives the substitute of the entity, as specified by the grf file + * @param entity_id of the entity being queried + * @return mapped id + */ +uint16 OverrideManagerBase::GetSubstituteID(byte entity_id) +{ + return mapping_ID[entity_id].substitute_id; +} + +/** Install the specs into the HouseSpecs array + * It will find itself the proper slot onwhich it will go + * @param hs HouseSpec read from the grf file, ready for inclusion + */ +void HouseOverrideManager::SetEntitySpec(const HouseSpec *hs) +{ + HouseID house_id = this->AddEntityID(hs->local_id, hs->grffile->grfid, hs->substitute_id); + + if (house_id == invalid_ID) { + grfmsg(1, "House.SetEntitySpec: Too many houses allocated. Ignoring."); + return; + } + + memcpy(&_house_specs[house_id], hs, sizeof(*hs)); + + /* Now add the overrides. */ + for (int i = 0; i != max_offset; i++) { + HouseSpec *overridden_hs = GetHouseSpecs(i); + + if (entity_overrides[i] != hs->local_id) continue; + + overridden_hs->override = house_id; + entity_overrides[i] = invalid_ID; + } +} -- cgit v1.2.3-54-g00ecf