industry_cmd.cpp

Go to the documentation of this file.

/* $Id: industry_cmd.cpp 14562 2008-11-03 20:23:51Z frosch $ */

#include "stdafx.h"
#include "openttd.h"
#include "clear_map.h"
#include "industry_map.h"
#include "station_map.h"
#include "train.h"
#include "landscape.h"
#include "viewport_func.h"
#include "command_func.h"
#include "industry.h"
#include "town.h"
#include "news_func.h"
#include "saveload.h"
#include "variables.h"
#include "cheat_func.h"
#include "genworld.h"
#include "water_map.h"
#include "tree_map.h"
#include "cargotype.h"
#include "newgrf.h"
#include "newgrf_commons.h"
#include "newgrf_industries.h"
#include "newgrf_industrytiles.h"
#include "newgrf_callbacks.h"
#include "autoslope.h"
#include "transparency.h"
#include "water.h"
#include "strings_func.h"
#include "tile_cmd.h"
#include "functions.h"
#include "window_func.h"
#include "date_func.h"
#include "vehicle_func.h"
#include "sound_func.h"
#include "station_base.h"
#include "oldpool_func.h"
#include "animated_tile_func.h"
#include "effectvehicle_func.h"

#include "table/strings.h"
#include "table/sprites.h"
#include "table/industry_land.h"
#include "table/build_industry.h"

void ShowIndustryViewWindow(int industry);
void BuildOilRig(TileIndex tile);

static byte _industry_sound_ctr;
static TileIndex _industry_sound_tile;

int _total_industries;                      //general counter
uint16 _industry_counts[NUM_INDUSTRYTYPES]; // Number of industries per type ingame

IndustrySpec _industry_specs[NUM_INDUSTRYTYPES];
IndustryTileSpec _industry_tile_specs[NUM_INDUSTRYTILES];

void ResetIndustries()
{
  memset(&_industry_specs, 0, sizeof(_industry_specs));
  memcpy(&_industry_specs, &_origin_industry_specs, sizeof(_origin_industry_specs));

  /* once performed, enable only the current climate industries */
  for (IndustryType i = 0; i < NUM_INDUSTRYTYPES; i++) {
    _industry_specs[i].enabled = i < NEW_INDUSTRYOFFSET &&
        HasBit(_origin_industry_specs[i].climate_availability, _settings_game.game_creation.landscape);
  }

  memset(&_industry_tile_specs, 0, sizeof(_industry_tile_specs));
  memcpy(&_industry_tile_specs, &_origin_industry_tile_specs, sizeof(_origin_industry_tile_specs));

  /* Reset any overrides that have been set. */
  _industile_mngr.ResetOverride();
  _industry_mngr.ResetOverride();
}

void ResetIndustryCreationProbility(IndustryType type)
{
  assert(type < INVALID_INDUSTRYTYPE);
  _industry_specs[type].appear_creation[_settings_game.game_creation.landscape] = 0;
}

DEFINE_OLD_POOL_GENERIC(Industry, Industry)


IndustryType GetIndustryType(TileIndex tile)
{
  assert(IsTileType(tile, MP_INDUSTRY));

  const Industry *ind = GetIndustryByTile(tile);
  return ind->IsValid() ? ind->type : (IndustryType)IT_INVALID;
}

const IndustrySpec *GetIndustrySpec(IndustryType thistype)
{
  assert(thistype < NUM_INDUSTRYTYPES);
  return &_industry_specs[thistype];
}

const IndustryTileSpec *GetIndustryTileSpec(IndustryGfx gfx)
{
  assert(gfx < INVALID_INDUSTRYTILE);
  return &_industry_tile_specs[gfx];
}

Industry::~Industry()
{
  if (CleaningPool()) return;

  /* Industry can also be destroyed when not fully initialized.
   * This means that we do not have to clear tiles either. */
  if (this->width == 0) {
    this->xy = 0;
    return;
  }

  BEGIN_TILE_LOOP(tile_cur, this->width, this->height, this->xy);
    if (IsTileType(tile_cur, MP_INDUSTRY)) {
      if (GetIndustryIndex(tile_cur) == this->index) {
        /* MakeWaterKeepingClass() can also handle 'land' */
        MakeWaterKeepingClass(tile_cur, OWNER_NONE);
      }
    } else if (IsTileType(tile_cur, MP_STATION) && IsOilRig(tile_cur)) {
      DeleteOilRig(tile_cur);
    }
  END_TILE_LOOP(tile_cur, this->width, this->height, this->xy);

  if (GetIndustrySpec(this->type)->behaviour & INDUSTRYBEH_PLANT_FIELDS) {
    /* Remove the farmland and convert it to regular tiles over time. */
    BEGIN_TILE_LOOP(tile_cur, 42, 42, this->xy - TileDiffXY(21, 21)) {
      tile_cur = TILE_MASK(tile_cur);
      if (IsTileType(tile_cur, MP_CLEAR) && IsClearGround(tile_cur, CLEAR_FIELDS) &&
          GetIndustryIndexOfField(tile_cur) == this->index) {
        SetIndustryIndexOfField(tile_cur, INVALID_INDUSTRY);
      }
    } END_TILE_LOOP(tile_cur, 42, 42, this->xy - TileDiff(21, 21))
  }

  DecIndustryTypeCount(this->type);

  DeleteSubsidyWithIndustry(this->index);
  DeleteWindowById(WC_INDUSTRY_VIEW, this->index);
  InvalidateWindowData(WC_INDUSTRY_DIRECTORY, 0, 0);
  this->xy = 0;
}

static void IndustryDrawSugarMine(const TileInfo *ti)
{
  const DrawIndustryAnimationStruct *d;

  if (!IsIndustryCompleted(ti->tile)) return;

  d = &_draw_industry_spec1[GetIndustryAnimationState(ti->tile)];

  AddChildSpriteScreen(SPR_IT_SUGAR_MINE_SIEVE + d->image_1, PAL_NONE, d->x, 0);

  if (d->image_2 != 0) {
    AddChildSpriteScreen(SPR_IT_SUGAR_MINE_CLOUDS + d->image_2 - 1, PAL_NONE, 8, 41);
  }

  if (d->image_3 != 0) {
    AddChildSpriteScreen(SPR_IT_SUGAR_MINE_PILE + d->image_3 - 1, PAL_NONE,
      _drawtile_proc1[d->image_3 - 1].x, _drawtile_proc1[d->image_3 - 1].y);
  }
}

static void IndustryDrawToffeeQuarry(const TileInfo *ti)
{
  uint8 x = 0;

  if (IsIndustryCompleted(ti->tile)) {
    x = _industry_anim_offs_toffee[GetIndustryAnimationState(ti->tile)];
    if (x == 0xFF)
      x = 0;
  }

  AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_SHOVEL, PAL_NONE, 22 - x, 24 + x);
  AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, PAL_NONE, 6, 14);
}

static void IndustryDrawBubbleGenerator( const TileInfo *ti)
{
  if (IsIndustryCompleted(ti->tile)) {
    AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_BUBBLE, PAL_NONE, 5, _industry_anim_offs_bubbles[GetIndustryAnimationState(ti->tile)]);
  } else {
    AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, PAL_NONE, 3, 67);
  }
}

static void IndustryDrawToyFactory(const TileInfo *ti)
{
  const DrawIndustryAnimationStruct *d;

  d = &_industry_anim_offs_toys[GetIndustryAnimationState(ti->tile)];

  if (d->image_1 != 0xFF) {
    AddChildSpriteScreen(SPR_IT_TOY_FACTORY_CLAY, PAL_NONE, d->x, 96 + d->image_1);
  }

  if (d->image_2 != 0xFF) {
    AddChildSpriteScreen(SPR_IT_TOY_FACTORY_ROBOT, PAL_NONE, 16 - d->image_2 * 2, 100 + d->image_2);
  }

  AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP, PAL_NONE, 7, d->image_3);
  AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, PAL_NONE, 0, 42);
}

static void IndustryDrawCoalPlantSparks(const TileInfo *ti)
{
  if (IsIndustryCompleted(ti->tile)) {
    uint8 image = GetIndustryAnimationState(ti->tile);

    if (image != 0 && image < 7) {
      AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,
        PAL_NONE,
        _coal_plant_sparks[image - 1].x,
        _coal_plant_sparks[image - 1].y
      );
    }
  }
}

typedef void IndustryDrawTileProc(const TileInfo *ti);
static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {
  IndustryDrawSugarMine,
  IndustryDrawToffeeQuarry,
  IndustryDrawBubbleGenerator,
  IndustryDrawToyFactory,
  IndustryDrawCoalPlantSparks,
};

static void DrawTile_Industry(TileInfo *ti)
{
  IndustryGfx gfx = GetIndustryGfx(ti->tile);
  Industry *ind = GetIndustryByTile(ti->tile);
  const IndustryTileSpec *indts = GetIndustryTileSpec(gfx);
  const DrawBuildingsTileStruct *dits;
  SpriteID image;
  SpriteID pal;

  /* Retrieve pointer to the draw industry tile struct */
  if (gfx >= NEW_INDUSTRYTILEOFFSET) {
    /* Draw the tile using the specialized method of newgrf industrytile.
     * DrawNewIndustry will return false if ever the resolver could not
     * find any sprite to display.  So in this case, we will jump on the
     * substitute gfx instead. */
    if (indts->grf_prop.spritegroup != NULL && DrawNewIndustryTile(ti, ind, gfx, indts)) {
      return;
    } else {
      /* No sprite group (or no valid one) found, meaning no graphics associated.
       * Use the substitute one instead */
      if (indts->grf_prop.subst_id != INVALID_INDUSTRYTILE) {
        gfx = indts->grf_prop.subst_id;
        /* And point the industrytile spec accordingly */
        indts = GetIndustryTileSpec(gfx);
      }
    }
  }

  dits = &_industry_draw_tile_data[gfx << 2 | (indts->anim_state ?
      GetIndustryAnimationState(ti->tile) & INDUSTRY_COMPLETED :
      GetIndustryConstructionStage(ti->tile))];

  image = dits->ground.sprite;
  if (HasBit(image, PALETTE_MODIFIER_COLOR) && dits->ground.pal == PAL_NONE) {
    pal = GENERAL_SPRITE_COLOR(ind->random_color);
  } else {
    pal = dits->ground.pal;
  }

  /* DrawFoundation() modifes ti->z and ti->tileh */
  if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);

  /* If the ground sprite is the default flat water sprite, draw also canal/river borders.
   * Do not do this if the tile's WaterClass is 'land'. */
  if (image == SPR_FLAT_WATER_TILE && IsIndustryTileOnWater(ti->tile)) {
    DrawWaterClassGround(ti);
  } else {
    DrawGroundSprite(image, pal);
  }

  /* If industries are transparent and invisible, do not draw the upper part */
  if (IsInvisibilitySet(TO_INDUSTRIES)) return;

  /* Add industry on top of the ground? */
  image = dits->building.sprite;
  if (image != 0) {
    AddSortableSpriteToDraw(image,
      (HasBit(image, PALETTE_MODIFIER_COLOR) && dits->building.pal == PAL_NONE) ? GENERAL_SPRITE_COLOR(ind->random_color) : dits->building.pal,
      ti->x + dits->subtile_x,
      ti->y + dits->subtile_y,
      dits->width,
      dits->height,
      dits->dz,
      ti->z,
      IsTransparencySet(TO_INDUSTRIES));

    if (IsTransparencySet(TO_INDUSTRIES)) return;
  }

  {
    int proc = dits->draw_proc - 1;
    if (proc >= 0) _industry_draw_tile_procs[proc](ti);
  }
}

static uint GetSlopeZ_Industry(TileIndex tile, uint x, uint y)
{
  return GetTileMaxZ(tile);
}

static Foundation GetFoundation_Industry(TileIndex tile, Slope tileh)
{
  IndustryGfx gfx = GetIndustryGfx(tile);

  /* For NewGRF industry tiles we might not be drawing a foundation. We need to
   * account for this, as other structures should
   * draw the wall of the foundation in this case.
   */
  if (gfx >= NEW_INDUSTRYTILEOFFSET) {
    const IndustryTileSpec *indts = GetIndustryTileSpec(gfx);
    if (indts->grf_prop.spritegroup != NULL && HasBit(indts->callback_flags, CBM_INDT_DRAW_FOUNDATIONS)) {
      uint32 callback_res = GetIndustryTileCallback(CBID_INDUSTRY_DRAW_FOUNDATIONS, 0, 0, gfx, GetIndustryByTile(tile), tile);
      if (callback_res == 0) return FOUNDATION_NONE;
    }
  }
  return FlatteningFoundation(tileh);
}

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)
{
  IndustryGfx gfx = GetIndustryGfx(tile);
  const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);

  /* When we have to use a callback, we put our data in the next two variables */
  CargoID raw_accepts_cargo[lengthof(itspec->accepts_cargo)];
  uint8 raw_acceptance[lengthof(itspec->acceptance)];

  /* And then these will always point to a same sized array with the required data */
  const CargoID *accepts_cargo = itspec->accepts_cargo;
  const uint8 *acceptance = itspec->acceptance;

  if (HasBit(itspec->callback_flags, CBM_INDT_ACCEPT_CARGO)) {
    uint16 res = GetIndustryTileCallback(CBID_INDTILE_ACCEPT_CARGO, 0, 0, gfx, GetIndustryByTile(tile), tile);
    if (res != CALLBACK_FAILED) {
      accepts_cargo = raw_accepts_cargo;
      for (uint i = 0; i < lengthof(itspec->accepts_cargo); i++) raw_accepts_cargo[i] = GetCargoTranslation(GB(res, i * 5, 5), itspec->grf_prop.grffile);
    }
  }

  if (HasBit(itspec->callback_flags, CBM_INDT_CARGO_ACCEPTANCE)) {
    uint16 res = GetIndustryTileCallback(CBID_INDTILE_CARGO_ACCEPTANCE, 0, 0, gfx, GetIndustryByTile(tile), tile);
    if (res != CALLBACK_FAILED) {
      acceptance = raw_acceptance;
      for (uint i = 0; i < lengthof(itspec->accepts_cargo); i++) raw_acceptance[i] = GB(res, i * 4, 4);
    }
  }

  for (byte i = 0; i < lengthof(itspec->accepts_cargo); i++) {
    CargoID a = accepts_cargo[i];
    /* Only set the value once. */
    if (a != CT_INVALID && ac[a] == 0) ac[a] = acceptance[i];
  }
}

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)
{
  const Industry *i = GetIndustryByTile(tile);
  const IndustrySpec *is = GetIndustrySpec(i->type);

  td->owner[0] = i->owner;
  td->str = is->name;
  if (!IsIndustryCompleted(tile)) {
    SetDParamX(td->dparam, 0, td->str);
    td->str = STR_2058_UNDER_CONSTRUCTION;
  }

  if (is->grf_prop.grffile != NULL) {
    td->grf = GetGRFConfig(is->grf_prop.grffile->grfid)->name;
  }
}

static CommandCost ClearTile_Industry(TileIndex tile, byte flags)
{
  Industry *i = GetIndustryByTile(tile);
  const IndustrySpec *indspec = GetIndustrySpec(i->type);

  /* water can destroy industries
   * in editor you can bulldoze industries
   * with magic_bulldozer cheat you can destroy industries
   * (area around OILRIG is water, so water shouldn't flood it
   */
  if ((_current_company != OWNER_WATER && _game_mode != GM_EDITOR &&
      !_cheats.magic_bulldozer.value) ||
      ((flags & DC_AUTO) != 0) ||
      (_current_company == OWNER_WATER &&
        ((indspec->behaviour & INDUSTRYBEH_BUILT_ONWATER) ||
        HasBit(GetIndustryTileSpec(GetIndustryGfx(tile))->slopes_refused, 5)))) {
    SetDParam(0, indspec->name);
    return_cmd_error(STR_4800_IN_THE_WAY);
  }

  if (flags & DC_EXEC) delete i;
  return CommandCost(EXPENSES_CONSTRUCTION, indspec->GetRemovalCost());
}

static void TransportIndustryGoods(TileIndex tile)
{
  Industry *i = GetIndustryByTile(tile);
  const IndustrySpec *indspec = GetIndustrySpec(i->type);
  bool moved_cargo = false;

  for (uint j = 0; j < lengthof(i->produced_cargo_waiting); j++) {
    uint cw = min(i->produced_cargo_waiting[j], 255);
    if (cw > indspec->minimal_cargo && i->produced_cargo[j] != CT_INVALID) {
      i->produced_cargo_waiting[j] -= cw;

      /* fluctuating economy? */
      if (_economy.fluct <= 0) cw = (cw + 1) / 2;

      i->this_month_production[j] += cw;

      uint am = MoveGoodsToStation(i->xy, i->width, i->height, i->produced_cargo[j], cw);
      i->this_month_transported[j] += am;

      moved_cargo |= (am != 0);
    }
  }

  if (moved_cargo && !StartStopIndustryTileAnimation(i, IAT_INDUSTRY_DISTRIBUTES_CARGO)) {
    uint newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_production;

    if (newgfx != INDUSTRYTILE_NOANIM) {
      ResetIndustryConstructionStage(tile);
      SetIndustryCompleted(tile, true);
      SetIndustryGfx(tile, newgfx);
      MarkTileDirtyByTile(tile);
    }
  }
}


static void AnimateTile_Industry(TileIndex tile)
{
  byte m;
  IndustryGfx gfx = GetIndustryGfx(tile);

  if (GetIndustryTileSpec(gfx)->animation_info != 0xFFFF) {
    AnimateNewIndustryTile(tile);
    return;
  }

  switch (gfx) {
  case GFX_SUGAR_MINE_SIEVE:
    if ((_tick_counter & 1) == 0) {
      m = GetIndustryAnimationState(tile) + 1;

      switch (m & 7) {
      case 2: SndPlayTileFx(SND_2D_RIP_2, tile); break;
      case 6: SndPlayTileFx(SND_29_RIP, tile); break;
      }

      if (m >= 96) {
        m = 0;
        DeleteAnimatedTile(tile);
      }
      SetIndustryAnimationState(tile, m);

      MarkTileDirtyByTile(tile);
    }
    break;

  case GFX_TOFFEE_QUARY:
    if ((_tick_counter & 3) == 0) {
      m = GetIndustryAnimationState(tile);

      if (_industry_anim_offs_toffee[m] == 0xFF) {
        SndPlayTileFx(SND_30_CARTOON_SOUND, tile);
      }

      if (++m >= 70) {
        m = 0;
        DeleteAnimatedTile(tile);
      }
      SetIndustryAnimationState(tile, m);

      MarkTileDirtyByTile(tile);
    }
    break;

  case GFX_BUBBLE_CATCHER:
    if ((_tick_counter & 1) == 0) {
      m = GetIndustryAnimationState(tile);

      if (++m >= 40) {
        m = 0;
        DeleteAnimatedTile(tile);
      }
      SetIndustryAnimationState(tile, m);

      MarkTileDirtyByTile(tile);
    }
    break;

  /* Sparks on a coal plant */
  case GFX_POWERPLANT_SPARKS:
    if ((_tick_counter & 3) == 0) {
      m = GetIndustryAnimationState(tile);
      if (m == 6) {
        SetIndustryAnimationState(tile, 0);
        DeleteAnimatedTile(tile);
      } else {
        SetIndustryAnimationState(tile, m + 1);
        MarkTileDirtyByTile(tile);
      }
    }
    break;

  case GFX_TOY_FACTORY:
    if ((_tick_counter & 1) == 0) {
      m = GetIndustryAnimationState(tile) + 1;

      switch (m) {
        case  1: SndPlayTileFx(SND_2C_MACHINERY, tile); break;
        case 23: SndPlayTileFx(SND_2B_COMEDY_HIT, tile); break;
        case 28: SndPlayTileFx(SND_2A_EXTRACT_AND_POP, tile); break;
        default:
          if (m >= 50) {
            int n = GetIndustryAnimationLoop(tile) + 1;
            m = 0;
            if (n >= 8) {
              n = 0;
              DeleteAnimatedTile(tile);
            }
            SetIndustryAnimationLoop(tile, n);
          }
      }

      SetIndustryAnimationState(tile, m);
      MarkTileDirtyByTile(tile);
    }
    break;

  case GFX_PLASTIC_FOUNTAIN_ANIMATED_1: case GFX_PLASTIC_FOUNTAIN_ANIMATED_2:
  case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:
  case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:
  case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:
    if ((_tick_counter & 3) == 0) {
      IndustryGfx gfx = GetIndustryGfx(tile);

      gfx = (gfx < 155) ? gfx + 1 : 148;
      SetIndustryGfx(tile, gfx);
      MarkTileDirtyByTile(tile);
    }
    break;

  case GFX_OILWELL_ANIMATED_1:
  case GFX_OILWELL_ANIMATED_2:
  case GFX_OILWELL_ANIMATED_3:
    if ((_tick_counter & 7) == 0) {
      bool b = Chance16(1, 7);
      IndustryGfx gfx = GetIndustryGfx(tile);

      m = GetIndustryAnimationState(tile) + 1;
      if (m == 4 && (m = 0, ++gfx) == GFX_OILWELL_ANIMATED_3 + 1 && (gfx = GFX_OILWELL_ANIMATED_1, b)) {
        SetIndustryGfx(tile, GFX_OILWELL_NOT_ANIMATED);
        SetIndustryConstructionStage(tile, 3);
        DeleteAnimatedTile(tile);
      } else {
        SetIndustryAnimationState(tile, m);
        SetIndustryGfx(tile, gfx);
        MarkTileDirtyByTile(tile);
      }
    }
    break;

  case GFX_COAL_MINE_TOWER_ANIMATED:
  case GFX_COPPER_MINE_TOWER_ANIMATED:
  case GFX_GOLD_MINE_TOWER_ANIMATED: {
      int state = _tick_counter & 0x7FF;

      if ((state -= 0x400) < 0)
        return;

      if (state < 0x1A0) {
        if (state < 0x20 || state >= 0x180) {
          m = GetIndustryAnimationState(tile);
          if (!(m & 0x40)) {
            SetIndustryAnimationState(tile, m | 0x40);
            SndPlayTileFx(SND_0B_MINING_MACHINERY, tile);
          }
          if (state & 7)
            return;
        } else {
          if (state & 3)
            return;
        }
        m = (GetIndustryAnimationState(tile) + 1) | 0x40;
        if (m > 0xC2) m = 0xC0;
        SetIndustryAnimationState(tile, m);
        MarkTileDirtyByTile(tile);
      } else if (state >= 0x200 && state < 0x3A0) {
        int i;
        i = (state < 0x220 || state >= 0x380) ? 7 : 3;
        if (state & i)
          return;

        m = (GetIndustryAnimationState(tile) & 0xBF) - 1;
        if (m < 0x80) m = 0x82;
        SetIndustryAnimationState(tile, m);
        MarkTileDirtyByTile(tile);
      }
    } break;
  }
}

static void CreateChimneySmoke(TileIndex tile)
{
  uint x = TileX(tile) * TILE_SIZE;
  uint y = TileY(tile) * TILE_SIZE;
  uint z = GetTileMaxZ(tile);

  CreateEffectVehicle(x + 15, y + 14, z + 59, EV_CHIMNEY_SMOKE);
}

static void MakeIndustryTileBigger(TileIndex tile)
{
  byte cnt = GetIndustryConstructionCounter(tile) + 1;
  byte stage;

  if (cnt != 4) {
    SetIndustryConstructionCounter(tile, cnt);
    return;
  }

  stage = GetIndustryConstructionStage(tile) + 1;
  SetIndustryConstructionCounter(tile, 0);
  SetIndustryConstructionStage(tile, stage);
  StartStopIndustryTileAnimation(tile, IAT_CONSTRUCTION_STATE_CHANGE);
  if (stage == INDUSTRY_COMPLETED) SetIndustryCompleted(tile, true);

  MarkTileDirtyByTile(tile);

  if (!IsIndustryCompleted(tile)) return;

  IndustryGfx gfx = GetIndustryGfx(tile);
  if (gfx >= NEW_INDUSTRYTILEOFFSET) {
    /* New industries are already animated on construction. */
    return;
  }

  switch (gfx) {
  case GFX_POWERPLANT_CHIMNEY:
    CreateChimneySmoke(tile);
    break;

  case GFX_OILRIG_1:
    if (GetIndustryGfx(tile + TileDiffXY(0, 1)) == GFX_OILRIG_1) BuildOilRig(tile);
    break;

  case GFX_TOY_FACTORY:
  case GFX_BUBBLE_CATCHER:
  case GFX_TOFFEE_QUARY:
    SetIndustryAnimationState(tile, 0);
    SetIndustryAnimationLoop(tile, 0);
    break;

  case GFX_PLASTIC_FOUNTAIN_ANIMATED_1: case GFX_PLASTIC_FOUNTAIN_ANIMATED_2:
  case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:
  case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:
  case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:
    AddAnimatedTile(tile);
    break;
  }
}

static void TileLoopIndustry_BubbleGenerator(TileIndex tile)
{
  int dir;
  Vehicle *v;
  static const int8 _bubble_spawn_location[3][4] = {
    { 11,   0, -4, -14 },
    { -4, -10, -4,   1 },
    { 49,  59, 60,  65 },
  };

  SndPlayTileFx(SND_2E_EXTRACT_AND_POP, tile);

  dir = Random() & 3;

  v = CreateEffectVehicleAbove(
    TileX(tile) * TILE_SIZE + _bubble_spawn_location[0][dir],
    TileY(tile) * TILE_SIZE + _bubble_spawn_location[1][dir],
    _bubble_spawn_location[2][dir],
    EV_BUBBLE
  );

  if (v != NULL) v->u.effect.animation_substate = dir;
}

static void TileLoop_Industry(TileIndex tile)
{
  IndustryGfx newgfx;
  IndustryGfx gfx;

  if (IsIndustryTileOnWater(tile)) TileLoop_Water(tile);

  TriggerIndustryTile(tile, INDTILE_TRIGGER_TILE_LOOP);

  if (!IsIndustryCompleted(tile)) {
    MakeIndustryTileBigger(tile);
    return;
  }

  if (_game_mode == GM_EDITOR) return;

  TransportIndustryGoods(tile);

  if (StartStopIndustryTileAnimation(tile, IAT_TILELOOP)) return;

  newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_next;
  if (newgfx != INDUSTRYTILE_NOANIM) {
    ResetIndustryConstructionStage(tile);
    SetIndustryGfx(tile, newgfx);
    MarkTileDirtyByTile(tile);
    return;
  }

  gfx = GetIndustryGfx(tile);

  switch (gfx) {
  case GFX_COAL_MINE_TOWER_NOT_ANIMATED:
  case GFX_COPPER_MINE_TOWER_NOT_ANIMATED:
  case GFX_GOLD_MINE_TOWER_NOT_ANIMATED:
    if (!(_tick_counter & 0x400) && Chance16(1, 2)) {
      switch (gfx) {
        case GFX_COAL_MINE_TOWER_NOT_ANIMATED:   gfx = GFX_COAL_MINE_TOWER_ANIMATED;   break;
        case GFX_COPPER_MINE_TOWER_NOT_ANIMATED: gfx = GFX_COPPER_MINE_TOWER_ANIMATED; break;
        case GFX_GOLD_MINE_TOWER_NOT_ANIMATED:   gfx = GFX_GOLD_MINE_TOWER_ANIMATED;   break;
      }
      SetIndustryGfx(tile, gfx);
      SetIndustryAnimationState(tile, 0x80);
      AddAnimatedTile(tile);
    }
    break;

  case GFX_OILWELL_NOT_ANIMATED:
    if (Chance16(1, 6)) {
      SetIndustryGfx(tile, GFX_OILWELL_ANIMATED_1);
      SetIndustryAnimationState(tile, 0);
      AddAnimatedTile(tile);
    }
    break;

  case GFX_COAL_MINE_TOWER_ANIMATED:
  case GFX_COPPER_MINE_TOWER_ANIMATED:
  case GFX_GOLD_MINE_TOWER_ANIMATED:
    if (!(_tick_counter & 0x400)) {
      switch (gfx) {
        case GFX_COAL_MINE_TOWER_ANIMATED:   gfx = GFX_COAL_MINE_TOWER_NOT_ANIMATED;   break;
        case GFX_COPPER_MINE_TOWER_ANIMATED: gfx = GFX_COPPER_MINE_TOWER_NOT_ANIMATED; break;
        case GFX_GOLD_MINE_TOWER_ANIMATED:   gfx = GFX_GOLD_MINE_TOWER_NOT_ANIMATED;   break;
      }
      SetIndustryGfx(tile, gfx);
      SetIndustryCompleted(tile, true);
      SetIndustryConstructionStage(tile, 3);
      DeleteAnimatedTile(tile);
    }
    break;

  case GFX_POWERPLANT_SPARKS:
    if (Chance16(1, 3)) {
      SndPlayTileFx(SND_0C_ELECTRIC_SPARK, tile);
      AddAnimatedTile(tile);
    }
    break;

  case GFX_COPPER_MINE_CHIMNEY:
    CreateEffectVehicleAbove(TileX(tile) * TILE_SIZE + 6, TileY(tile) * TILE_SIZE + 6, 43, EV_SMOKE);
    break;


  case GFX_TOY_FACTORY: {
      Industry *i = GetIndustryByTile(tile);
      if (i->was_cargo_delivered) {
        i->was_cargo_delivered = false;
        SetIndustryAnimationLoop(tile, 0);
        AddAnimatedTile(tile);
      }
    }
    break;

  case GFX_BUBBLE_GENERATOR:
    TileLoopIndustry_BubbleGenerator(tile);
    break;

  case GFX_TOFFEE_QUARY:
    AddAnimatedTile(tile);
    break;

  case GFX_SUGAR_MINE_SIEVE:
    if (Chance16(1, 3)) AddAnimatedTile(tile);
    break;
  }
}

static void ClickTile_Industry(TileIndex tile)
{
  ShowIndustryViewWindow(GetIndustryIndex(tile));
}

static TrackStatus GetTileTrackStatus_Industry(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
{
  return 0;
}

static void GetProducedCargo_Industry(TileIndex tile, CargoID *b)
{
  const Industry *i = GetIndustryByTile(tile);

  b[0] = i->produced_cargo[0];
  b[1] = i->produced_cargo[1];
}

static void ChangeTileOwner_Industry(TileIndex tile, Owner old_owner, Owner new_owner)
{
  /* If the founder merges, the industry was created by the merged company */
  Industry *i = GetIndustryByTile(tile);
  if (i->founder == old_owner) i->founder = (new_owner == INVALID_OWNER) ? OWNER_NONE : new_owner;
}

static const byte _plantfarmfield_type[] = {1, 1, 1, 1, 1, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6};

static bool IsBadFarmFieldTile(TileIndex tile)
{
  switch (GetTileType(tile)) {
    case MP_CLEAR: return IsClearGround(tile, CLEAR_FIELDS) || IsClearGround(tile, CLEAR_SNOW) || IsClearGround(tile, CLEAR_DESERT);
    case MP_TREES: return (GetTreeGround(tile) == TREE_GROUND_SHORE);
    default:       return true;
  }
}

static bool IsBadFarmFieldTile2(TileIndex tile)
{
  switch (GetTileType(tile)) {
    case MP_CLEAR: return IsClearGround(tile, CLEAR_SNOW) || IsClearGround(tile, CLEAR_DESERT);
    case MP_TREES: return (GetTreeGround(tile) == TREE_GROUND_SHORE);
    default:       return true;
  }
}

static void SetupFarmFieldFence(TileIndex tile, int size, byte type, Axis direction)
{
  do {
    tile = TILE_MASK(tile);

    if (IsTileType(tile, MP_CLEAR) || IsTileType(tile,