animated_tile.cpp

Go to the documentation of this file.

/* $Id: animated_tile.cpp 13301 2008-05-27 21:41:00Z rubidium $ */

#include "stdafx.h"
#include "openttd.h"
#include "saveload.h"
#include "landscape.h"
#include "core/alloc_func.hpp"
#include "functions.h"

TileIndex *_animated_tile_list = NULL;
uint _animated_tile_count = 0;
static 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;
    }
  }
}

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++;
}

void AnimateAnimatedTiles()
{
  const TileIndex *ti = _animated_tile_list;
  while (ti < _animated_tile_list + _animated_tile_count) {
    const TileIndex curr = *ti;
    AnimateTile(curr);
    /* During the AnimateTile call, DeleteAnimatedTile could have been called,
     * deleting an element we've already processed and pushing the rest one
     * slot to the left. We can detect this by checking whether the index
     * in the current slot has changed - if it has, an element has been deleted,
     * and we should process the current slot again instead of going forward.
     * NOTE: this will still break if more than one animated tile is being
     *       deleted during the same AnimateTile call, but no code seems to
     *       be doing this anyway.
     */
    if (*ti == curr) ++ti;
  }
}

void InitializeAnimatedTiles()
{
  _animated_tile_list = ReallocT<TileIndex>(_animated_tile_list, 256);
  _animated_tile_count = 0;
  _animated_tile_allocated = 256;
}

static void Save_ANIT()
{
  SlSetLength(_animated_tile_count * sizeof(*_animated_tile_list));
  SlArray(_animated_tile_list, _animated_tile_count, SLE_UINT32);
}

static void Load_ANIT()
{
  /* Before version 80 we did NOT have a variable length animated tile table */
  if (CheckSavegameVersion(80)) {
    /* In pre version 6, we has 16bit per tile, now we have 32bit per tile, convert it ;) */
    SlArray(_animated_tile_list, 256, CheckSavegameVersion(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;
    }
    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);
}

extern const ChunkHandler _animated_tile_chunk_handlers[] = {
  { 'ANIT', Save_ANIT, Load_ANIT, CH_RIFF | CH_LAST},
};