src/disaster_vehicle.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 /**
   9  * @file disaster_vehicle.cpp
  10  *
  11  * All disaster/easter egg vehicles are handled here.
  12  * The general flow of control for the disaster vehicles is as follows:
  13  * <ol>
  14  * <li>Initialize the disaster in a disaster specific way (eg start position,
  15  *     possible target, etc.) Disaster_XXX_Init() function
  16  * <li>Add a subtype to a disaster, which is an index into the function array
  17  *     that handles the vehicle's ticks.
  18  * <li>Run the disaster vehicles each tick until their target has been reached,
  19  *     this happens in the DisasterTick_XXX() functions. In here, a vehicle's
  20  *     state is kept by v->current_order.dest variable. Each achieved sub-target
  21  *     will increase this value, and the last one will remove the disaster itself
  22  * </ol>
  23  */
  24
  25
  26 #include "stdafx.h"
  27
  28 #include "aircraft.h"
  29 #include "disaster_vehicle.h"
  30 #include "industry.h"
  31 #include "station_base.h"
  32 #include "command_func.h"
  33 #include "news_func.h"
  34 #include "town.h"
  35 #include "company_func.h"
  36 #include "strings_func.h"
  37 #include "date_func.h"
  38 #include "viewport_func.h"
  39 #include "vehicle_func.h"
  40 #include "sound_func.h"
  41 #include "effectvehicle_func.h"
  42 #include "roadveh.h"
  43 #include "ai/ai.hpp"
  44 #include "game/game.hpp"
  45 #include "company_base.h"
  46 #include "core/random_func.hpp"
  47 #include "core/backup_type.hpp"
  48
  49 #include "table/strings.h"
  50
  51 #include "safeguards.h"
  52
  53 /** Delay counter for considering the next disaster. */
  54 uint16 _disaster_delay;
  55
  56 static void DisasterClearSquare(TileIndex tile)
  57 {
  58         if (EnsureNoVehicleOnGround(tile).Failed()) return;
  59
  60         switch (GetTileType(tile)) {
  61                 case MP_RAILWAY:
  62                         if (Company::IsHumanID(GetTileOwner(tile)) && !IsRailDepot(tile)) {
  63                                 Backup<CompanyID> cur_company(_current_company, OWNER_WATER, FILE_LINE);
  64                                 DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
  65                                 cur_company.Restore();
  66
  67                                 /* update signals in buffer */
  68                                 UpdateSignalsInBuffer();
  69                         }
  70                         break;
  71
  72                 case MP_HOUSE: {
  73                         Backup<CompanyID> cur_company(_current_company, OWNER_NONE, FILE_LINE);
  74                         DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
  75                         cur_company.Restore();
  76                         break;
  77                 }
  78
  79                 case MP_TREES:
  80                 case MP_CLEAR:
  81                         DoClearSquare(tile);
  82                         break;
  83
  84                 default:
  85                         break;
  86         }
  87 }
  88
  89 static const SpriteID _disaster_images_1[] = {SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP};
  90 static const SpriteID _disaster_images_2[] = {SPR_UFO_SMALL_SCOUT, SPR_UFO_SMALL_SCOUT, SPR_UFO_SMALL_SCOUT, SPR_UFO_SMALL_SCOUT, SPR_UFO_SMALL_SCOUT, SPR_UFO_SMALL_SCOUT, SPR_UFO_SMALL_SCOUT, SPR_UFO_SMALL_SCOUT};
  91 static const SpriteID _disaster_images_3[] = {SPR_F_15, SPR_F_15, SPR_F_15, SPR_F_15, SPR_F_15, SPR_F_15, SPR_F_15, SPR_F_15};
  92 static const SpriteID _disaster_images_4[] = {SPR_SUB_SMALL_NE, SPR_SUB_SMALL_NE, SPR_SUB_SMALL_SE, SPR_SUB_SMALL_SE, SPR_SUB_SMALL_SW, SPR_SUB_SMALL_SW, SPR_SUB_SMALL_NW, SPR_SUB_SMALL_NW};
  93 static const SpriteID _disaster_images_5[] = {SPR_SUB_LARGE_NE, SPR_SUB_LARGE_NE, SPR_SUB_LARGE_SE, SPR_SUB_LARGE_SE, SPR_SUB_LARGE_SW, SPR_SUB_LARGE_SW, SPR_SUB_LARGE_NW, SPR_SUB_LARGE_NW};
  94 static const SpriteID _disaster_images_6[] = {SPR_UFO_HARVESTER, SPR_UFO_HARVESTER, SPR_UFO_HARVESTER, SPR_UFO_HARVESTER, SPR_UFO_HARVESTER, SPR_UFO_HARVESTER, SPR_UFO_HARVESTER, SPR_UFO_HARVESTER};
  95 static const SpriteID _disaster_images_7[] = {SPR_XCOM_SKYRANGER, SPR_XCOM_SKYRANGER, SPR_XCOM_SKYRANGER, SPR_XCOM_SKYRANGER, SPR_XCOM_SKYRANGER, SPR_XCOM_SKYRANGER, SPR_XCOM_SKYRANGER, SPR_XCOM_SKYRANGER};
  96 static const SpriteID _disaster_images_8[] = {SPR_AH_64A, SPR_AH_64A, SPR_AH_64A, SPR_AH_64A, SPR_AH_64A, SPR_AH_64A, SPR_AH_64A, SPR_AH_64A};
  97 static const SpriteID _disaster_images_9[] = {SPR_ROTOR_MOVING_1, SPR_ROTOR_MOVING_1, SPR_ROTOR_MOVING_1, SPR_ROTOR_MOVING_1, SPR_ROTOR_MOVING_1, SPR_ROTOR_MOVING_1, SPR_ROTOR_MOVING_1, SPR_ROTOR_MOVING_1};
  98
  99 static const SpriteID * const _disaster_images[] = {
 100         _disaster_images_1, _disaster_images_1,                     ///< zeppeliner and zeppeliner shadow
 101         _disaster_images_2, _disaster_images_2,                     ///< small ufo and small ufo shadow
 102         _disaster_images_3, _disaster_images_3,                     ///< combat aircraft and shadow
 103         _disaster_images_8, _disaster_images_8, _disaster_images_9, ///< combat helicopter, shadow and rotor
 104         _disaster_images_6, _disaster_images_6,                     ///< big ufo and shadow
 105         _disaster_images_7, _disaster_images_7,                     ///< skyranger and shadow
 106         _disaster_images_4, _disaster_images_5,                     ///< small and big submarine sprites
 107 };
 108
 109 void DisasterVehicle::UpdateImage()
 110 {
 111         SpriteID img = this->image_override;
 112         if (img == 0) img = _disaster_images[this->subtype][this->direction];
 113         this->sprite_seq.Set(img);
 114 }
 115
 116 /**
 117  * Construct the disaster vehicle.
 118  * @param x         The X coordinate.
 119  * @param y         The Y coordinate.
 120  * @param direction The direction the vehicle is facing.
 121  * @param subtype   The sub type of vehicle.
 122  * @param big_ufo_destroyer_target The target for the UFO destroyer.
 123  */
 124 DisasterVehicle::DisasterVehicle(int x, int y, Direction direction, DisasterSubType subtype, VehicleID big_ufo_destroyer_target) :
 125                 SpecializedVehicleBase(), big_ufo_destroyer_target(big_ufo_destroyer_target)
 126 {
 127         this->vehstatus = VS_UNCLICKABLE;
 128
 129         this->x_pos = x;
 130         this->y_pos = y;
 131         switch (subtype) {
 132                 case ST_ZEPPELINER:
 133                 case ST_SMALL_UFO:
 134                 case ST_AIRPLANE:
 135                 case ST_HELICOPTER:
 136                 case ST_BIG_UFO:
 137                 case ST_BIG_UFO_DESTROYER:
 138                         GetAircraftFlightLevelBounds(this, &this->z_pos, nullptr);
 139                         break;
 140
 141                 case ST_HELICOPTER_ROTORS:
 142                         GetAircraftFlightLevelBounds(this, &this->z_pos, nullptr);
 143                         this->z_pos += ROTOR_Z_OFFSET;
 144                         break;
 145
 146                 case ST_SMALL_SUBMARINE:
 147                 case ST_BIG_SUBMARINE:
 148                         this->z_pos = 0;
 149                         break;
 150
 151                 case ST_ZEPPELINER_SHADOW:
 152                 case ST_SMALL_UFO_SHADOW:
 153                 case ST_AIRPLANE_SHADOW:
 154                 case ST_HELICOPTER_SHADOW:
 155                 case ST_BIG_UFO_SHADOW:
 156                 case ST_BIG_UFO_DESTROYER_SHADOW:
 157                         this->z_pos = 0;
 158                         this->vehstatus |= VS_SHADOW;
 159                         break;
 160         }
 161
 162         this->direction = direction;
 163         this->tile = TileVirtXY(x, y);
 164         this->subtype = subtype;
 165         this->UpdateDeltaXY();
 166         this->owner = OWNER_NONE;
 167         this->image_override = 0;
 168         this->current_order.Free();
 169
 170         this->UpdateImage();
 171         this->UpdatePositionAndViewport();
 172 }
 173
 174 /**
 175  * Update the position of the vehicle.
 176  * @param x The new X-coordinate.
 177  * @param y The new Y-coordinate.
 178  * @param z The new Z-coordinate.
 179  */
 180 void DisasterVehicle::UpdatePosition(int x, int y, int z)
 181 {
 182         this->x_pos = x;
 183         this->y_pos = y;
 184         this->z_pos = z;
 185         this->tile = TileVirtXY(x, y);
 186
 187         this->UpdateImage();
 188         this->UpdatePositionAndViewport();
 189
 190         DisasterVehicle *u = this->Next();
 191         if (u != nullptr) {
 192                 int safe_x = Clamp(x, 0, MapMaxX() * TILE_SIZE);
 193                 int safe_y = Clamp(y - 1, 0, MapMaxY() * TILE_SIZE);
 194
 195                 u->x_pos = x;
 196                 u->y_pos = y - 1 - (max(z - GetSlopePixelZ(safe_x, safe_y), 0) >> 3);
 197                 safe_y = Clamp(u->y_pos, 0, MapMaxY() * TILE_SIZE);
 198                 u->z_pos = GetSlopePixelZ(safe_x, safe_y);
 199                 u->direction = this->direction;
 200
 201                 u->UpdateImage();
 202                 u->UpdatePositionAndViewport();
 203
 204                 if ((u = u->Next()) != nullptr) {
 205                         u->x_pos = x;
 206                         u->y_pos = y;
 207                         u->z_pos = z + ROTOR_Z_OFFSET;
 208                         u->UpdatePositionAndViewport();
 209                 }
 210         }
 211 }
 212
 213 /**
 214  * Zeppeliner handling, v->current_order.dest states:
 215  * 0: Zeppeliner initialization has found a small airport, go there and crash
 216  * 1: Create crash and animate falling down for extra dramatic effect
 217  * 2: Create more smoke and leave debris on ground
 218  * 2: Clear the runway after some time and remove crashed zeppeliner
 219  * If not airport was found, only state 0 is reached until zeppeliner leaves map
 220  */
 221 static bool DisasterTick_Zeppeliner(DisasterVehicle *v)
 222 {
 223         v->tick_counter++;
 224
 225         if (v->current_order.GetDestination() < 2) {
 226                 if (HasBit(v->tick_counter, 0)) return true;
 227
 228                 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 229
 230                 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
 231
 232                 if (v->current_order.GetDestination() == 1) {
 233                         if (++v->age == 38) {
 234                                 v->current_order.SetDestination(2);
 235                                 v->age = 0;
 236                         }
 237
 238                         if (GB(v->tick_counter, 0, 3) == 0) CreateEffectVehicleRel(v, 0, -17, 2, EV_CRASH_SMOKE);
 239
 240                 } else if (v->current_order.GetDestination() == 0) {
 241                         if (IsValidTile(v->tile) && IsAirportTile(v->tile)) {
 242                                 v->current_order.SetDestination(1);
 243                                 v->age = 0;
 244
 245                                 SetDParam(0, GetStationIndex(v->tile));
 246                                 AddVehicleNewsItem(STR_NEWS_DISASTER_ZEPPELIN, NT_ACCIDENT, v->index); // Delete the news, when the zeppelin is gone
 247                                 AI::NewEvent(GetTileOwner(v->tile), new ScriptEventDisasterZeppelinerCrashed(GetStationIndex(v->tile)));
 248                         }
 249                 }
 250
 251                 if (v->y_pos >= (int)((MapSizeY() + 9) * TILE_SIZE - 1)) {
 252                         delete v;
 253                         return false;
 254                 }
 255
 256                 return true;
 257         }
 258
 259         if (v->current_order.GetDestination() > 2) {
 260                 if (++v->age <= 13320) return true;
 261
 262                 if (IsValidTile(v->tile) && IsAirportTile(v->tile)) {
 263                         Station *st = Station::GetByTile(v->tile);
 264                         CLRBITS(st->airport.flags, RUNWAY_IN_block);
 265                         AI::NewEvent(GetTileOwner(v->tile), new ScriptEventDisasterZeppelinerCleared(st->index));
 266                 }
 267
 268                 v->UpdatePosition(v->x_pos, v->y_pos, GetAircraftFlightLevel(v));
 269                 delete v;
 270                 return false;
 271         }
 272
 273         int x = v->x_pos;
 274         int y = v->y_pos;
 275         int z = GetSlopePixelZ(x, y);
 276         if (z < v->z_pos) z = v->z_pos - 1;
 277         v->UpdatePosition(x, y, z);
 278
 279         if (++v->age == 1) {
 280                 CreateEffectVehicleRel(v, 0, 7, 8, EV_EXPLOSION_LARGE);
 281                 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, v);
 282                 v->image_override = SPR_BLIMP_CRASHING;
 283         } else if (v->age == 70) {
 284                 v->image_override = SPR_BLIMP_CRASHED;
 285         } else if (v->age <= 300) {
 286                 if (GB(v->tick_counter, 0, 3) == 0) {
 287                         uint32 r = Random();
 288
 289                         CreateEffectVehicleRel(v,
 290                                 GB(r, 0, 4) - 7,
 291                                 GB(r, 4, 4) - 7,
 292                                 GB(r, 8, 3) + 5,
 293                                 EV_EXPLOSION_SMALL);
 294                 }
 295         } else if (v->age == 350) {
 296                 v->current_order.SetDestination(3);
 297                 v->age = 0;
 298         }
 299
 300         if (IsValidTile(v->tile) && IsAirportTile(v->tile)) {
 301                 SETBITS(Station::GetByTile(v->tile)->airport.flags, RUNWAY_IN_block);
 302         }
 303
 304         return true;
 305 }
 306
 307 /**
 308  * (Small) Ufo handling, v->current_order.dest states:
 309  * 0: Fly around to the middle of the map, then randomly, after a while target a road vehicle
 310  * 1: Home in on a road vehicle and crash it >:)
 311  * If not road vehicle was found, only state 0 is used and Ufo disappears after a while
 312  */
 313 static bool DisasterTick_Ufo(DisasterVehicle *v)
 314 {
 315         v->image_override = (HasBit(++v->tick_counter, 3)) ? SPR_UFO_SMALL_SCOUT_DARKER : SPR_UFO_SMALL_SCOUT;
 316
 317         if (v->current_order.GetDestination() == 0) {
 318                 /* Fly around randomly */
 319                 int x = TileX(v->dest_tile) * TILE_SIZE;
 320                 int y = TileY(v->dest_tile) * TILE_SIZE;
 321                 if (Delta(x, v->x_pos) + Delta(y, v->y_pos) >= (int)TILE_SIZE) {
 322                         v->direction = GetDirectionTowards(v, x, y);
 323                         GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 324                         v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
 325                         return true;
 326                 }
 327                 if (++v->age < 6) {
 328                         v->dest_tile = RandomTile();
 329                         return true;
 330                 }
 331                 v->current_order.SetDestination(1);
 332
 333                 uint n = 0; // Total number of targetable road vehicles.
 334                 for (const RoadVehicle *u : RoadVehicle::Iterate()) {
 335                         if (u->IsFrontEngine()) n++;
 336                 }
 337
 338                 if (n == 0) {
 339                         /* If there are no targetable road vehicles, destroy the UFO. */
 340                         delete v;
 341                         return false;
 342                 }
 343
 344                 n = RandomRange(n); // Choose one of them.
 345                 for (const RoadVehicle *u : RoadVehicle::Iterate()) {
 346                         /* Find (n+1)-th road vehicle. */
 347                         if (u->IsFrontEngine() && (n-- == 0)) {
 348                                 /* Target it. */
 349                                 v->dest_tile = u->index;
 350                                 v->age = 0;
 351                                 break;
 352                         }
 353                 }
 354
 355                 return true;
 356         } else {
 357                 /* Target a vehicle */
 358                 RoadVehicle *u = RoadVehicle::Get(v->dest_tile);
 359                 assert(u != nullptr && u->type == VEH_ROAD && u->IsFrontEngine());
 360
 361                 uint dist = Delta(v->x_pos, u->x_pos) + Delta(v->y_pos, u->y_pos);
 362
 363                 if (dist < TILE_SIZE && !(u->vehstatus & VS_HIDDEN) && u->breakdown_ctr == 0) {
 364                         u->breakdown_ctr = 3;
 365                         u->breakdown_delay = 140;
 366                 }
 367
 368                 v->direction = GetDirectionTowards(v, u->x_pos, u->y_pos);
 369                 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 370
 371                 int z = v->z_pos;
 372                 if (dist <= TILE_SIZE && z > u->z_pos) z--;
 373                 v->UpdatePosition(gp.x, gp.y, z);
 374
 375                 if (z <= u->z_pos && (u->vehstatus & VS_HIDDEN) == 0) {
 376                         v->age++;
 377                         if (u->crashed_ctr == 0) {
 378                                 u->Crash();
 379
 380                                 AddVehicleNewsItem(STR_NEWS_DISASTER_SMALL_UFO, NT_ACCIDENT, u->index); // delete the news, when the roadvehicle is gone
 381
 382                                 AI::NewEvent(u->owner, new ScriptEventVehicleCrashed(u->index, u->tile, ScriptEventVehicleCrashed::CRASH_RV_UFO));
 383                                 Game::NewEvent(new ScriptEventVehicleCrashed(u->index, u->tile, ScriptEventVehicleCrashed::CRASH_RV_UFO));
 384                         }
 385                 }
 386
 387                 /* Destroy? */
 388                 if (v->age > 50) {
 389                         CreateEffectVehicleRel(v, 0, 7, 8, EV_EXPLOSION_LARGE);
 390                         if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, v);
 391                         delete v;
 392                         return false;
 393                 }
 394         }
 395
 396         return true;
 397 }
 398
 399 static void DestructIndustry(Industry *i)
 400 {
 401         for (TileIndex tile = 0; tile != MapSize(); tile++) {
 402                 if (i->TileBelongsToIndustry(tile)) {
 403                         ResetIndustryConstructionStage(tile);
 404                         MarkTileDirtyByTile(tile);
 405                 }
 406         }
 407 }
 408
 409 /**
 410  * Aircraft handling, v->current_order.dest states:
 411  * 0: Fly towards the targeted industry
 412  * 1: If within 15 tiles, fire away rockets and destroy industry
 413  * 2: Industry explosions
 414  * 3: Fly out of the map
 415  * If the industry was removed in the meantime just fly to the end of the map.
 416  * @param v The disaster vehicle.
 417  * @param image_override The image at the time the aircraft is firing.
 418  * @param leave_at_top True iff the vehicle leaves the map at the north side.
 419  * @param news_message The string that's used as news message.
 420  * @param industry_flag Only attack industries that have this flag set.
 421  */
 422 static bool DisasterTick_Aircraft(DisasterVehicle *v, uint16 image_override, bool leave_at_top, StringID news_message, IndustryBehaviour industry_flag)
 423 {
 424         v->tick_counter++;
 425         v->image_override = (v->current_order.GetDestination() == 1 && HasBit(v->tick_counter, 2)) ? image_override : 0;
 426
 427         GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 428         v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
 429
 430         if ((leave_at_top && gp.x < (-10 * (int)TILE_SIZE)) || (!leave_at_top && gp.x > (int)(MapSizeX() * TILE_SIZE + 9 * TILE_SIZE) - 1)) {
 431                 delete v;
 432                 return false;
 433         }
 434
 435         if (v->current_order.GetDestination() == 2) {
 436                 if (GB(v->tick_counter, 0, 2) == 0) {
 437                         Industry *i = Industry::Get(v->dest_tile); // Industry destructor calls ReleaseDisastersTargetingIndustry, so this is valid
 438                         int x = TileX(i->location.tile) * TILE_SIZE;
 439                         int y = TileY(i->location.tile) * TILE_SIZE;
 440                         uint32 r = Random();
 441
 442                         CreateEffectVehicleAbove(
 443                                 GB(r,  0, 6) + x,
 444                                 GB(r,  6, 6) + y,
 445                                 GB(r, 12, 4),
 446                                 EV_EXPLOSION_SMALL);
 447
 448                         if (++v->age >= 55) v->current_order.SetDestination(3);
 449                 }
 450         } else if (v->current_order.GetDestination() == 1) {
 451                 if (++v->age == 112) {
 452                         v->current_order.SetDestination(2);
 453                         v->age = 0;
 454
 455                         Industry *i = Industry::Get(v->dest_tile); // Industry destructor calls ReleaseDisastersTargetingIndustry, so this is valid
 456                         DestructIndustry(i);
 457
 458                         SetDParam(0, i->town->index);
 459                         AddIndustryNewsItem(news_message, NT_ACCIDENT, i->index); // delete the news, when the industry closes
 460                         if (_settings_client.sound.disaster) SndPlayTileFx(SND_12_EXPLOSION, i->location.tile);
 461                 }
 462         } else if (v->current_order.GetDestination() == 0) {
 463                 int x = v->x_pos + ((leave_at_top ? -15 : 15) * TILE_SIZE);
 464                 int y = v->y_pos;
 465
 466                 if ((uint)x > MapMaxX() * TILE_SIZE - 1) return true;
 467
 468                 TileIndex tile = TileVirtXY(x, y);
 469                 if (!IsTileType(tile, MP_INDUSTRY)) return true;
 470
 471                 IndustryID ind = GetIndustryIndex(tile);
 472                 v->dest_tile = ind;
 473
 474                 if (GetIndustrySpec(Industry::Get(ind)->type)->behaviour & industry_flag) {
 475                         v->current_order.SetDestination(1);
 476                         v->age = 0;
 477                 }
 478         }
 479
 480         return true;
 481 }
 482
 483 /** Airplane handling. */
 484 static bool DisasterTick_Airplane(DisasterVehicle *v)
 485 {
 486         return DisasterTick_Aircraft(v, SPR_F_15_FIRING, true, STR_NEWS_DISASTER_AIRPLANE_OIL_REFINERY, INDUSTRYBEH_AIRPLANE_ATTACKS);
 487 }
 488
 489 /** Helicopter handling. */
 490 static bool DisasterTick_Helicopter(DisasterVehicle *v)
 491 {
 492         return DisasterTick_Aircraft(v, SPR_AH_64A_FIRING, false, STR_NEWS_DISASTER_HELICOPTER_FACTORY, INDUSTRYBEH_CHOPPER_ATTACKS);
 493 }
 494
 495 /** Helicopter rotor blades; keep these spinning */
 496 static bool DisasterTick_Helicopter_Rotors(DisasterVehicle *v)
 497 {
 498         v->tick_counter++;
 499         if (HasBit(v->tick_counter, 0)) return true;
 500
 501         SpriteID &cur_image = v->sprite_seq.seq[0].sprite;
 502         if (++cur_image > SPR_ROTOR_MOVING_3) cur_image = SPR_ROTOR_MOVING_1;
 503
 504         v->UpdatePositionAndViewport();
 505
 506         return true;
 507 }
 508
 509 /**
 510  * (Big) Ufo handling, v->current_order.dest states:
 511  * 0: Fly around to the middle of the map, then randomly for a while and home in on a piece of rail
 512  * 1: Land there and breakdown all trains in a radius of 12 tiles; and now we wait...
 513  *    because as soon as the Ufo lands, a fighter jet, a Skyranger, is called to clear up the mess
 514  */
 515 static bool DisasterTick_Big_Ufo(DisasterVehicle *v)
 516 {
 517         v->tick_counter++;
 518
 519         if (v->current_order.GetDestination() == 1) {
 520                 int x = TileX(v->dest_tile) * TILE_SIZE + TILE_SIZE / 2;
 521                 int y = TileY(v->dest_tile) * TILE_SIZE + TILE_SIZE / 2;
 522                 if (Delta(v->x_pos, x) + Delta(v->y_pos, y) >= 8) {
 523                         v->direction = GetDirectionTowards(v, x, y);
 524
 525                         GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 526                         v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
 527                         return true;
 528                 }
 529
 530                 if (!IsValidTile(v->dest_tile)) {
 531                         /* Make sure we don't land outside the map. */
 532                         delete v;
 533                         return false;
 534                 }
 535
 536                 int z = GetSlopePixelZ(v->x_pos, v->y_pos);
 537                 if (z < v->z_pos) {
 538                         v->UpdatePosition(v->x_pos, v->y_pos, v->z_pos - 1);
 539                         return true;
 540                 }
 541
 542                 v->current_order.SetDestination(2);
 543
 544                 for (Vehicle *target : Vehicle::Iterate()) {
 545                         if (target->IsGroundVehicle()) {
 546                                 if (Delta(target->x_pos, v->x_pos) + Delta(target->y_pos, v->y_pos) <= 12 * (int)TILE_SIZE) {
 547                                         target->breakdown_ctr = 5;
 548                                         target->breakdown_delay = 0xF0;
 549                                 }
 550                         }
 551                 }
 552
 553                 Town *t = ClosestTownFromTile(v->dest_tile, UINT_MAX);
 554                 SetDParam(0, t->index);
 555                 AddTileNewsItem(STR_NEWS_DISASTER_BIG_UFO, NT_ACCIDENT, v->tile);
 556
 557                 if (!Vehicle::CanAllocateItem(2)) {
 558                         delete v;
 559                         return false;
 560                 }
 561                 DisasterVehicle *u = new DisasterVehicle(-6 * (int)TILE_SIZE, v->y_pos, DIR_SW, ST_BIG_UFO_DESTROYER, v->index);
 562                 DisasterVehicle *w = new DisasterVehicle(-6 * (int)TILE_SIZE, v->y_pos, DIR_SW, ST_BIG_UFO_DESTROYER_SHADOW);
 563                 u->SetNext(w);
 564         } else if (v->current_order.GetDestination() == 0) {
 565                 int x = TileX(v->dest_tile) * TILE_SIZE;
 566                 int y = TileY(v->dest_tile) * TILE_SIZE;
 567                 if (Delta(x, v->x_pos) + Delta(y, v->y_pos) >= (int)TILE_SIZE) {
 568                         v->direction = GetDirectionTowards(v, x, y);
 569                         GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 570                         v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
 571                         return true;
 572                 }
 573
 574                 if (++v->age < 6) {
 575                         v->dest_tile = RandomTile();
 576                         return true;
 577                 }
 578                 v->current_order.SetDestination(1);
 579
 580                 TileIndex tile_org = RandomTile();
 581                 TileIndex tile = tile_org;
 582                 do {
 583                         if (IsPlainRailTile(tile) &&
 584                                         Company::IsHumanID(GetTileOwner(tile))) {
 585                                 break;
 586                         }
 587                         tile = TILE_MASK(tile + 1);
 588                 } while (tile != tile_org);
 589                 v->dest_tile = tile;
 590                 v->age = 0;
 591         }
 592
 593         return true;
 594 }
 595
 596 /**
 597  * Skyranger destroying (Big) Ufo handling, v->current_order.dest states:
 598  * 0: Home in on landed Ufo and shoot it down
 599  */
 600 static bool DisasterTick_Big_Ufo_Destroyer(DisasterVehicle *v)
 601 {
 602         v->tick_counter++;
 603
 604         GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 605         v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
 606
 607         if (gp.x > (int)(MapSizeX() * TILE_SIZE + 9 * TILE_SIZE) - 1) {
 608                 delete v;
 609                 return false;
 610         }
 611
 612         if (v->current_order.GetDestination() == 0) {
 613                 Vehicle *u = Vehicle::Get(v->big_ufo_destroyer_target);
 614                 if (Delta(v->x_pos, u->x_pos) > (int)TILE_SIZE) return true;
 615                 v->current_order.SetDestination(1);
 616
 617                 CreateEffectVehicleRel(u, 0, 7, 8, EV_EXPLOSION_LARGE);
 618                 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, u);
 619
 620                 delete u;
 621
 622                 for (int i = 0; i != 80; i++) {
 623                         uint32 r = Random();
 624                         CreateEffectVehicleAbove(
 625                                 GB(r, 0, 6) + v->x_pos - 32,
 626                                 GB(r, 5, 6) + v->y_pos - 32,
 627                                 0,
 628                                 EV_EXPLOSION_SMALL);
 629                 }
 630
 631                 for (int dy = -3; dy < 3; dy++) {
 632                         for (int dx = -3; dx < 3; dx++) {
 633                                 TileIndex tile = TileAddWrap(v->tile, dx, dy);
 634                                 if (tile != INVALID_TILE) DisasterClearSquare(tile);
 635                         }
 636                 }
 637         }
 638
 639         return true;
 640 }
 641
 642 /**
 643  * Submarine, v->current_order.dest states:
 644  * Unused, just float around aimlessly and pop up at different places, turning around
 645  */
 646 static bool DisasterTick_Submarine(DisasterVehicle *v)
 647 {
 648         v->tick_counter++;
 649
 650         if (++v->age > 8880) {
 651                 delete v;
 652                 return false;
 653         }
 654
 655         if (!HasBit(v->tick_counter, 0)) return true;
 656
 657         TileIndex tile = v->tile + TileOffsByDiagDir(DirToDiagDir(v->direction));
 658         if (IsValidTile(tile)) {
 659                 TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0));
 660                 if (trackbits == TRACK_BIT_ALL && !Chance16(1, 90)) {
 661                         GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 662                         v->UpdatePosition(gp.x, gp.y, v->z_pos);
 663                         return true;
 664                 }
 665         }
 666
 667         v->direction = ChangeDir(v->direction, GB(Random(), 0, 1) ? DIRDIFF_90RIGHT : DIRDIFF_90LEFT);
 668
 669         return true;
 670 }
 671
 672
 673 static bool DisasterTick_NULL(DisasterVehicle *v)
 674 {
 675         return true;
 676 }
 677
 678 typedef bool DisasterVehicleTickProc(DisasterVehicle *v);
 679
 680 static DisasterVehicleTickProc * const _disastervehicle_tick_procs[] = {
 681         DisasterTick_Zeppeliner, DisasterTick_NULL,
 682         DisasterTick_Ufo,        DisasterTick_NULL,
 683         DisasterTick_Airplane,   DisasterTick_NULL,
 684         DisasterTick_Helicopter, DisasterTick_NULL, DisasterTick_Helicopter_Rotors,
 685         DisasterTick_Big_Ufo,    DisasterTick_NULL, DisasterTick_Big_Ufo_Destroyer,
 686         DisasterTick_NULL,
 687         DisasterTick_Submarine,
 688         DisasterTick_Submarine,
 689 };
 690
 691
 692 bool DisasterVehicle::Tick()
 693 {
 694         return _disastervehicle_tick_procs[this->subtype](this);
 695 }
 696
 697 typedef void DisasterInitProc();
 698
 699
 700 /**
 701  * Zeppeliner which crashes on a small airport if one found,
 702  * otherwise crashes on a random tile
 703  */
 704 static void Disaster_Zeppeliner_Init()
 705 {
 706         if (!Vehicle::CanAllocateItem(2)) return;
 707
 708         /* Pick a random place, unless we find a small airport */
 709         int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;
 710
 711         for (const Station *st : Station::Iterate()) {
 712                 if (st->airport.tile != INVALID_TILE && (st->airport.type == AT_SMALL || st->airport.type == AT_LARGE)) {
 713                         x = (TileX(st->airport.tile) + 2) * TILE_SIZE;
 714                         break;
 715                 }
 716         }
 717
 718         DisasterVehicle *v = new DisasterVehicle(x, 0, DIR_SE, ST_ZEPPELINER);
 719         /* Allocate shadow */
 720         DisasterVehicle *u = new DisasterVehicle(x, 0, DIR_SE, ST_ZEPPELINER_SHADOW);
 721         v->SetNext(u);
 722 }
 723
 724
 725 /**
 726  * Ufo which flies around aimlessly from the middle of the map a bit
 727  * until it locates a road vehicle which it targets and then destroys
 728  */
 729 static void Disaster_Small_Ufo_Init()
 730 {
 731         if (!Vehicle::CanAllocateItem(2)) return;
 732
 733         int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;
 734         DisasterVehicle *v = new DisasterVehicle(x, 0, DIR_SE, ST_SMALL_UFO);
 735         v->dest_tile = TileXY(MapSizeX() / 2, MapSizeY() / 2);
 736
 737         /* Allocate shadow */
 738         DisasterVehicle *u = new DisasterVehicle(x, 0, DIR_SE, ST_SMALL_UFO_SHADOW);
 739         v->SetNext(u);
 740 }
 741
 742
 743 /* Combat airplane which destroys an oil refinery */
 744 static void Disaster_Airplane_Init()
 745 {
 746         if (!Vehicle::CanAllocateItem(2)) return;
 747
 748         Industry *found = nullptr;
 749
 750         for (Industry *i : Industry::Iterate()) {
 751                 if ((GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_AIRPLANE_ATTACKS) &&
 752                                 (found == nullptr || Chance16(1, 2))) {
 753                         found = i;
 754                 }
 755         }
 756
 757         if (found == nullptr) return;
 758
 759         /* Start from the bottom (south side) of the map */
 760         int x = (MapSizeX() + 9) * TILE_SIZE - 1;
 761         int y = TileY(found->location.tile) * TILE_SIZE + 37;
 762
 763         DisasterVehicle *v = new DisasterVehicle(x, y, DIR_NE, ST_AIRPLANE);
 764         DisasterVehicle *u = new DisasterVehicle(x, y, DIR_NE, ST_AIRPLANE_SHADOW);
 765         v->SetNext(u);
 766 }
 767
 768
 769 /** Combat helicopter that destroys a factory */
 770 static void Disaster_Helicopter_Init()
 771 {
 772         if (!Vehicle::CanAllocateItem(3)) return;
 773
 774         Industry *found = nullptr;
 775
 776         for (Industry *i : Industry::Iterate()) {
 777                 if ((GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_CHOPPER_ATTACKS) &&
 778                                 (found == nullptr || Chance16(1, 2))) {
 779                         found = i;
 780                 }
 781         }
 782
 783         if (found == nullptr) return;
 784
 785         int x = -16 * (int)TILE_SIZE;
 786         int y = TileY(found->location.tile) * TILE_SIZE + 37;
 787
 788         DisasterVehicle *v = new DisasterVehicle(x, y, DIR_SW, ST_HELICOPTER);
 789         DisasterVehicle *u = new DisasterVehicle(x, y, DIR_SW, ST_HELICOPTER_SHADOW);
 790         v->SetNext(u);
 791
 792         DisasterVehicle *w = new DisasterVehicle(x, y, DIR_SW, ST_HELICOPTER_ROTORS);
 793         u->SetNext(w);
 794 }
 795
 796
 797 /* Big Ufo which lands on a piece of rail and will consequently be shot
 798  * down by a combat airplane, destroying the surroundings */
 799 static void Disaster_Big_Ufo_Init()
 800 {
 801         if (!Vehicle::CanAllocateItem(2)) return;
 802
 803         int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;
 804         int y = MapMaxX() * TILE_SIZE - 1;
 805
 806         DisasterVehicle *v = new DisasterVehicle(x, y, DIR_NW, ST_BIG_UFO);
 807         v->dest_tile = TileXY(MapSizeX() / 2, MapSizeY() / 2);
 808
 809         /* Allocate shadow */
 810         DisasterVehicle *u = new DisasterVehicle(x, y, DIR_NW, ST_BIG_UFO_SHADOW);
 811         v->SetNext(u);
 812 }
 813
 814
 815 static void Disaster_Submarine_Init(DisasterSubType subtype)
 816 {
 817         if (!Vehicle::CanAllocateItem()) return;
 818
 819         int y;
 820         Direction dir;
 821         uint32 r = Random();
 822         int x = TileX(r) * TILE_SIZE + TILE_SIZE / 2;
 823
 824         if (HasBit(r, 31)) {
 825                 y = MapMaxY() * TILE_SIZE - TILE_SIZE / 2 - 1;
 826                 dir = DIR_NW;
 827         } else {
 828                 y = TILE_SIZE / 2;
 829                 if (_settings_game.construction.freeform_edges) y += TILE_SIZE;
 830                 dir = DIR_SE;
 831         }
 832         if (!IsWaterTile(TileVirtXY(x, y))) return;
 833
 834         new DisasterVehicle(x, y, dir, subtype);
 835 }
 836
 837 /* Curious submarine #1, just floats around */
 838 static void Disaster_Small_Submarine_Init()
 839 {
 840         Disaster_Submarine_Init(ST_SMALL_SUBMARINE);
 841 }
 842
 843
 844 /* Curious submarine #2, just floats around */
 845 static void Disaster_Big_Submarine_Init()
 846 {
 847         Disaster_Submarine_Init(ST_BIG_SUBMARINE);
 848 }
 849
 850
 851 /**
 852  * Coal mine catastrophe, destroys a stretch of 30 tiles of
 853  * land in a certain direction
 854  */
 855 static void Disaster_CoalMine_Init()
 856 {
 857         int index = GB(Random(), 0, 4);
 858         uint m;
 859
 860         for (m = 0; m < 15; m++) {
 861                 for (const Industry *i : Industry::Iterate()) {
 862                         if ((GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_CAN_SUBSIDENCE) && --index < 0) {
 863                                 SetDParam(0, i->town->index);
 864                                 AddTileNewsItem(STR_NEWS_DISASTER_COAL_MINE_SUBSIDENCE, NT_ACCIDENT, i->location.tile + TileDiffXY(1, 1)); // keep the news, even when the mine closes
 865
 866                                 {
 867                                         TileIndex tile = i->location.tile;
 868                                         TileIndexDiff step = TileOffsByDiagDir((DiagDirection)GB(Random(), 0, 2));
 869
 870                                         for (uint n = 0; n < 30; n++) {
 871                                                 DisasterClearSquare(tile);
 872                                                 tile += step;
 873                                                 if (!IsValidTile(tile)) break;
 874                                         }
 875                                 }
 876                                 return;
 877                         }
 878                 }
 879         }
 880 }
 881
 882 struct Disaster {
 883         DisasterInitProc *init_proc; ///< The init function for this disaster.
 884         Year min_year;               ///< The first year this disaster will occur.
 885         Year max_year;               ///< The last year this disaster will occur.
 886 };
 887
 888 static const Disaster _disasters[] = {
 889         {Disaster_Zeppeliner_Init,      1930, 1955}, // zeppeliner
 890         {Disaster_Small_Ufo_Init,       1940, 1970}, // ufo (small)
 891         {Disaster_Airplane_Init,        1960, 1990}, // airplane
 892         {Disaster_Helicopter_Init,      1970, 2000}, // helicopter
 893         {Disaster_Big_Ufo_Init,         2000, 2100}, // ufo (big)
 894         {Disaster_Small_Submarine_Init, 1940, 1965}, // submarine (small)
 895         {Disaster_Big_Submarine_Init,   1975, 2010}, // submarine (big)
 896         {Disaster_CoalMine_Init,        1950, 1985}, // coalmine
 897 };
 898
 899 static void DoDisaster()
 900 {
 901         byte buf[lengthof(_disasters)];
 902
 903         byte j = 0;
 904         for (size_t i = 0; i != lengthof(_disasters); i++) {
 905                 if (_cur_year >= _disasters[i].min_year && _cur_year < _disasters[i].max_year) buf[j++] = (byte)i;
 906         }
 907
 908         if (j == 0) return;
 909
 910         _disasters[buf[RandomRange(j)]].init_proc();
 911 }
 912
 913
 914 static void ResetDisasterDelay()
 915 {
 916         _disaster_delay = GB(Random(), 0, 9) + 730;
 917 }
 918
 919 void DisasterDailyLoop()
 920 {
 921         if (--_disaster_delay != 0) return;
 922
 923         ResetDisasterDelay();
 924
 925         if (_settings_game.difficulty.disasters != 0) DoDisaster();
 926 }
 927
 928 void StartupDisasters()
 929 {
 930         ResetDisasterDelay();
 931 }
 932
 933 /**
 934  * Marks all disasters targeting this industry in such a way
 935  * they won't call Industry::Get(v->dest_tile) on invalid industry anymore.
 936  * @param i deleted industry
 937  */
 938 void ReleaseDisastersTargetingIndustry(IndustryID i)
 939 {
 940         for (DisasterVehicle *v : DisasterVehicle::Iterate()) {
 941                 /* primary disaster vehicles that have chosen target */
 942                 if (v->subtype == ST_AIRPLANE || v->subtype == ST_HELICOPTER) {
 943                         /* if it has chosen target, and it is this industry (yes, dest_tile is IndustryID here), set order to "leaving map peacefully" */
 944                         if (v->current_order.GetDestination() > 0 && v->dest_tile == i) v->current_order.SetDestination(3);
 945                 }
 946         }
 947 }
 948
 949 /**
 950  * Notify disasters that we are about to delete a vehicle. So make them head elsewhere.
 951  * @param vehicle deleted vehicle
 952  */
 953 void ReleaseDisastersTargetingVehicle(VehicleID vehicle)
 954 {
 955         for (DisasterVehicle *v : DisasterVehicle::Iterate()) {
 956                 /* primary disaster vehicles that have chosen target */
 957                 if (v->subtype == ST_SMALL_UFO) {
 958                         if (v->current_order.GetDestination() != 0 && v->dest_tile == vehicle) {
 959                                 /* Revert to target-searching */
 960                                 v->current_order.SetDestination(0);
 961                                 v->dest_tile = RandomTile();
 962                                 GetAircraftFlightLevelBounds(v, &v->z_pos, nullptr);
 963                                 v->age = 0;
 964                         }
 965                 }
 966         }
 967 }
 968
 969 void DisasterVehicle::UpdateDeltaXY()
 970 {
 971         this->x_offs        = -1;
 972         this->y_offs        = -1;
 973         this->x_extent      =  2;
 974         this->y_extent      =  2;
 975         this->z_extent      =  5;
 976 }