525 static int32 DoClearTunnel(TileIndex tile, uint32 flags)

   526 {

   527 	Town *t = NULL;

   528 	TileIndex endtile;

   529 	uint length;

   530 

   531 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   532 

   533 	if (!CheckAllowRemoveTunnelBridge(tile)) return CMD_ERROR;

   534 

   535 	endtile = CheckTunnelBusy(tile, &length);

   536 	if (endtile == INVALID_TILE) return CMD_ERROR;

   537 

   538 	_build_tunnel_endtile = endtile;

   539 

   540 	if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR) {

   541 		t = ClosestTownFromTile(tile, (uint)-1); // town penalty rating

   542 

   543 		/* Check if you are allowed to remove the tunnel owned by a town

   544 		 * Removal depends on difficulty settings */

   545 		if (!CheckforTownRating(flags, t, TUNNELBRIDGE_REMOVE)) {

   546 			SetDParam(0, t->index);

   547 			return_cmd_error(STR_2009_LOCAL_AUTHORITY_REFUSES);

   548 		}

   549 	}

   550 

   551 	if (flags & DC_EXEC) {

   552 		// We first need to request the direction before calling DoClearSquare

   553 		//  else the direction is always 0.. dah!! ;)

   554 		DiagDirection dir = GetTunnelDirection(tile);

   555 		Track track;

   556 

   557 		// Adjust the town's player rating. Do this before removing the tile owner info.

   558 		if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR)

   559 			ChangeTownRating(t, RATING_TUNNEL_BRIDGE_DOWN_STEP, RATING_TUNNEL_BRIDGE_MINIMUM);

   560 

   561 		DoClearSquare(tile);

   562 		DoClearSquare(endtile);

   563 		UpdateSignalsOnSegment(tile, ReverseDiagDir(dir));

   564 		UpdateSignalsOnSegment(endtile, dir);

   565 		track = AxisToTrack(DiagDirToAxis(dir));

   566 		YapfNotifyTrackLayoutChange(tile, track);

   567 		YapfNotifyTrackLayoutChange(endtile, track);

   568 	}

   569 	return _price.clear_tunnel * (length + 1);

   570 }

   571 

   572 

   644 static int32 ClearTile_Tunnel(TileIndex tile, byte flags)

   645 {

   646 	assert(IsTunnelTile(tile));

   647 	if (flags & DC_AUTO) return_cmd_error(STR_5006_MUST_DEMOLISH_TUNNEL_FIRST);

   648 	return DoClearTunnel(tile, flags);

   649 }

   790 /**

   791  * Draws a tunnel tile.

   792  * Please note that in this code, "roads" are treated as railtype 1, whilst the real railtypes are 0, 2 and 3

   793  */

   794 static void DrawTile_Tunnel(TileInfo *ti)

   795 {

   796 	uint32 image;

   797 

   798 	if (GetTunnelTransportType(ti->tile) == TRANSPORT_RAIL) {

   799 		image = GetRailTypeInfo(GetRailType(ti->tile))->base_sprites.tunnel;

   800 	} else {

   801 		image = SPR_TUNNEL_ENTRY_REAR_ROAD;

   802 	}

   803 

   804 	if (HasTunnelSnowOrDesert(ti->tile)) image += 32;

   805 

   806 	image += GetTunnelDirection(ti->tile) * 2;

   807 	DrawGroundSprite(image);

   808 	if (GetRailType(ti->tile) == RAILTYPE_ELECTRIC) DrawCatenary(ti);

   809 

   810 	AddSortableSpriteToDraw(image+1, ti->x + TILE_SIZE - 1, ti->y + TILE_SIZE - 1, 1, 1, 8, (byte)ti->z);

   811 	DrawBridgeMiddle(ti);

   812 }

   997 /** Gets the absolute z coordinate of a point inside a tunnel tile

   998  *  When we're on the track (that means between position 5 and 10)

   999  *  on the coordinate perpendicular to the track it returns only the

  1000  *  base height of the tile (because the track is horizontal).

  1001  *  Outside this range (from 0 to 4 and from 11 to 15) it returns the

  1002  *  "true" Z coordinate of the tile by taking the slope into account

  1003  *  @param tile The index of the tile we are talking about

  1004  *  @param x Absolute or relative x coordinate

  1005  *  @param y Absolute or relative y coordinate

  1006  *  @return Absolute z coordinate

  1007  */

  1008 static uint GetSlopeZ_Tunnel(TileIndex tile, uint x, uint y)

  1009 {

  1010 	uint z, pos;

  1011 	Slope tileh = GetTileSlope(tile, &z);

  1012 

  1013 	x &= 0xF;

  1014 	y &= 0xF;

  1015 

  1016 	pos = (DiagDirToAxis(GetTunnelDirection(tile)) == AXIS_X ? y : x);

  1017 

  1018 	// In the tunnel entrance?

  1019 	if (5 <= pos && pos <= 10) return z;

  1020 

  1021 	return z + GetPartialZ(x, y, tileh);

  1022 }

  1023 

  1078 static Slope GetSlopeTileh_Tunnel(TileIndex tile, Slope tileh)

  1079 {

  1080 	return tileh;

  1081 }

  1082 

  1094 }

  1095 

  1096 static void GetAcceptedCargo_Tunnel(TileIndex tile, AcceptedCargo ac)

  1097 {

  1098 	/* not used */

  1138 static void GetTileDesc_Tunnel(TileIndex tile, TileDesc *td)

  1139 {

  1140 	td->str = (GetTunnelTransportType(tile) == TRANSPORT_RAIL) ?  STR_5017_RAILROAD_TUNNEL : STR_5018_ROAD_TUNNEL;

  1141 	td->owner = GetTileOwner(tile);

  1142 }

  1143 

  1156 static void AnimateTile_Bridge(TileIndex tile)

  1157 {

  1158 	/* not used */

  1159 }

  1160 

  1161 static void TileLoop_Tunnel(TileIndex tile)

  1162 {

  1163 	bool snow_or_desert = HasTunnelSnowOrDesert(tile);

  1164 	switch (_opt.landscape) {

  1165 		case LT_HILLY:

  1166 			if (snow_or_desert != (GetTileZ(tile) > _opt.snow_line)) {

  1167 				SetTunnelSnowOrDesert(tile, !snow_or_desert);

  1168 				MarkTileDirtyByTile(tile);

  1169 			}

  1170 			break;

  1171 

  1172 		case LT_DESERT:

  1173 			if (GetTropicZone(tile) == TROPICZONE_DESERT && !snow_or_desert) {

  1174 				SetTunnelSnowOrDesert(tile, true);

  1175 				MarkTileDirtyByTile(tile);

  1176 			}

  1177 			break;

  1178 	}

  1179 }

  1206 static void ClickTile_Bridge(TileIndex tile)

  1207 {

  1208 	/* not used */

  1209 }

  1210 

  1211 

  1212 static uint32 GetTileTrackStatus_Tunnel(TileIndex tile, TransportType mode)

  1213 {

  1214 	if (GetTunnelTransportType(tile) != mode) return 0;

  1215 	return AxisToTrackBits(DiagDirToAxis(GetTunnelDirection(tile))) * 0x101;

  1216 }

  1235 static void ChangeTileOwner_Bridge(TileIndex tile, PlayerID old_player, PlayerID new_player)

  1236 {

  1237 	if (!IsTileOwner(tile, old_player)) return;

  1238 

  1239 	if (new_player != PLAYER_SPECTATOR) {

  1240 		SetTileOwner(tile, new_player);

  1241 	} else {

  1242 		DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);

  1243 	}

  1244 }

  1245 

  1246 

  1247 static const byte _tunnel_fractcoord_1[4]    = {0x8E, 0x18, 0x81, 0xE8};

  1248 static const byte _tunnel_fractcoord_2[4]    = {0x81, 0x98, 0x87, 0x38};

  1249 static const byte _tunnel_fractcoord_3[4]    = {0x82, 0x88, 0x86, 0x48};

  1250 static const byte _exit_tunnel_track[4]      = {1, 2, 1, 2};

  1251 

  1252 static const byte _road_exit_tunnel_state[4] = {8, 9, 0, 1};

  1253 static const byte _road_exit_tunnel_frame[4] = {2, 7, 9, 4};

  1254 

  1255 static const byte _tunnel_fractcoord_4[4]    = {0x52, 0x85, 0x98, 0x29};

  1256 static const byte _tunnel_fractcoord_5[4]    = {0x92, 0x89, 0x58, 0x25};

  1257 static const byte _tunnel_fractcoord_6[4]    = {0x92, 0x89, 0x56, 0x45};

  1258 static const byte _tunnel_fractcoord_7[4]    = {0x52, 0x85, 0x96, 0x49};

  1259 

  1260 static uint32 VehicleEnter_Tunnel(Vehicle *v, TileIndex tile, int x, int y)

  1261 {

  1262 	int z = GetSlopeZ(x, y) - v->z_pos;

  1263 

  1264 	byte fc;

  1265 	DiagDirection dir;

  1266 	DiagDirection vdir;

  1267 

  1268 	if (myabs(z) > 2) return 8;

  1269 

  1270 	if (v->type == VEH_Train) {

  1271 		fc = (x & 0xF) + (y << 4);

  1272 

  1273 		dir = GetTunnelDirection(tile);

  1274 		vdir = DirToDiagDir(v->direction);

  1275 

  1276 		if (v->u.rail.track != 0x40 && dir == vdir) {

  1277 			if (IsFrontEngine(v) && fc == _tunnel_fractcoord_1[dir]) {

  1278 				if (!PlayVehicleSound(v, VSE_TUNNEL) && v->spritenum < 4) {

  1279 					SndPlayVehicleFx(SND_05_TRAIN_THROUGH_TUNNEL, v);

  1280 				}

  1281 				return 0;

  1282 			}

  1283 			if (fc == _tunnel_fractcoord_2[dir]) {

  1284 				v->tile = tile;

  1285 				v->u.rail.track = 0x40;

  1286 				v->vehstatus |= VS_HIDDEN;

  1287 				return 4;

  1288 			}

  1289 		}

  1290 

  1291 		if (dir == ReverseDiagDir(vdir) && fc == _tunnel_fractcoord_3[dir] && z == 0) {

  1292 			/* We're at the tunnel exit ?? */

  1293 			v->tile = tile;

  1294 			v->u.rail.track = _exit_tunnel_track[dir];

  1295 			assert(v->u.rail.track);

  1296 			v->vehstatus &= ~VS_HIDDEN;

  1297 			return 4;

  1298 		}

  1299 	} else if (v->type == VEH_Road) {

  1300 		fc = (x & 0xF) + (y << 4);

  1301 		dir = GetTunnelDirection(tile);

  1302 		vdir = DirToDiagDir(v->direction);

  1303 

  1304 		// Enter tunnel?

  1305 		if (v->u.road.state != 0xFF && dir == vdir) {

  1306 			if (fc == _tunnel_fractcoord_4[dir] ||

  1307 					fc == _tunnel_fractcoord_5[dir]) {

  1308 				v->tile = tile;

  1309 				v->u.road.state = 0xFF;

  1310 				v->vehstatus |= VS_HIDDEN;

  1311 				return 4;

  1312 			} else {

  1313 				return 0;

  1314 			}

  1315 		}

  1316 

  1317 		if (dir == ReverseDiagDir(vdir) && (

  1318 					/* We're at the tunnel exit ?? */

  1319 					fc == _tunnel_fractcoord_6[dir] ||

  1320 					fc == _tunnel_fractcoord_7[dir]

  1321 				) &&

  1322 				z == 0) {

  1323 			v->tile = tile;

  1324 			v->u.road.state = _road_exit_tunnel_state[dir];

  1325 			v->u.road.frame = _road_exit_tunnel_frame[dir];

  1326 			v->vehstatus &= ~VS_HIDDEN;

  1327 			return 4;

  1328 		}

  1329 	}

  1330 	return 0;

  1331 }

  1384 

  1385 const TileTypeProcs _tile_type_tunnel_procs = {

  1386 	DrawTile_Tunnel,           /* draw_tile_proc */

  1387 	GetSlopeZ_Tunnel,          /* get_slope_z_proc */

  1388 	ClearTile_Tunnel,          /* clear_tile_proc */

  1389 	GetAcceptedCargo_Tunnel,   /* get_accepted_cargo_proc */

  1390 	GetTileDesc_Tunnel,        /* get_tile_desc_proc */

  1391 	GetTileTrackStatus_Tunnel, /* get_tile_track_status_proc */

  1392 	ClickTile_Tunnel,          /* click_tile_proc */

  1393 	AnimateTile_Tunnel,        /* animate_tile_proc */

  1394 	TileLoop_Tunnel,           /* tile_loop_clear */

  1395 	ChangeTileOwner_Tunnel,    /* change_tile_owner_clear */

  1396 	NULL,                            /* get_produced_cargo_proc */

  1397 	VehicleEnter_Tunnel,       /* vehicle_enter_tile_proc */

  1398 	GetSlopeTileh_Tunnel,      /* get_slope_tileh_proc */

  1399 };