mirror of https://github.com/OpenTTD/OpenTTD.git
Codechange: Use a SmallVec for the animated tile list instead of replicating most of the logic.
This commit is contained in:
parent
4851feb102
commit
7dd6027194
|
@ -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<TileIndex, 256> _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<TileIndex>(_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<TileIndex>(_animated_tile_list, 256);
|
||||
_animated_tile_count = 0;
|
||||
_animated_tile_allocated = 256;
|
||||
_animated_tiles.Clear();
|
||||
}
|
||||
|
|
|
@ -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<TileIndex, 256> _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++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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<TileIndex, 256> _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<TileIndex>(_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);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -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<TileIndex, 256> _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;
|
||||
|
|
Loading…
Reference in New Issue