src/script/api/script_tunnel.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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 <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /** @file script_tunnel.cpp Implementation of ScriptTunnel. */
  11
  12 #include "../../stdafx.h"
  13 #include "script_tunnel.hpp"
  14 #include "script_rail.hpp"
  15 #include "../script_instance.hpp"
  16 #include "../../tunnel_map.h"
  17
  18 #include "../../safeguards.h"
  19
  20 /* static */ bool ScriptTunnel::IsTunnelTile(TileIndex tile)
  21 {
  22         if (!::IsValidTile(tile)) return false;
  23         return ::IsTunnelTile(tile);
  24 }
  25
  26 /* static */ TileIndex ScriptTunnel::GetOtherTunnelEnd(TileIndex tile)
  27 {
  28         if (!::IsValidTile(tile)) return INVALID_TILE;
  29
  30         /* If it's a tunnel already, take the easy way out! */
  31         if (IsTunnelTile(tile)) return ::GetOtherTunnelEnd(tile);
  32
  33         int start_z;
  34         Slope start_tileh = ::GetTileSlope(tile, &start_z);
  35         DiagDirection direction = ::GetInclinedSlopeDirection(start_tileh);
  36         if (direction == INVALID_DIAGDIR) return INVALID_TILE;
  37
  38         TileIndexDiff delta = ::TileOffsByDiagDir(direction);
  39         int end_z;
  40         do {
  41                 tile += delta;
  42                 if (!::IsValidTile(tile)) return INVALID_TILE;
  43
  44                 ::GetTileSlope(tile, &end_z);
  45         } while (start_z != end_z);
  46
  47         return tile;
  48 }
  49
  50 /**
  51  * Helper function to connect a just built tunnel to nearby roads.
  52  * @param instance The script instance we have to built the road for.
  53  */
  54 static void _DoCommandReturnBuildTunnel2(class ScriptInstance *instance)
  55 {
  56         if (!ScriptTunnel::_BuildTunnelRoad2()) {
  57                 ScriptInstance::DoCommandReturn(instance);
  58                 return;
  59         }
  60
  61         /* This can never happen, as in test-mode this callback is never executed,
  62          *  and in execute-mode, the other callback is called. */
  63         NOT_REACHED();
  64 }
  65
  66 /**
  67  * Helper function to connect a just built tunnel to nearby roads.
  68  * @param instance The script instance we have to built the road for.
  69  */
  70 static void _DoCommandReturnBuildTunnel1(class ScriptInstance *instance)
  71 {
  72         if (!ScriptTunnel::_BuildTunnelRoad1()) {
  73                 ScriptInstance::DoCommandReturn(instance);
  74                 return;
  75         }
  76
  77         /* This can never happen, as in test-mode this callback is never executed,
  78          *  and in execute-mode, the other callback is called. */
  79         NOT_REACHED();
  80 }
  81
  82 /* static */ bool ScriptTunnel::BuildTunnel(ScriptVehicle::VehicleType vehicle_type, TileIndex start)
  83 {
  84         EnforcePrecondition(false, ::IsValidTile(start));
  85         EnforcePrecondition(false, vehicle_type == ScriptVehicle::VT_RAIL || vehicle_type == ScriptVehicle::VT_ROAD);
  86         EnforcePrecondition(false, vehicle_type != ScriptVehicle::VT_RAIL || ScriptRail::IsRailTypeAvailable(ScriptRail::GetCurrentRailType()));
  87         EnforcePrecondition(false, vehicle_type != ScriptVehicle::VT_ROAD || ScriptRoad::IsRoadTypeAvailable(ScriptRoad::GetCurrentRoadType()));
  88         EnforcePrecondition(false, ScriptObject::GetCompany() != OWNER_DEITY || vehicle_type == ScriptVehicle::VT_ROAD);
  89
  90         uint type = 0;
  91         if (vehicle_type == ScriptVehicle::VT_ROAD) {
  92                 type |= (TRANSPORT_ROAD << 8);
  93                 type |= ::RoadTypeToRoadTypes((::RoadType)ScriptObject::GetRoadType());
  94         } else {
  95                 type |= (TRANSPORT_RAIL << 8);
  96                 type |= ScriptRail::GetCurrentRailType();
  97         }
  98
  99         /* For rail we do nothing special */
 100         if (vehicle_type == ScriptVehicle::VT_RAIL) {
 101                 return ScriptObject::DoCommand(start, type, 0, CMD_BUILD_TUNNEL);
 102         }
 103
 104         ScriptObject::SetCallbackVariable(0, start);
 105         return ScriptObject::DoCommand(start, type, 0, CMD_BUILD_TUNNEL, nullptr, &::_DoCommandReturnBuildTunnel1);
 106 }
 107
 108 /* static */ bool ScriptTunnel::_BuildTunnelRoad1()
 109 {
 110         /* Build the piece of road on the 'start' side of the tunnel */
 111         TileIndex end = ScriptObject::GetCallbackVariable(0);
 112         TileIndex start = ScriptTunnel::GetOtherTunnelEnd(end);
 113
 114         DiagDirection dir_1 = ::DiagdirBetweenTiles(end, start);
 115         DiagDirection dir_2 = ::ReverseDiagDir(dir_1);
 116
 117         return ScriptObject::DoCommand(start + ::TileOffsByDiagDir(dir_1), ::DiagDirToRoadBits(dir_2) | (ScriptObject::GetRoadType() << 4), 0, CMD_BUILD_ROAD, nullptr, &::_DoCommandReturnBuildTunnel2);
 118 }
 119
 120 /* static */ bool ScriptTunnel::_BuildTunnelRoad2()
 121 {
 122         /* Build the piece of road on the 'end' side of the tunnel */
 123         TileIndex end = ScriptObject::GetCallbackVariable(0);
 124         TileIndex start = ScriptTunnel::GetOtherTunnelEnd(end);
 125
 126         DiagDirection dir_1 = ::DiagdirBetweenTiles(end, start);
 127         DiagDirection dir_2 = ::ReverseDiagDir(dir_1);
 128
 129         return ScriptObject::DoCommand(end + ::TileOffsByDiagDir(dir_2), ::DiagDirToRoadBits(dir_1) | (ScriptObject::GetRoadType() << 4), 0, CMD_BUILD_ROAD);
 130 }
 131
 132 /* static */ bool ScriptTunnel::RemoveTunnel(TileIndex tile)
 133 {
 134         EnforcePrecondition(false, ScriptObject::GetCompany() != OWNER_DEITY);
 135         EnforcePrecondition(false, IsTunnelTile(tile));
 136
 137         return ScriptObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR);
 138 }