diff --git a/src/animated_tile.cpp b/src/animated_tile.cpp index 78dda8b3b6..796c5f5e09 100644 --- a/src/animated_tile.cpp +++ b/src/animated_tile.cpp @@ -11,17 +11,14 @@ #include "stdafx.h" #include "core/alloc_func.hpp" +#include "core/smallvec_type.hpp" #include "tile_cmd.h" #include "viewport_func.h" #include "safeguards.h" /** The table/list with animated tiles. */ -TileIndex *_animated_tile_list = NULL; -/** The number of animated tiles in the current state. */ -uint _animated_tile_count = 0; -/** The number of slots for animated tiles allocated currently. */ -uint _animated_tile_allocated = 0; +SmallVector _animated_tiles; /** * Removes the given tile from the animated tile table. @@ -29,17 +26,11 @@ uint _animated_tile_allocated = 0; */ void DeleteAnimatedTile(TileIndex tile) { - for (TileIndex *ti = _animated_tile_list; ti < _animated_tile_list + _animated_tile_count; ti++) { - if (tile == *ti) { - /* Remove the hole - * The order of the remaining elements must stay the same, otherwise the animation loop - * may miss a tile; that's why we must use memmove instead of just moving the last element. - */ - memmove(ti, ti + 1, (_animated_tile_list + _animated_tile_count - (ti + 1)) * sizeof(*ti)); - _animated_tile_count--; - MarkTileDirtyByTile(tile); - return; - } + TileIndex *to_remove = _animated_tiles.Find(tile); + if (to_remove != _animated_tiles.End()) { + /* The order of the remaining elements must stay the same, otherwise the animation loop may miss a tile. */ + _animated_tiles.ErasePreservingOrder(to_remove); + MarkTileDirtyByTile(tile); } } @@ -51,19 +42,7 @@ void DeleteAnimatedTile(TileIndex tile) void AddAnimatedTile(TileIndex tile) { MarkTileDirtyByTile(tile); - - for (const TileIndex *ti = _animated_tile_list; ti < _animated_tile_list + _animated_tile_count; ti++) { - if (tile == *ti) return; - } - - /* Table not large enough, so make it larger */ - if (_animated_tile_count == _animated_tile_allocated) { - _animated_tile_allocated *= 2; - _animated_tile_list = ReallocT(_animated_tile_list, _animated_tile_allocated); - } - - _animated_tile_list[_animated_tile_count] = tile; - _animated_tile_count++; + _animated_tiles.Include(tile); } /** @@ -71,8 +50,8 @@ void AddAnimatedTile(TileIndex tile) */ void AnimateAnimatedTiles() { - const TileIndex *ti = _animated_tile_list; - while (ti < _animated_tile_list + _animated_tile_count) { + const TileIndex *ti = _animated_tiles.Begin(); + while (ti < _animated_tiles.End()) { const TileIndex curr = *ti; AnimateTile(curr); /* During the AnimateTile call, DeleteAnimatedTile could have been called, @@ -93,7 +72,5 @@ void AnimateAnimatedTiles() */ void InitializeAnimatedTiles() { - _animated_tile_list = ReallocT(_animated_tile_list, 256); - _animated_tile_count = 0; - _animated_tile_allocated = 256; + _animated_tiles.Clear(); } diff --git a/src/saveload/afterload.cpp b/src/saveload/afterload.cpp index d5d9bc3a48..f01afb425d 100644 --- a/src/saveload/afterload.cpp +++ b/src/saveload/afterload.cpp @@ -2157,22 +2157,21 @@ bool AfterLoadGame() /* Animated tiles would sometimes not be actually animated or * in case of old savegames duplicate. */ - extern TileIndex *_animated_tile_list; - extern uint _animated_tile_count; + extern SmallVector _animated_tiles; - for (uint i = 0; i < _animated_tile_count; /* Nothing */) { + for (TileIndex *tile = _animated_tiles.Begin(); tile < _animated_tiles.End(); /* Nothing */) { /* Remove if tile is not animated */ - bool remove = _tile_type_procs[GetTileType(_animated_tile_list[i])]->animate_tile_proc == NULL; + bool remove = _tile_type_procs[GetTileType(*tile)]->animate_tile_proc == NULL; /* and remove if duplicate */ - for (uint j = 0; !remove && j < i; j++) { - remove = _animated_tile_list[i] == _animated_tile_list[j]; + for (TileIndex *j = _animated_tiles.Begin(); !remove && j < tile; j++) { + remove = *tile == *j; } if (remove) { - DeleteAnimatedTile(_animated_tile_list[i]); + DeleteAnimatedTile(*tile); } else { - i++; + tile++; } } } diff --git a/src/saveload/animated_tile_sl.cpp b/src/saveload/animated_tile_sl.cpp index 3fc5f61753..2152c42e34 100644 --- a/src/saveload/animated_tile_sl.cpp +++ b/src/saveload/animated_tile_sl.cpp @@ -12,22 +12,21 @@ #include "../stdafx.h" #include "../tile_type.h" #include "../core/alloc_func.hpp" +#include "../core/smallvec_type.hpp" #include "saveload.h" #include "../safeguards.h" -extern TileIndex *_animated_tile_list; -extern uint _animated_tile_count; -extern uint _animated_tile_allocated; +extern SmallVector _animated_tiles; /** * Save the ANIT chunk. */ static void Save_ANIT() { - SlSetLength(_animated_tile_count * sizeof(*_animated_tile_list)); - SlArray(_animated_tile_list, _animated_tile_count, SLE_UINT32); + SlSetLength(_animated_tiles.Length() * sizeof(*_animated_tiles.Begin())); + SlArray(_animated_tiles.Begin(), _animated_tiles.Length(), SLE_UINT32); } /** @@ -38,22 +37,20 @@ static void Load_ANIT() /* Before version 80 we did NOT have a variable length animated tile table */ if (IsSavegameVersionBefore(80)) { /* In pre version 6, we has 16bit per tile, now we have 32bit per tile, convert it ;) */ - SlArray(_animated_tile_list, 256, IsSavegameVersionBefore(6) ? (SLE_FILE_U16 | SLE_VAR_U32) : SLE_UINT32); + TileIndex anim_list[256]; + SlArray(anim_list, 256, IsSavegameVersionBefore(6) ? (SLE_FILE_U16 | SLE_VAR_U32) : SLE_UINT32); - for (_animated_tile_count = 0; _animated_tile_count < 256; _animated_tile_count++) { - if (_animated_tile_list[_animated_tile_count] == 0) break; + for (int i = 0; i < 256; i++) { + if (anim_list[i] == 0) break; + *_animated_tiles.Append() = anim_list[i]; } return; } - _animated_tile_count = (uint)SlGetFieldLength() / sizeof(*_animated_tile_list); - - /* Determine a nice rounded size for the amount of allocated tiles */ - _animated_tile_allocated = 256; - while (_animated_tile_allocated < _animated_tile_count) _animated_tile_allocated *= 2; - - _animated_tile_list = ReallocT(_animated_tile_list, _animated_tile_allocated); - SlArray(_animated_tile_list, _animated_tile_count, SLE_UINT32); + uint count = (uint)SlGetFieldLength() / sizeof(*_animated_tiles.Begin()); + _animated_tiles.Clear(); + _animated_tiles.Append(count); + SlArray(_animated_tiles.Begin(), count, SLE_UINT32); } /** diff --git a/src/saveload/oldloader_sl.cpp b/src/saveload/oldloader_sl.cpp index 0c57166816..61a5aa5c6d 100644 --- a/src/saveload/oldloader_sl.cpp +++ b/src/saveload/oldloader_sl.cpp @@ -28,6 +28,7 @@ #include "../engine_func.h" #include "../company_base.h" #include "../disaster_vehicle.h" +#include "../core/smallvec_type.hpp" #include "saveload_internal.h" #include "oldloader.h" @@ -490,8 +491,7 @@ static inline uint RemapOrderIndex(uint x) return _savegame_type == SGT_TTO ? (x - 0x1AC4) / 2 : (x - 0x1C18) / 2; } -extern TileIndex *_animated_tile_list; -extern uint _animated_tile_count; +extern SmallVector _animated_tiles; extern char *_old_name_array; static uint32 _old_town_index; @@ -640,22 +640,18 @@ static bool LoadOldOrder(LoadgameState *ls, int num) static bool LoadOldAnimTileList(LoadgameState *ls, int num) { - /* This is slightly hackish - we must load a chunk into an array whose - * address isn't static, but instead pointed to by _animated_tile_list. - * To achieve that, create an OldChunks list on the stack on the fly. - * The list cannot be static because the value of _animated_tile_list - * can change between calls. */ - + TileIndex anim_list[256]; const OldChunks anim_chunk[] = { - OCL_VAR ( OC_TILE, 256, _animated_tile_list ), + OCL_VAR ( OC_TILE, 256, anim_list ), OCL_END () }; if (!LoadChunk(ls, NULL, anim_chunk)) return false; - /* Update the animated tile counter by counting till the first zero in the array */ - for (_animated_tile_count = 0; _animated_tile_count < 256; _animated_tile_count++) { - if (_animated_tile_list[_animated_tile_count] == 0) break; + /* The first zero in the loaded array indicates the end of the list. */ + for (int i = 0; i < 256; i++) { + if (anim_list[i] == 0) break; + *_animated_tiles.Append() = anim_list[i]; } return true;