town_cmd.cpp

Go to the documentation of this file.

/* $Id: town_cmd.cpp 14933 2009-01-09 14:59:02Z rubidium $ */

#include "stdafx.h"
#include "openttd.h"
#include "tile_cmd.h"
#include "debug.h"
#include "road_map.h"
#include "road_internal.h" /* Cleaning up road bits */
#include "road_cmd.h"
#include "landscape.h"
#include "town_map.h"
#include "tunnel_map.h"
#include "viewport_func.h"
#include "town.h"
#include "command_func.h"
#include "industry.h"
#include "station_base.h"
#include "company_base.h"
#include "news_func.h"
#include "gui.h"
#include "unmovable_map.h"
#include "water_map.h"
#include "variables.h"
#include "bridge.h"
#include "bridge_map.h"
#include "genworld.h"
#include "newgrf.h"
#include "newgrf_callbacks.h"
#include "newgrf_house.h"
#include "newgrf_commons.h"
#include "newgrf_townname.h"
#include "autoslope.h"
#include "waypoint.h"
#include "transparency.h"
#include "tunnelbridge_map.h"
#include "strings_func.h"
#include "window_func.h"
#include "string_func.h"
#include "newgrf_cargo.h"
#include "oldpool_func.h"
#include "sprite.h"
#include "economy_func.h"
#include "station_func.h"
#include "cheat_func.h"
#include "functions.h"
#include "animated_tile_func.h"
#include "date_func.h"
#include "core/smallmap_type.hpp"

#include "table/strings.h"
#include "table/sprites.h"
#include "table/town_land.h"

uint _total_towns;
HouseSpec _house_specs[HOUSE_MAX];

Town *_cleared_town;
int _cleared_town_rating;

/* Initialize the town-pool */
DEFINE_OLD_POOL_GENERIC(Town, Town)

Town::Town(TileIndex tile)
{
  if (tile != INVALID_TILE) _total_towns++;
  this->xy = tile;
}

Town::~Town()
{
  free(this->name);

  if (CleaningPool()) return;

  Industry *i;

  /* Delete town authority window
   * and remove from list of sorted towns */
  DeleteWindowById(WC_TOWN_VIEW, this->index);
  InvalidateWindowData(WC_TOWN_DIRECTORY, 0, 0);
  _total_towns--;

  /* Delete all industries belonging to the town */
  FOR_ALL_INDUSTRIES(i) if (i->town == this) delete i;

  /* Go through all tiles and delete those belonging to the town */
  for (TileIndex tile = 0; tile < MapSize(); ++tile) {
    switch (GetTileType(tile)) {
      case MP_HOUSE:
        if (GetTownByTile(tile) == this) DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
        break;

      case MP_ROAD:
        /* Cached nearest town is updated later (after this town has been deleted) */
        if (HasTownOwnedRoad(tile) && GetTownIndex(tile) == this->index) {
          DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
        }
        break;

      case MP_TUNNELBRIDGE:
        if (IsTileOwner(tile, OWNER_TOWN) &&
            ClosestTownFromTile(tile, UINT_MAX) == this)
          DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
        break;

      default:
        break;
    }
  }

  DeleteSubsidyWithTown(this->index);

  MarkWholeScreenDirty();

  this->xy = INVALID_TILE;

  UpdateNearestTownForRoadTiles(false);
}

void Town::InitializeLayout()
{
  this->layout = (TownLayout)(TileHash(TileX(this->xy), TileY(this->xy)) % NUM_TLS);

  /* Set invalid layouts to valid ones */
  switch (this->layout) {
    default: break;
    case TL_RANDOM: this->layout = TL_ORIGINAL; break;
    case TL_NO_ROADS: this->layout = TL_BETTER_ROADS; break;
  }
}

Money HouseSpec::GetRemovalCost() const
{
  return (_price.remove_house * this->removal_cost) >> 8;
}

// Local
static int _grow_town_result;

/* Describe the possible states */
enum TownGrowthResult {
  GROWTH_SUCCEED         = -1,
  GROWTH_SEARCH_STOPPED  =  0
//  GROWTH_SEARCH_RUNNING >=  1
};

static bool BuildTownHouse(Town *t, TileIndex tile);

static void TownDrawHouseLift(const TileInfo *ti)
{
  AddChildSpriteScreen(SPR_LIFT, PAL_NONE, 14, 60 - GetLiftPosition(ti->tile));
}

typedef void TownDrawTileProc(const TileInfo *ti);
static TownDrawTileProc *const _town_draw_tile_procs[1] = {
  TownDrawHouseLift
};

static inline DiagDirection RandomDiagDir()
{
  return (DiagDirection)(3 & Random());
}

static void DrawTile_Town(TileInfo *ti)
{
  HouseID house_id = GetHouseType(ti->tile);

  if (house_id >= NEW_HOUSE_OFFSET) {
    /* Houses don't necessarily need new graphics. If they don't have a
     * spritegroup associated with them, then the sprite for the substitute
     * house id is drawn instead. */
    if (GetHouseSpecs(house_id)->spritegroup != NULL) {
      DrawNewHouseTile(ti, house_id);
      return;
    } else {
      house_id = GetHouseSpecs(house_id)->substitute_id;
    }
  }

  /* Retrieve pointer to the draw town tile struct */
  const DrawBuildingsTileStruct *dcts = &_town_draw_tile_data[house_id << 4 | TileHash2Bit(ti->x, ti->y) << 2 | GetHouseBuildingStage(ti->tile)];

  if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);

  DrawGroundSprite(dcts->ground.sprite, dcts->ground.pal);

  /* If houses are invisible, do not draw the upper part */
  if (IsInvisibilitySet(TO_HOUSES)) return;

  /* Add a house on top of the ground? */
  SpriteID image = dcts->building.sprite;
  if (image != 0) {
    AddSortableSpriteToDraw(image, dcts->building.pal,
      ti->x + dcts->subtile_x,
      ti->y + dcts->subtile_y,
      dcts->width,
      dcts->height,
      dcts->dz,
      ti->z,
      IsTransparencySet(TO_HOUSES)
    );

    if (IsTransparencySet(TO_HOUSES)) return;
  }

  {
    int proc = dcts->draw_proc - 1;

    if (proc >= 0) _town_draw_tile_procs[proc](ti);
  }
}

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

static Foundation GetFoundation_Town(TileIndex tile, Slope tileh)
{
  return FlatteningFoundation(tileh);
}

static void AnimateTile_Town(TileIndex tile)
{
  if (GetHouseType(tile) >= NEW_HOUSE_OFFSET) {
    AnimateNewHouseTile(tile);
    return;
  }

  if (_tick_counter & 3) return;

  /* If the house is not one with a lift anymore, then stop this animating.
   * Not exactly sure when this happens, but probably when a house changes.
   * Before this was just a return...so it'd leak animated tiles..
   * That bug seems to have been here since day 1?? */
  if (!(GetHouseSpecs(GetHouseType(tile))->building_flags & BUILDING_IS_ANIMATED)) {
    DeleteAnimatedTile(tile);
    return;
  }

  if (!LiftHasDestination(tile)) {
    uint i;

    /* Building has 6 floors, number 0 .. 6, where 1 is illegal.
     * This is due to the fact that the first floor is, in the graphics,
     *  the height of 2 'normal' floors.
     * Furthermore, there are 6 lift positions from floor N (incl) to floor N + 1 (excl) */
    do {
      i = RandomRange(7);
    } while (i == 1 || i * 6 == GetLiftPosition(tile));

    SetLiftDestination(tile, i);
  }

  int pos = GetLiftPosition(tile);
  int dest = GetLiftDestination(tile) * 6;
  pos += (pos < dest) ? 1 : -1;
  SetLiftPosition(tile, pos);

  if (pos == dest) {
    HaltLift(tile);
    DeleteAnimatedTile(tile);
  }

  MarkTileDirtyByTile(tile);
}

static bool IsCloseToTown(TileIndex tile, uint dist)
{
  const Town *t;

  FOR_ALL_TOWNS(t) {
    if (DistanceManhattan(tile, t->xy) < dist) return true;
  }
  return false;
}

static void MarkTownSignDirty(Town *t)
{
  MarkAllViewportsDirty(
    t->sign.left - 6,
    t->sign.top - 3,
    t->sign.left + t->sign.width_1 * 4 + 12,
    t->sign.top + 45
  );
}

void UpdateTownVirtCoord(Town *t)
{
  MarkTownSignDirty(t);
  Point pt = RemapCoords2(TileX(t->xy) * TILE_SIZE, TileY(t->xy) * TILE_SIZE);
  SetDParam(0, t->index);
  SetDParam(1, t->population);
  UpdateViewportSignPos(&t->sign, pt.x, pt.y - 24,
    _settings_client.gui.population_in_label ? STR_TOWN_LABEL_POP : STR_TOWN_LABEL);
  MarkTownSignDirty(t);
}

void UpdateAllTownVirtCoords()
{
  Town *t;
  FOR_ALL_TOWNS(t) {
    UpdateTownVirtCoord(t);
  }
}

static void ChangePopulation(Town *t, int mod)
{
  t->population += mod;
  InvalidateWindow(WC_TOWN_VIEW, t->index);
  UpdateTownVirtCoord(t);

  InvalidateWindowData(WC_TOWN_DIRECTORY, 0, 1);
}

uint32 GetWorldPopulation()
{
  uint32 pop = 0;
  const Town *t;

  FOR_ALL_TOWNS(t) pop += t->population;
  return pop;
}

static void MakeSingleHouseBigger(TileIndex tile)
{
  assert(IsTileType(tile, MP_HOUSE));

  /* means it is completed, get out. */
  if (LiftHasDestination(tile)) return;

  /* progress in construction stages */
  IncHouseConstructionTick(tile);
  if (GetHouseConstructionTick(tile) != 0) return;

  const HouseSpec *hs = GetHouseSpecs(GetHouseType(tile));

  /* Check and/or  */
  if (HasBit(hs->callback_mask, CBM_HOUSE_CONSTRUCTION_STATE_CHANGE)) {
    uint16 callback_res = GetHouseCallback(CBID_HOUSE_CONSTRUCTION_STATE_CHANGE, 0, 0, GetHouseType(tile), GetTownByTile(tile), tile);
    if (callback_res != CALLBACK_FAILED) ChangeHouseAnimationFrame(hs->grffile, tile, callback_res);
  }

  if (IsHouseCompleted(tile)) {
    /* Now that construction is complete, we can add the population of the
     * building to the town. */
    ChangePopulation(GetTownByTile(tile), hs->population);
    ResetHouseAge(tile);
  }
  MarkTileDirtyByTile(tile);
}

static void MakeTownHouseBigger(TileIndex tile)
{
  uint flags = GetHouseSpecs(GetHouseType(tile))->building_flags;
  if (flags & BUILDING_HAS_1_TILE)  MakeSingleHouseBigger(TILE_ADDXY(tile, 0, 0));
  if (flags & BUILDING_2_TILES_Y)   MakeSingleHouseBigger(TILE_ADDXY(tile, 0, 1));
  if (flags & BUILDING_2_TILES_X)   MakeSingleHouseBigger(TILE_ADDXY(tile, 1, 0));
  if (flags & BUILDING_HAS_4_TILES) MakeSingleHouseBigger(TILE_ADDXY(tile, 1, 1));
}

static void TileLoop_Town(TileIndex tile)
{
  HouseID house_id = GetHouseType(tile);

  /* NewHouseTileLoop returns false if Callback 21 succeeded, i.e. the house
   * doesn't exist any more, so don't continue here. */
  if (house_id >= NEW_HOUSE_OFFSET && !NewHouseTileLoop(tile)) return;

  if (!IsHouseCompleted(tile)) {
    /* Construction is not completed. See if we can go further in construction*/
    MakeTownHouseBigger(tile);
    return;
  }

  const HouseSpec *hs = GetHouseSpecs(house_id);

  /* If the lift has a destination, it is already an animated tile. */
  if ((hs->building_flags & BUILDING_IS_ANIMATED) &&
      house_id < NEW_HOUSE_OFFSET &&
      !LiftHasDestination(tile) &&
      Chance16(1, 2)) {
    AddAnimatedTile(tile);
  }

  Town *t = GetTownByTile(tile);
  uint32 r = Random();

  if (HasBit(hs->callback_mask, CBM_HOUSE_PRODUCE_CARGO)) {
    for (uint i = 0; i < 256; i++) {
      uint16 callback = GetHouseCallback(CBID_HOUSE_PRODUCE_CARGO, i, r, house_id, t, tile);

      if (callback == CALLBACK_FAILED || callback == CALLBACK_HOUSEPRODCARGO_END) break;

      CargoID cargo = GetCargoTranslation(GB(callback, 8, 7), hs->grffile);
      if (cargo == CT_INVALID) continue;

      uint amt = GB(callback, 0, 8);
      uint moved = MoveGoodsToStation(tile, 1, 1, cargo, amt);

      const CargoSpec *cs = GetCargo(cargo);
      switch (cs->town_effect) {
        case TE_PASSENGERS:
          t->new_max_pass += amt;
          t->new_act_pass += moved;
          break;

        case TE_MAIL:
          t->new_max_mail += amt;
          t->new_act_mail += moved;
          break;

        default:
          break;
      }
    }
  } else {
    if (GB(r, 0, 8) < hs->population) {
      uint amt = GB(r, 0, 8) / 8 + 1;

      if (_economy.fluct <= 0) amt = (amt + 1) >> 1;
      t->new_max_pass += amt;
      t->new_act_pass += MoveGoodsToStation(tile, 1, 1, CT_PASSENGERS, amt);
    }

    if (GB(r, 8, 8) < hs->mail_generation) {
      uint amt = GB(r, 8, 8) / 8 + 1;

      if (_economy.fluct <= 0) amt = (amt + 1) >> 1;
      t->new_max_mail += amt;
      t->new_act_mail += MoveGoodsToStation(tile, 1, 1, CT_MAIL, amt);
    }
  }

  _current_company = OWNER_TOWN;

  if (hs->building_flags & BUILDING_HAS_1_TILE &&
      HasBit(t->flags12, TOWN_IS_FUNDED) &&
      CanDeleteHouse(tile) &&
      GetHouseAge(tile) >= hs->minimum_life &&
      --t->time_until_rebuild == 0) {
    t->time_until_rebuild = GB(r, 16, 8) + 192;

    ClearTownHouse(t, tile);

    /* Rebuild with another house? */
    if (GB(r, 24, 8) >= 12) BuildTownHouse(t, tile);
  }

  _current_company = OWNER_NONE;
}

static bool ClickTile_Town(TileIndex tile)
{
  /* not used */
  return false;
}

static CommandCost ClearTile_Town(TileIndex tile, byte flags)
{
  if ((flags & DC_AUTO) && !(flags & DC_AI_BUILDING)) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);
  if (!CanDeleteHouse(tile)) return CMD_ERROR;

  const HouseSpec *hs = GetHouseSpecs(GetHouseType(tile));

  CommandCost cost(EXPENSES_CONSTRUCTION);
  cost.AddCost(hs->GetRemovalCost());

  int rating = hs->remove_rating_decrease;
  _cleared_town_rating += rating;
  Town *t = _cleared_town = GetTownByTile(tile);

  if (IsValidCompanyID(_current_company)) {
    if (rating > t->ratings[_current_company] && !(flags & DC_NO_TOWN_RATING) && !_cheats.magic_bulldozer.value) {
      SetDParam(0, t->index);
      return_cmd_error(STR_2009_LOCAL_AUTHORITY_REFUSES);
    }
  }

  ChangeTownRating(t, -rating, RATING_HOUSE_MINIMUM);
  if (flags & DC_EXEC) {
    ClearTownHouse(t, tile);
  }

  return cost;
}

static void GetProducedCargo_Town(TileIndex tile, CargoID *b)
{
  HouseID house_id = GetHouseType(tile);
  const HouseSpec *hs = GetHouseSpecs(house_id);
  Town *t = GetTownByTile(tile);

  if (HasBit(hs->callback_mask, CBM_HOUSE_PRODUCE_CARGO)) {
    for (uint i = 0; i < 256; i++) {
      uint16 callback = GetHouseCallback(CBID_HOUSE_PRODUCE_CARGO, i, 0, house_id, t, tile);

      if (callback == CALLBACK_FAILED || callback == CALLBACK_HOUSEPRODCARGO_END) break;

      CargoID cargo = GetCargoTranslation(GB(callback, 8, 7), hs->grffile);

      if (cargo == CT_INVALID) continue;
      *(b++) = cargo;
    }
  } else {
    if (hs->population > 0) {
      *(b++) = CT_PASSENGERS;
    }
    if (hs->mail_generation > 0) {
      *(b++) = CT_MAIL;
    }
  }
}

static void GetAcceptedCargo_Town(TileIndex tile, AcceptedCargo ac)
{
  const HouseSpec *hs = GetHouseSpecs(GetHouseType(tile));
  CargoID accepts[3];

  /* Set the initial accepted cargo types */
  for (uint8 i = 0; i < lengthof(accepts); i++) {
    accepts[i] = hs->accepts_cargo[i];
  }

  /* Check for custom accepted cargo types */
  if (HasBit(hs->callback_mask, CBM_HOUSE_ACCEPT_CARGO)) {
    uint16 callback = GetHouseCallback(CBID_HOUSE_ACCEPT_CARGO, 0, 0, GetHouseType(tile), GetTownByTile(tile), tile);
    if (callback != CALLBACK_FAILED) {
      /* Replace accepted cargo types with translated values from callback */
      accepts[0] = GetCargoTranslation(GB(callback,  0, 5), hs->grffile);
      accepts[1] = GetCargoTranslation(GB(callback,  5, 5), hs->grffile);
      accepts[2] = GetCargoTranslation(GB(callback, 10, 5), hs->grffile);
    }
  }

  /* Check for custom cargo acceptance */
  if (HasBit(hs->callback_mask, CBM_HOUSE_CARGO_ACCEPTANCE)) {
    uint16 callback = GetHouseCallback(CBID_HOUSE_CARGO_ACCEPTANCE, 0, 0, GetHouseType(tile), GetTownByTile(tile), tile);
    if (callback != CALLBACK_FAILED) {
      if (accepts[0] != CT_INVALID) ac[accepts[0]] = GB(callback, 0, 4);
      if (accepts[1] != CT_INVALID) ac[accepts[1]] = GB(callback, 4, 4);
      if (_settings_game.game_creation.landscape != LT_TEMPERATE && HasBit(callback, 12)) {
        /* The 'S' bit indicates food instead of goods */
        ac[CT_FOOD] = GB(callback, 8, 4);
      } else {
        if (accepts[2] != CT_INVALID) ac[accepts[2]] = GB(callback, 8, 4);
      }
      return;
    }
  }

  /* No custom acceptance, so fill in with the default values */
  for (uint8 i = 0; i < lengthof(accepts); i++) {
    if (accepts[i] != CT_INVALID) ac[accepts[i]] = hs->cargo_acceptance[i];
  }
}

static void GetTileDesc_Town(TileIndex tile, TileDesc *td)
{
  const HouseSpec *hs = GetHouseSpecs(GetHouseType(tile));

  td->str = hs->building_name;
  if (!IsHouseCompleted(tile)) {
    SetDParamX(td->dparam, 0, td->str);
    td->str = STR_2058_UNDER_CONSTRUCTION;
  }

  if (hs->grffile != NULL) {
    const GRFConfig *gc = GetGRFConfig(hs->grffile->grfid);
    td->grf = gc->name;
  }

  td->owner[0] = OWNER_TOWN;
}

static TrackStatus GetTileTrackStatus_Town(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
{
  /* not used */
  return 0;
}

static void ChangeTileOwner_Town(TileIndex tile, Owner old_owner, Owner new_owner)
{
  /* not used */
}

static bool GrowTown(Town *t);

static void TownTickHandler(Town *t)
{
  if (HasBit(t->flags12, TOWN_IS_FUNDED)) {
    int i = t->grow_counter - 1;
    if (i < 0) {
      if (GrowTown(t)) {
        i = t->growth_rate;
      } else {
        i = 0;
      }
    }
    t->grow_counter = i;
  }

  UpdateTownRadius(t);
}

void OnTick_Town()
{
  if (_game_mode == GM_EDITOR) return;

  /* Make sure each town's tickhandler invocation frequency is about the
   * same - TOWN_GROWTH_FREQUENCY - independent on the number of towns. */
  for (_cur_town_iter += GetMaxTownIndex() + 1;
       _cur_town_iter >= TOWN_GROWTH_FREQUENCY;
       _cur_town_iter -= TOWN_GROWTH_FREQUENCY) {
    uint32 i = _cur_town_ctr;

    if (++_cur_town_ctr > GetMaxTownIndex())
      _cur_town_ctr = 0;

    if (IsValidTownID(i)) TownTickHandler(GetTown(i));
  }
}

static RoadBits GetTownRoadBits(TileIndex tile)
{
  TrackBits b = GetAnyRoadTrackBits(tile, ROADTYPE_ROAD);
  RoadBits r = ROAD_NONE;

  if (b == TRACK_BIT_NONE) return r;
  if (b & TRACK_BIT_X)     r |= ROAD_X;
  if (b & TRACK_BIT_Y)     r |= ROAD_Y;
  if (b & TRACK_BIT_UPPER) r |= ROAD_NE | ROAD_NW;
  if (b & TRACK_BIT_LOWER) r |= ROAD_SE | ROAD_SW;
  if (b & TRACK_BIT_LEFT)  r |= ROAD_NW | ROAD_SW;
  if (b & TRACK_BIT_RIGHT) r |= ROAD_NE | ROAD_SE;
  return r;
}

static bool IsNeighborRoadTile(TileIndex tile, const DiagDirection dir, uint dist_multi)
{
  /* Lookup table for the used diff values */
  const TileIndexDiff tid_lt[3] = {
    TileOffsByDiagDir(ChangeDiagDir(dir, DIAGDIRDIFF_90RIGHT)),
    TileOffsByDiagDir(ChangeDiagDir(dir, DIAGDIRDIFF_90LEFT)),
    TileOffsByDiagDir(ReverseDiagDir(dir)),
  };

  /* We add 1 to the distance because we want to get 1 for
   * the min distance multiplyer and not 0.
   * Therefore we start at 4. The 4 is used because
   * there are 4 tiles per distance step to check. */
  dist_multi = (dist_multi + 1) * 4;
  for (uint pos = 4; pos < dist_multi; pos++) {
    TileIndexDiff cur = 0;
    /* For each even value of pos add the right TileIndexDiff
     * for each uneven value the left TileIndexDiff
     * for each with 2nd bit set (2,3,6,7,..) add the reversed TileIndexDiff */
    cur += tid_lt[(pos & 1) ? 0 : 1];
    if (pos & 2) cur += tid_lt[2];

    cur = (uint)(pos / 4) * cur; // Multiply for the fitting distance
    if (GetTownRoadBits(TILE_ADD(tile, cur)) & DiagDirToRoadBits((pos & 2) ? dir : ReverseDiagDir(dir))) return true;
  }
  return false;
}

static bool IsRoadAllowedHere(Town *t, TileIndex tile, DiagDirection dir)
{
  if (TileX(tile) < 2 || TileX(tile) >= MapMaxX() || TileY(tile) < 2 || TileY(tile) >= MapMaxY()) return false;

  Slope cur_slope, desired_slope;

  for (;;) {
    /* Check if there already is a road at this point? */
    if (GetTownRoadBits(tile) == ROAD_NONE) {
      /* No, try if we are able to build a road piece there.
       * If that fails clear the land, and if that fails exit.
       * This is to make sure that we can build a road here later. */
      if (CmdFailed(DoCommand(tile, ((dir == DIAGDIR_NW || dir == DIAGDIR_SE) ? ROAD_X : ROAD_Y), 0, DC_AUTO, CMD_BUILD_ROAD)) &&
          CmdFailed(DoCommand(tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR)))
        return false;
    }

    cur_slope = GetTileSlope(tile, NULL);
    if (cur_slope == SLOPE_FLAT) {
no_slope:
      /* Tile has no slope */
      switch (t->GetActiveLayout()) {
        default: NOT_REACHED();

        case TL_ORIGINAL: // Disallow the road if any neighboring tile has a road (distance: 1)
          return !IsNeighborRoadTile(tile, dir, 1);

        case TL_BETTER_ROADS: // Disallow the road if any neighboring tile has a road (distance: 1 and 2).
          return !IsNeighborRoadTile(tile, dir, 2);
      }
    }

    /* If the tile is not a slope in the right direction, then
     * maybe terraform some. */
    desired_slope = (dir == DIAGDIR_NW || dir == DIAGDIR_SE) ? SLOPE_NW : SLOPE_NE;
    if (desired_slope != cur_slope && ComplementSlope(desired_slope) != cur_slope) {
      if (Chance16(1, 8)) {
        CommandCost res = CMD_ERROR;
        if (!_generating_world && Chance16(1, 10)) {
          /* Note: Do not replace "^ SLOPE_ELEVATED" with ComplementSlope(). The slope might be steep. */
          res = DoCommand(tile, Chance16(1, 16) ? cur_slope : cur_slope ^ SLOPE_ELEVATED, 0,
              DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
        }
        if (CmdFailed(res) && Chance16(1, 3)) {
          /* We can consider building on the slope, though. */
          goto no_slope;
        }
      }
      return false;
    }
    return true;
  }
}

static bool TerraformTownTile(TileIndex tile, int edges, int dir)
{
  TILE_ASSERT(tile);

  CommandCost r = DoCommand(tile, edges, dir, DC_AUTO | DC_NO_WATER, CMD_TERRAFORM_LAND);
  if (CmdFailed(r) || r.GetCost() >= (_price.terraform + 2) * 8) return false;
  DoCommand(tile, edges, dir, DC_AUTO | DC_NO_WATER | DC_EXEC, CMD_TERRAFORM_LAND);
  return true;
}

static void LevelTownLand(TileIndex tile)
{
  TILE_ASSERT(tile);

  /* Don't terraform if land is plain or if there's a house there. */
  if (IsTileType(tile, MP_HOUSE)) return;
  Slope tileh = GetTileSlope(tile, NULL);
  if (tileh == SLOPE_FLAT) return;

  /* First try up, then down */
  if (!TerraformTownTile(tile, ~tileh & SLOPE_ELEVATED, 1)) {
    TerraformTownTile(tile, tileh & SLOPE_ELEVATED, 0);
  }
}

static RoadBits GetTownRoadGridElement(Town *t, TileIndex tile, DiagDirection dir)
{
  /* align the grid to the downtown */
  TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile); // Vector from downtown to the tile
  RoadBits rcmd = ROAD_NONE;

  switch (t->GetActiveLayout()) {
    default: NOT_REACHED();

    case TL_2X2_GRID:
      if ((grid_pos.x % 3) == 0) rcmd |= ROAD_Y;
      if ((grid_pos.y % 3) == 0) rcmd |= ROAD_X;
      break;

    case TL_3X3_GRID:
      if ((grid_pos.x % 4) == 0) rcmd |= ROAD_Y;
      if ((grid_pos.y % 4) == 0) rcmd |= ROAD_X;
      break;
  }

  /* Optimise only X-junctions */
  if (rcmd != ROAD_ALL) return rcmd;

  RoadBits rb_template;

  switch (GetTileSlope(tile, NULL)) {
    default:       rb_template = ROAD_ALL; break;
    case SLOPE_W:  rb_template = ROAD_NW | ROAD_SW; break;
    case SLOPE_SW: rb_template = ROAD_Y  | ROAD_SW; break;
    case SLOPE_S:  rb_template = ROAD_SW | ROAD_SE; break;
    case SLOPE_SE: rb_template = ROAD_X  | ROAD_SE; break;
    case SLOPE_E:  rb_template = ROAD_SE | ROAD_NE; break;
    case SLOPE_NE: rb_template = ROAD_Y  | ROAD_NE; break;
    case SLOPE_N:  rb_template = ROAD_NE | ROAD_NW; break;
    case SLOPE_NW: rb_template = ROAD_X  | ROAD_NW; break;
    case SLOPE_STEEP_W:
    case SLOPE_STEEP_S:
    case SLOPE_STEEP_E:
    case SLOPE_STEEP_N:
      rb_template = ROAD_NONE;
      break;
  }

  /* Stop if the template is compatible to the growth dir */
  if (DiagDirToRoadBits(ReverseDiagDir(dir)) & rb_template) return rb_template;
  /* If not generate a straight road in the direction of the growth */
  return DiagDirToRoadBits(dir) | DiagDirToRoadBits(ReverseDiagDir(dir));
}

static bool GrowTownWithExtraHouse(Town *t, TileIndex tile)
{
  /* We can't look further than that. */
  if (TileX(tile) < 2 || TileY(tile) < 2 || MapMaxX() <= TileX(tile) || MapMaxY() <= TileY(tile)) return false;

  uint counter = 0; // counts the house neighbor tiles

  /* Check the tiles E,N,W and S of the current tile for houses */
  for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {

    if (IsTileType(TileAddByDiagDir(tile, dir), MP_HOUSE)) counter++;

    /* If there are enough neighbors stop here */
    if (counter >= 3) {
      if (BuildTownHouse(t, tile)) {
        _grow_town_result = GROWTH_SUCCEED;
        return true;
      }
      return false;
    }
  }
  return false;
}

static bool GrowTownWithRoad(const Town *t, TileIndex tile, RoadBits rcmd)
{
  if (CmdSucceeded(DoCommand(tile, rcmd, t->index, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD))) {
    _grow_town_result = GROWTH_SUCCEED;
    return true;
  }
  return false;
}