/**
* Make a normal road tile.
* @param t Tile to make a normal road.
* @param bits Road bits to set for all present road types.
* @param rot New present road types.
* @param town Town ID if the road is a town-owned road.
* @param road New owner of road.
* @param tram New owner of tram tracks.
*/
public static void MakeRoadNormal(this TileIndex t, RoadBits bits, RoadTypes rot, TownID town, Owner road,
Owner tram)
{
TileMap.SetTileType(t, TileType.MP_ROAD);
TileMap.SetTileOwner(t, road);
Map._m[t].m2 = town;
Map._m[t].m3 = (BitMath.HasBit(rot, RoadType.ROADTYPE_TRAM) ? bits : 0);
Map._m[t].m4 = 0;
Map._m[t].m5 = (BitMath.HasBit(rot, RoadType.ROADTYPE_ROAD) ? bits : 0) |
RoadTileType.ROAD_TILE_NORMAL << 6;
BitMath.SB(Map._me[t].m6, 2, 4, 0);
Map._me[t].m7 = rot << 6;
SetRoadOwner(t, RoadType.ROADTYPE_TRAM, tram);
}
/**
* Set the present road bits for a specific road type.
* @param t The tile to change.
* @param r The new road bits.
* @param rt Road type.
* @pre IsNormalRoad(t)
*/
public static void SetRoadBits(this TileIndex t, RoadBits r, RoadType rt)
{
Debug.Assert(IsNormalRoad(t)); // XXX incomplete
switch (rt)
{
default: throw new NotReachedException();
case RoadType.ROADTYPE_ROAD:
Map._m[t].m5 = BitMath.SB(Map._m[t].m5, 0, 4, r);
break;
case RoadType.ROADTYPE_TRAM:
Map._m[t].m3 = BitMath.SB(Map._m[t].m3, 0, 4, r);
break;
}
}
/**
* Clean up unnecessary RoadBits of a planed tile.
* @param tile current tile
* @param org_rb planed RoadBits
* @return optimised RoadBits
*/
RoadBits CleanUpRoadBits(TileIndex tile, RoadBits org_rb)
{
if (!TileMap.IsValidTile(tile))
{
return(RoadBits.ROAD_NONE);
}
for (DiagDirection dir = DiagDirection.DIAGDIR_BEGIN; dir < DiagDirection.DIAGDIR_END; dir++)
{
TileIndex neighbor_tile = TileAddByDiagDir(tile, dir);
/* Get the Roadbit pointing to the neighbor_tile */
RoadBits target_rb = DiagDirToRoadBits(dir);
/* If the roadbit is in the current plan */
if (org_rb & target_rb)
{
bool connective = false;
const RoadBits mirrored_rb = MirrorRoadBits(target_rb);
if (TileMap.IsValidTile(neighbor_tile))
{
switch (TileMap.GetTileType(neighbor_tile))
{
/* Always connective ones */
case TileType.MP_CLEAR:
case TileType.MP_TREES:
connective = true;
break;
/* The conditionally connective ones */
case TileType.MP_TUNNELBRIDGE:
case TileType.MP_STATION:
case TileType.MP_ROAD:
if (IsNormalRoadTile(neighbor_tile))
{
/* Always connective */
connective = true;
}
else
{
const RoadBits neighbor_rb =
GetAnyRoadBits(neighbor_tile, RoadType.ROADTYPE_ROAD) |
GetAnyRoadBits(neighbor_tile, RoadType.ROADTYPE_TRAM);
/* Accept only connective tiles */
connective = (neighbor_rb & mirrored_rb) != RoadBits.ROAD_NONE;
}
break;
case TileType.MP_RAILWAY:
connective = IsPossibleCrossing(neighbor_tile, DiagDirToAxis(dir));
break;
case TileType.MP_WATER:
/* Check for real water tile */
connective = !WaterMap.IsWater(neighbor_tile);
break;
/* The definitely not connective ones */
default: break;
}
}
/* If the neighbor tile is inconnective, remove the planed road connection to it */
if (!connective)
{
org_rb ^= target_rb;
}
}
}
return(org_rb);
}
