clear_map.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef CLEAR_MAP_H
#define CLEAR_MAP_H
 
#include "bridge_map.h"
#include "industry_type.h"
 
static constexpr size_t CLEAR_GROUND_BITS = 3; 

enum class ClearGround : uint8_t {
  Grass = 0, 
  Rough = 1, 
  Rocks = 2, 
  Fields = 3, 
  Desert = 5, 
 
  End, 
  MaxSize = 1U << CLEAR_GROUND_BITS, 
};
 
static_assert(ClearGround::End <= ClearGround::MaxSize);

inline bool IsSnowTile(Tile t)
{
  assert(IsTileType(t, TileType::Clear));
  return HasBit(t.m3(), 4);
}

inline ClearGround GetClearGround(Tile t)
{
  assert(IsTileType(t, TileType::Clear));
  return static_cast<ClearGround>(GB(t.m5(), 2, CLEAR_GROUND_BITS));
}

inline bool IsClearGround(Tile t, ClearGround ct)
{
  return GetClearGround(t) == ct;
}
 

inline uint GetClearDensity(Tile t)
{
  assert(IsTileType(t, TileType::Clear));
  return GB(t.m5(), 0, 2);
}

inline void AddClearDensity(Tile t, int d)
{
  assert(IsTileType(t, TileType::Clear)); // XXX incomplete
  t.m5() += d;
}

inline void SetClearDensity(Tile t, uint d)
{
  assert(IsTileType(t, TileType::Clear));
  SB(t.m5(), 0, 2, d);
}
 

inline uint GetClearCounter(Tile t)
{
  assert(IsTileType(t, TileType::Clear));
  return GB(t.m5(), 5, 3);
}

inline void AddClearCounter(Tile t, int c)
{
  assert(IsTileType(t, TileType::Clear)); // XXX incomplete
  t.m5() += c << 5;
}

inline void SetClearCounter(Tile t, uint c)
{
  assert(IsTileType(t, TileType::Clear)); // XXX incomplete
  SB(t.m5(), 5, 3, c);
}
 

inline void SetClearGroundDensity(Tile t, ClearGround type, uint density)
{
  assert(IsTileType(t, TileType::Clear)); // XXX incomplete
  t.m5() = 0 << 5 | to_underlying(type) << 2 | density;
}
 

inline uint GetFieldType(Tile t)
{
  assert(GetClearGround(t) == ClearGround::Fields);
  return GB(t.m3(), 0, 4);
}

inline void SetFieldType(Tile t, uint f)
{
  assert(GetClearGround(t) == ClearGround::Fields); // XXX incomplete
  SB(t.m3(), 0, 4, f);
}

inline IndustryID GetIndustryIndexOfField(Tile t)
{
  assert(GetClearGround(t) == ClearGround::Fields);
  return(IndustryID) t.m2();
}

inline void SetIndustryIndexOfField(Tile t, IndustryID i)
{
  assert(GetClearGround(t) == ClearGround::Fields);
  t.m2() = i.base();
}
 

inline uint GetFence(Tile t, DiagDirection side)
{
  assert(IsClearGround(t, ClearGround::Fields));
  switch (side) {
    default: NOT_REACHED();
    case DIAGDIR_SE: return GB(t.m4(), 2, 3);
    case DIAGDIR_SW: return GB(t.m4(), 5, 3);
    case DIAGDIR_NE: return GB(t.m3(), 5, 3);
    case DIAGDIR_NW: return GB(t.m6(), 2, 3);
  }
}

inline void SetFence(Tile t, DiagDirection side, uint h)
{
  assert(IsClearGround(t, ClearGround::Fields));
  switch (side) {
    default: NOT_REACHED();
    case DIAGDIR_SE: SB(t.m4(), 2, 3, h); break;
    case DIAGDIR_SW: SB(t.m4(), 5, 3, h); break;
    case DIAGDIR_NE: SB(t.m3(), 5, 3, h); break;
    case DIAGDIR_NW: SB(t.m6(), 2, 3, h); break;
  }
}
 

inline void MakeClear(Tile t, ClearGround g, uint density)
{
  SetTileType(t, TileType::Clear);
  t.m1() = 0;
  SetTileOwner(t, OWNER_NONE);
  t.m2() = 0;
  t.m3() = 0;
  t.m4() = 0 << 5 | 0 << 2;
  SetClearGroundDensity(t, g, density); // Sets m5
  t.m6() = 0;
  t.m7() = 0;
  t.m8() = 0;
}
 

inline void MakeField(Tile t, uint field_type, IndustryID industry)
{
  SetTileType(t, TileType::Clear);
  t.m1() = 0;
  SetTileOwner(t, OWNER_NONE);
  t.m2() = industry.base();
  t.m3() = field_type;
  t.m4() = 0 << 5 | 0 << 2;
  SetClearGroundDensity(t, ClearGround::Fields, 3);
  SB(t.m6(), 2, 6, 0);
  t.m7() = 0;
  t.m8() = 0;
}

inline void MakeSnow(Tile t, uint density = 0)
{
  assert(!IsSnowTile(t));
  SetBit(t.m3(), 4);
  if (GetClearGround(t) == ClearGround::Fields) {
    SetClearGroundDensity(t, ClearGround::Grass, density);
  } else {
    SetClearDensity(t, density);
  }
}

inline void ClearSnow(Tile t)
{
  assert(IsSnowTile(t));
  ClrBit(t.m3(), 4);
  SetClearDensity(t, 3);
}
 
#endif /* CLEAR_MAP_H */