/* The house being overridden must be an original house. */

				if (override >= NEW_HOUSE_OFFSET) {

					grfmsg(2, "TownHouseChangeInfo: Attempt to override new house %u with house id %u. Ignoring.", override, hid + i);

					continue;

				}

			} break;

			case 0x16: // Periodic refresh multiplier

				housespec->processing_time = grf_load_byte(&buf);

				break;

				/* The industry being overridden must be an original industry. */

				if (ovrid >= NEW_INDUSTRYTILEOFFSET) {

					grfmsg(2, "IndustryTilesChangeInfo: Attempt to override new industry tile %u with industry tile id %u. Ignoring.", ovrid, indtid + i);

					return false;

				}

			} break;

			case 0x0A: // Tile acceptance

			case 0x0B:

			case 0x0C: {

				uint16 acctp = grf_load_word(&buf);

				/* The industry being overridden must be an original industry. */

				if (ovrid >= NEW_INDUSTRYOFFSET) {

					grfmsg(2, "IndustriesChangeInfo: Attempt to override new industry %u with industry id %u. Ignoring.", ovrid, indid + i);

					return false;

				}

				indsp->grf_prop.override = ovrid;

			} break;

			case 0x0A: { // Set industry layout(s)

				indsp->num_table = grf_load_byte(&buf); // Number of layaouts

				uint32 defsize = grf_load_dword(&buf);  // Total size of the definition

				IndustryTileTable **tile_table = CallocT<IndustryTileTable*>(indsp->num_table); // Table with tiles to compose an industry

	max_new_entities = maximum;

	invalid_ID = invalid;

	mapping_ID = CallocT<EntityIDMapping>(max_new_entities);

	entity_overrides = MallocT<uint16>(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 entity_type original 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

	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);

		overridden_hs->override = house_id;

		entity_overrides[i] = invalid_ID;

	}

}

/** Method to find an entity ID and to mark it as reserved for the Industry to be included.

 * @param grf_local_id ID used by the grf file for pre-installation work (equivalent of TTDPatch's setid

 * @param grfid ID of the current grf file

	memcpy(&_industry_tile_specs[indt_id], its, sizeof(*its));

	/* Now add the overrides. */

	for (int i = 0; i < max_offset; i++) {

		IndustryTileSpec *overridden_its = &_industry_tile_specs[i];

		overridden_its->grf_prop.override = indt_id;

		overridden_its->enabled = false;

		entity_overrides[i] = invalid_ID;

	}

}

/** Function used by houses (and soon industries) to get information

 * on type of "terrain" the tile it is queries sits on.

 * @param tile TileIndex of the tile been queried

	uint8  substitute_id;  ///< The (original) entity ID to use if this GRF is not available

};

class OverrideManagerBase {

protected:

	uint16 *entity_overrides;

	uint16 max_offset;       ///< what is the length of the original entity's array of specs

	uint16 max_new_entities; ///< what is the amount of entities, old and new summed

	uint16 invalid_ID;       ///< ID used to dected invalid entities;

	virtual bool CheckValidNewID(uint16 testid) { return true; }

	OverrideManagerBase(uint16 offset, uint16 maximum, uint16 invalid);

	virtual ~OverrideManagerBase();

	void ResetOverride();

	void ResetMapping();

	virtual uint16 AddEntityID(byte grf_local_id, uint32 grfid, byte substitute_id);

	uint16 GetSubstituteID(byte entity_id);

	uint16 GetID(uint8 grf_local_id, uint32 grfid);

	inline uint16 GetMaxMapping() { return max_new_entities; }