src/script/api/script_town.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file script_town.cpp Implementation of ScriptTown. */
   9
  10 #include "../../stdafx.h"
  11 #include "script_town.hpp"
  12 #include "script_map.hpp"
  13 #include "script_error.hpp"
  14 #include "../../town.h"
  15 #include "../../townname_func.h"
  16 #include "../../string_func.h"
  17 #include "../../strings_func.h"
  18 #include "../../station_base.h"
  19 #include "../../landscape.h"
  20 #include "../../town_cmd.h"
  21 #include "table/strings.h"
  22
  23 #include "../../safeguards.h"
  24
  25 /* static */ SQInteger ScriptTown::GetTownCount()
  26 {
  27         return ::Town::GetNumItems();
  28 }
  29
  30 /* static */ bool ScriptTown::IsValidTown(TownID town_id)
  31 {
  32         return ::Town::IsValidID(town_id);
  33 }
  34
  35 /* static */ std::optional<std::string> ScriptTown::GetName(TownID town_id)
  36 {
  37         if (!IsValidTown(town_id)) return std::nullopt;
  38
  39         ::SetDParam(0, town_id);
  40         return GetString(STR_TOWN_NAME);
  41 }
  42
  43 /* static */ bool ScriptTown::SetName(TownID town_id, Text *name)
  44 {
  45         CCountedPtr<Text> counter(name);
  46
  47         EnforceDeityMode(false);
  48         EnforcePrecondition(false, IsValidTown(town_id));
  49         std::string text;
  50         if (name != nullptr) {
  51                 text = name->GetDecodedText();
  52                 EnforcePreconditionCustomError(false, ::Utf8StringLength(text) < MAX_LENGTH_TOWN_NAME_CHARS, ScriptError::ERR_PRECONDITION_STRING_TOO_LONG);
  53         }
  54
  55         return ScriptObject::Command<CMD_RENAME_TOWN>::Do(town_id, text);
  56 }
  57
  58 /* static */ bool ScriptTown::SetText(TownID town_id, Text *text)
  59 {
  60         CCountedPtr<Text> counter(text);
  61
  62         EnforceDeityMode(false);
  63         EnforcePrecondition(false, IsValidTown(town_id));
  64
  65         return ScriptObject::Command<CMD_TOWN_SET_TEXT>::Do(town_id, text != nullptr ? text->GetEncodedText() : std::string{});
  66 }
  67
  68 /* static */ SQInteger ScriptTown::GetPopulation(TownID town_id)
  69 {
  70         if (!IsValidTown(town_id)) return -1;
  71         const Town *t = ::Town::Get(town_id);
  72         return t->cache.population;
  73 }
  74
  75 /* static */ SQInteger ScriptTown::GetHouseCount(TownID town_id)
  76 {
  77         if (!IsValidTown(town_id)) return -1;
  78         const Town *t = ::Town::Get(town_id);
  79         return t->cache.num_houses;
  80 }
  81
  82 /* static */ TileIndex ScriptTown::GetLocation(TownID town_id)
  83 {
  84         if (!IsValidTown(town_id)) return INVALID_TILE;
  85         const Town *t = ::Town::Get(town_id);
  86         return t->xy;
  87 }
  88
  89 /* static */ SQInteger ScriptTown::GetLastMonthProduction(TownID town_id, CargoID cargo_id)
  90 {
  91         if (!IsValidTown(town_id)) return -1;
  92         if (!ScriptCargo::IsValidCargo(cargo_id)) return -1;
  93
  94         const Town *t = ::Town::Get(town_id);
  95
  96         return t->supplied[cargo_id].old_max;
  97 }
  98
  99 /* static */ SQInteger ScriptTown::GetLastMonthSupplied(TownID town_id, CargoID cargo_id)
 100 {
 101         if (!IsValidTown(town_id)) return -1;
 102         if (!ScriptCargo::IsValidCargo(cargo_id)) return -1;
 103
 104         const Town *t = ::Town::Get(town_id);
 105
 106         return t->supplied[cargo_id].old_act;
 107 }
 108
 109 /* static */ SQInteger ScriptTown::GetLastMonthTransportedPercentage(TownID town_id, CargoID cargo_id)
 110 {
 111         if (!IsValidTown(town_id)) return -1;
 112         if (!ScriptCargo::IsValidCargo(cargo_id)) return -1;
 113
 114         const Town *t = ::Town::Get(town_id);
 115         return ::ToPercent8(t->GetPercentTransported(cargo_id));
 116 }
 117
 118 /* static */ SQInteger ScriptTown::GetLastMonthReceived(TownID town_id, ScriptCargo::TownEffect towneffect_id)
 119 {
 120         if (!IsValidTown(town_id)) return -1;
 121         if (!ScriptCargo::IsValidTownEffect(towneffect_id)) return -1;
 122
 123         const Town *t = ::Town::Get(town_id);
 124
 125         return t->received[towneffect_id].old_act;
 126 }
 127
 128 /* static */ bool ScriptTown::SetCargoGoal(TownID town_id, ScriptCargo::TownEffect towneffect_id, SQInteger goal)
 129 {
 130         EnforceDeityMode(false);
 131         EnforcePrecondition(false, IsValidTown(town_id));
 132         EnforcePrecondition(false, ScriptCargo::IsValidTownEffect(towneffect_id));
 133
 134         goal = Clamp<SQInteger>(goal, 0, UINT32_MAX);
 135
 136         return ScriptObject::Command<CMD_TOWN_CARGO_GOAL>::Do(town_id, (::TownAcceptanceEffect)towneffect_id, goal);
 137 }
 138
 139 /* static */ SQInteger ScriptTown::GetCargoGoal(TownID town_id, ScriptCargo::TownEffect towneffect_id)
 140 {
 141         if (!IsValidTown(town_id)) return -1;
 142         if (!ScriptCargo::IsValidTownEffect(towneffect_id)) return -1;
 143
 144         const Town *t = ::Town::Get(town_id);
 145
 146         switch (t->goal[towneffect_id]) {
 147                 case TOWN_GROWTH_WINTER:
 148                         if (TileHeight(t->xy) >= GetSnowLine() && t->cache.population > 90) return 1;
 149                         return 0;
 150
 151                 case TOWN_GROWTH_DESERT:
 152                         if (GetTropicZone(t->xy) == TROPICZONE_DESERT && t->cache.population > 60) return 1;
 153                         return 0;
 154
 155                 default: return t->goal[towneffect_id];
 156         }
 157 }
 158
 159 /* static */ bool ScriptTown::SetGrowthRate(TownID town_id, SQInteger days_between_town_growth)
 160 {
 161         EnforceDeityMode(false);
 162         EnforcePrecondition(false, IsValidTown(town_id));
 163         uint16_t growth_rate;
 164         switch (days_between_town_growth) {
 165                 case TOWN_GROWTH_NORMAL:
 166                         growth_rate = 0;
 167                         break;
 168
 169                 case TOWN_GROWTH_NONE:
 170                         growth_rate = TOWN_GROWTH_RATE_NONE;
 171                         break;
 172
 173                 default:
 174                         EnforcePrecondition(false, (days_between_town_growth * ::Ticks::DAY_TICKS / ::Ticks::TOWN_GROWTH_TICKS) <= MAX_TOWN_GROWTH_TICKS);
 175                         /* Don't use growth_rate 0 as it means GROWTH_NORMAL */
 176                         growth_rate = std::max<SQInteger>(days_between_town_growth * ::Ticks::DAY_TICKS, 2u) - 1;
 177                         break;
 178         }
 179
 180         return ScriptObject::Command<CMD_TOWN_GROWTH_RATE>::Do(town_id, growth_rate);
 181 }
 182
 183 /* static */ SQInteger ScriptTown::GetGrowthRate(TownID town_id)
 184 {
 185         if (!IsValidTown(town_id)) return -1;
 186
 187         const Town *t = ::Town::Get(town_id);
 188
 189         if (t->growth_rate == TOWN_GROWTH_RATE_NONE) return TOWN_GROWTH_NONE;
 190
 191         return RoundDivSU(t->growth_rate + 1, ::Ticks::DAY_TICKS);
 192 }
 193
 194 /* static */ SQInteger ScriptTown::GetDistanceManhattanToTile(TownID town_id, TileIndex tile)
 195 {
 196         return ScriptMap::DistanceManhattan(tile, GetLocation(town_id));
 197 }
 198
 199 /* static */ SQInteger ScriptTown::GetDistanceSquareToTile(TownID town_id, TileIndex tile)
 200 {
 201         return ScriptMap::DistanceSquare(tile, GetLocation(town_id));
 202 }
 203
 204 /* static */ bool ScriptTown::IsWithinTownInfluence(TownID town_id, TileIndex tile)
 205 {
 206         if (!IsValidTown(town_id)) return false;
 207
 208         const Town *t = ::Town::Get(town_id);
 209         return ((uint32_t)GetDistanceSquareToTile(town_id, tile) <= t->cache.squared_town_zone_radius[HZB_TOWN_EDGE]);
 210 }
 211
 212 /* static */ bool ScriptTown::HasStatue(TownID town_id)
 213 {
 214         EnforceCompanyModeValid(false);
 215         if (!IsValidTown(town_id)) return false;
 216
 217         return ::HasBit(::Town::Get(town_id)->statues, ScriptObject::GetCompany());
 218 }
 219
 220 /* static */ bool ScriptTown::IsCity(TownID town_id)
 221 {
 222         if (!IsValidTown(town_id)) return false;
 223
 224         return ::Town::Get(town_id)->larger_town;
 225 }
 226
 227 /* static */ SQInteger ScriptTown::GetRoadReworkDuration(TownID town_id)
 228 {
 229         if (!IsValidTown(town_id)) return -1;
 230
 231         return ::Town::Get(town_id)->road_build_months;
 232 }
 233
 234 /* static */ SQInteger ScriptTown::GetFundBuildingsDuration(TownID town_id)
 235 {
 236         if (!IsValidTown(town_id)) return -1;
 237
 238         return ::Town::Get(town_id)->fund_buildings_months;
 239 }
 240
 241 /* static */ ScriptCompany::CompanyID ScriptTown::GetExclusiveRightsCompany(TownID town_id)
 242 {
 243         EnforceCompanyModeValid(ScriptCompany::COMPANY_INVALID);
 244         if (!IsValidTown(town_id)) return ScriptCompany::COMPANY_INVALID;
 245
 246         return (ScriptCompany::CompanyID)(int8_t)::Town::Get(town_id)->exclusivity;
 247 }
 248
 249 /* static */ SQInteger ScriptTown::GetExclusiveRightsDuration(TownID town_id)
 250 {
 251         if (!IsValidTown(town_id)) return -1;
 252
 253         return ::Town::Get(town_id)->exclusive_counter;
 254 }
 255
 256 /* static */ bool ScriptTown::IsActionAvailable(TownID town_id, TownAction town_action)
 257 {
 258         EnforceCompanyModeValid(false);
 259         if (!IsValidTown(town_id)) return false;
 260
 261         return HasBit(::GetMaskOfTownActions(ScriptObject::GetCompany(), ::Town::Get(town_id)), town_action);
 262 }
 263
 264 /* static */ bool ScriptTown::PerformTownAction(TownID town_id, TownAction town_action)
 265 {
 266         EnforceCompanyModeValid(false);
 267         EnforcePrecondition(false, IsValidTown(town_id));
 268         EnforcePrecondition(false, IsActionAvailable(town_id, town_action));
 269
 270         return ScriptObject::Command<CMD_DO_TOWN_ACTION>::Do(town_id, town_action);
 271 }
 272
 273 /* static */ bool ScriptTown::ExpandTown(TownID town_id, SQInteger houses)
 274 {
 275         EnforceDeityMode(false);
 276         EnforcePrecondition(false, IsValidTown(town_id));
 277         EnforcePrecondition(false, houses > 0);
 278
 279         houses = std::min<SQInteger>(houses, UINT32_MAX);
 280
 281         return ScriptObject::Command<CMD_EXPAND_TOWN>::Do(town_id, houses);
 282 }
 283
 284 /* static */ bool ScriptTown::FoundTown(TileIndex tile, TownSize size, bool city, RoadLayout layout, Text *name)
 285 {
 286         CCountedPtr<Text> counter(name);
 287
 288         EnforceDeityOrCompanyModeValid(false);
 289         EnforcePrecondition(false, ScriptCompanyMode::IsDeity() || _settings_game.economy.found_town != TF_FORBIDDEN);
 290         EnforcePrecondition(false, ::IsValidTile(tile));
 291         EnforcePrecondition(false, size == TOWN_SIZE_SMALL || size == TOWN_SIZE_MEDIUM || size == TOWN_SIZE_LARGE)
 292         EnforcePrecondition(false, ScriptCompanyMode::IsDeity() || size != TOWN_SIZE_LARGE);
 293         if (ScriptCompanyMode::IsDeity() || _settings_game.economy.found_town == TF_CUSTOM_LAYOUT) {
 294                 EnforcePrecondition(false, layout >= ROAD_LAYOUT_ORIGINAL && layout <= ROAD_LAYOUT_RANDOM);
 295         } else {
 296                 /* The layout parameter is ignored for AIs when custom layouts is disabled. */
 297                 layout = (RoadLayout) (uint8_t)_settings_game.economy.town_layout;
 298         }
 299
 300         std::string text;
 301         if (name != nullptr) {
 302                 text = name->GetDecodedText();
 303                 EnforcePreconditionCustomError(false, ::Utf8StringLength(text) < MAX_LENGTH_TOWN_NAME_CHARS, ScriptError::ERR_PRECONDITION_STRING_TOO_LONG);
 304         }
 305         uint32_t townnameparts;
 306         if (!GenerateTownName(ScriptObject::GetRandomizer(), &townnameparts)) {
 307                 ScriptObject::SetLastError(ScriptError::ERR_NAME_IS_NOT_UNIQUE);
 308                 return false;
 309         }
 310
 311         return ScriptObject::Command<CMD_FOUND_TOWN>::Do(tile, (::TownSize)size, city, (::TownLayout)layout, false, townnameparts, text);
 312 }
 313
 314 /* static */ ScriptTown::TownRating ScriptTown::GetRating(TownID town_id, ScriptCompany::CompanyID company_id)
 315 {
 316         if (!IsValidTown(town_id)) return TOWN_RATING_INVALID;
 317         ScriptCompany::CompanyID company = ScriptCompany::ResolveCompanyID(company_id);
 318         if (company == ScriptCompany::COMPANY_INVALID) return TOWN_RATING_INVALID;
 319
 320         const Town *t = ::Town::Get(town_id);
 321         if (!HasBit(t->have_ratings, company)) {
 322                 return TOWN_RATING_NONE;
 323         } else if (t->ratings[company] <= RATING_APPALLING) {
 324                 return TOWN_RATING_APPALLING;
 325         } else if (t->ratings[company] <= RATING_VERYPOOR) {
 326                 return TOWN_RATING_VERY_POOR;
 327         } else if (t->ratings[company] <= RATING_POOR) {
 328                 return TOWN_RATING_POOR;
 329         } else if (t->ratings[company] <= RATING_MEDIOCRE) {
 330                 return TOWN_RATING_MEDIOCRE;
 331         } else if (t->ratings[company] <= RATING_GOOD) {
 332                 return TOWN_RATING_GOOD;
 333         } else if (t->ratings[company] <= RATING_VERYGOOD) {
 334                 return TOWN_RATING_VERY_GOOD;
 335         } else if (t->ratings[company] <= RATING_EXCELLENT) {
 336                 return TOWN_RATING_EXCELLENT;
 337         } else {
 338                 return TOWN_RATING_OUTSTANDING;
 339         }
 340 }
 341
 342 /* static */ SQInteger ScriptTown::GetDetailedRating(TownID town_id, ScriptCompany::CompanyID company_id)
 343 {
 344         if (!IsValidTown(town_id)) return TOWN_RATING_INVALID;
 345         ScriptCompany::CompanyID company = ScriptCompany::ResolveCompanyID(company_id);
 346         if (company == ScriptCompany::COMPANY_INVALID) return TOWN_RATING_INVALID;
 347
 348         const Town *t = ::Town::Get(town_id);
 349         return t->ratings[company];
 350 }
 351
 352 /* static */ bool ScriptTown::ChangeRating(TownID town_id, ScriptCompany::CompanyID company_id, SQInteger delta)
 353 {
 354         EnforceDeityMode(false);
 355         EnforcePrecondition(false, IsValidTown(town_id));
 356         ScriptCompany::CompanyID company = ScriptCompany::ResolveCompanyID(company_id);
 357         EnforcePrecondition(false, company != ScriptCompany::COMPANY_INVALID);
 358
 359         const Town *t = ::Town::Get(town_id);
 360         int16_t new_rating = Clamp(t->ratings[company] + delta, RATING_MINIMUM, RATING_MAXIMUM);
 361         if (new_rating == t->ratings[company]) return false;
 362
 363         return ScriptObject::Command<CMD_TOWN_RATING>::Do(town_id, (::CompanyID)company_id, new_rating);
 364 }
 365
 366 /* static */ SQInteger ScriptTown::GetAllowedNoise(TownID town_id)
 367 {
 368         if (!IsValidTown(town_id)) return -1;
 369
 370         const Town *t = ::Town::Get(town_id);
 371         if (_settings_game.economy.station_noise_level) {
 372                 return t->MaxTownNoise() - t->noise_reached;
 373         }
 374
 375         int num = 0;
 376         for (const Station *st : Station::Iterate()) {
 377                 if (st->town == t && (st->facilities & FACIL_AIRPORT) && st->airport.type != AT_OILRIG) num++;
 378         }
 379         return std::max(0, 2 - num);
 380 }
 381
 382 /* static */ ScriptTown::RoadLayout ScriptTown::GetRoadLayout(TownID town_id)
 383 {
 384         if (!IsValidTown(town_id)) return ROAD_LAYOUT_INVALID;
 385
 386         return (ScriptTown::RoadLayout)((TownLayout)::Town::Get(town_id)->layout);
 387 }