OpenTTD Source: src/disaster_vehicle.cpp Source File

OpenTTD Source 15.0-beta1

disaster_vehicle.cpp
Go to the documentation of this file.
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
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 "viewport_func.h"
38#include "vehicle_func.h"
39#include "sound_func.h"
40#include "effectvehicle_func.h"
41#include "roadveh.h"
42#include "train.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#include "landscape_cmd.h"
49#include "timer/timer.h"
50#include "timer/timer_game_economy.h"
51
52#include "table/strings.h"
53
54#include "safeguards.h"
55
57uint16_t _disaster_delay;
58
59static void DisasterClearSquare(TileIndex tile)
60{
61 if (EnsureNoVehicleOnGround(tile).Failed()) return;
62
63 switch (GetTileType(tile)) {
64 case MP_RAILWAY:
65 if (Company::IsHumanID(GetTileOwner(tile)) && !IsRailDepot(tile)) {
66 Backup<CompanyID> cur_company(_current_company, OWNER_WATER);
67 Command<CMD_LANDSCAPE_CLEAR>::Do(DC_EXEC, tile);
68 cur_company.Restore();
69
70 /* update signals in buffer */
71 UpdateSignalsInBuffer();
72 }
73 break;
74
75 case MP_HOUSE: {
76 Backup<CompanyID> cur_company(_current_company, OWNER_NONE);
77 Command<CMD_LANDSCAPE_CLEAR>::Do(DC_EXEC, tile);
78 cur_company.Restore();
79 break;
80 }
81
82 case MP_TREES:
83 case MP_CLEAR:
84 DoClearSquare(tile);
85 break;
86
87 default:
88 break;
89 }
90}
91
92static const SpriteID _disaster_images_1[] = {SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP};
93static 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};
94static 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};
95static 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};
96static 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};
97static 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};
98static 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};
99static 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};
100static 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};
101
102static const SpriteID * const _disaster_images[] = {
103 _disaster_images_1, _disaster_images_1,
104 _disaster_images_2, _disaster_images_2,
105 _disaster_images_3, _disaster_images_3,
106 _disaster_images_8, _disaster_images_8, _disaster_images_9,
107 _disaster_images_6, _disaster_images_6,
108 _disaster_images_7, _disaster_images_7,
109 _disaster_images_4, _disaster_images_5,
110};
111
112void DisasterVehicle::UpdateImage()
113{
114 SpriteID img = this->image_override;
115 if (img == 0) img = _disaster_images[this->subtype][this->direction];
116 this->sprite_cache.sprite_seq.Set(img);
117}
118
127 DisasterVehicle::DisasterVehicle(int x, int y, Direction direction, DisasterSubType subtype, VehicleID big_ufo_destroyer_target) :
128 SpecializedVehicleBase(), big_ufo_destroyer_target(big_ufo_destroyer_target)
129{
130 this->vehstatus = VS_UNCLICKABLE;
131
132 this->x_pos = x;
133 this->y_pos = y;
134 switch (subtype) {
135 case ST_ZEPPELINER:
136 case ST_SMALL_UFO:
137 case ST_AIRPLANE:
138 case ST_HELICOPTER:
139 case ST_BIG_UFO:
140 case ST_BIG_UFO_DESTROYER:
141 GetAircraftFlightLevelBounds(this, &this->z_pos, nullptr);
142 break;
143
144 case ST_HELICOPTER_ROTORS:
145 GetAircraftFlightLevelBounds(this, &this->z_pos, nullptr);
146 this->z_pos += ROTOR_Z_OFFSET;
147 break;
148
149 case ST_SMALL_SUBMARINE:
150 case ST_BIG_SUBMARINE:
151 this->z_pos = 0;
152 break;
153
154 case ST_ZEPPELINER_SHADOW:
155 case ST_SMALL_UFO_SHADOW:
156 case ST_AIRPLANE_SHADOW:
157 case ST_HELICOPTER_SHADOW:
158 case ST_BIG_UFO_SHADOW:
159 case ST_BIG_UFO_DESTROYER_SHADOW:
160 this->z_pos = 0;
161 this->vehstatus |= VS_SHADOW;
162 break;
163 }
164
165 this->direction = direction;
166 this->tile = TileVirtXY(x, y);
167 this->subtype = subtype;
168 this->UpdateDeltaXY();
169 this->owner = OWNER_NONE;
170 this->image_override = 0;
171 this->state = 0;
172
173 this->UpdateImage();
174 this->UpdatePositionAndViewport();
175}
176
183 void DisasterVehicle::UpdatePosition(int x, int y, int z)
184{
185 this->x_pos = x;
186 this->y_pos = y;
187 this->z_pos = z;
188 this->tile = TileVirtXY(x, y);
189
190 this->UpdateImage();
191 this->UpdatePositionAndViewport();
192
193 DisasterVehicle *u = this->Next();
194 if (u != nullptr) {
195 int safe_x = Clamp(x, 0, Map::MaxX() * TILE_SIZE);
196 int safe_y = Clamp(y - 1, 0, Map::MaxY() * TILE_SIZE);
197
198 u->x_pos = x;
199 u->y_pos = y - 1 - (std::max(z - GetSlopePixelZ(safe_x, safe_y), 0) >> 3);
200 safe_y = Clamp(u->y_pos, 0, Map::MaxY() * TILE_SIZE);
201 u->z_pos = GetSlopePixelZ(safe_x, safe_y);
202 u->direction = this->direction;
203
204 u->UpdateImage();
205 u->UpdatePositionAndViewport();
206
207 if ((u = u->Next()) != nullptr) {
208 u->x_pos = x;
209 u->y_pos = y;
210 u->z_pos = z + ROTOR_Z_OFFSET;
211 u->UpdatePositionAndViewport();
212 }
213 }
214}
215
224 static bool DisasterTick_Zeppeliner(DisasterVehicle *v)
225{
226 v->tick_counter++;
227
228 if (v->state < 2) {
229 if (HasBit(v->tick_counter, 0)) return true;
230
231 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
232
233 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
234
235 if (v->state == 1) {
236 if (++v->age == 38) {
237 v->state = 2;
238 v->age = 0;
239 }
240
241 if (GB(v->tick_counter, 0, 3) == 0) CreateEffectVehicleRel(v, 0, -17, 2, EV_CRASH_SMOKE);
242
243 } else if (v->state == 0) {
244 if (IsValidTile(v->tile) && IsAirportTile(v->tile)) {
245 v->state = 1;
246 v->age = 0;
247
248 SetDParam(0, GetStationIndex(v->tile));
249 AddTileNewsItem(STR_NEWS_DISASTER_ZEPPELIN, NT_ACCIDENT, v->tile);
250 AI::NewEvent(GetTileOwner(v->tile), new ScriptEventDisasterZeppelinerCrashed(GetStationIndex(v->tile)));
251 }
252 }
253
254 if (v->y_pos >= (int)((Map::SizeY() + 9) * TILE_SIZE - 1)) {
255 delete v;
256 return false;
257 }
258
259 return true;
260 }
261
262 if (v->state > 2) {
263 if (++v->age <= 13320) return true;
264
265 if (IsValidTile(v->tile) && IsAirportTile(v->tile)) {
266 Station *st = Station::GetByTile(v->tile);
267 CLRBITS(st->airport.flags, RUNWAY_IN_block);
268 AI::NewEvent(GetTileOwner(v->tile), new ScriptEventDisasterZeppelinerCleared(st->index));
269 }
270
271 v->UpdatePosition(v->x_pos, v->y_pos, GetAircraftFlightLevel(v));
272 delete v;
273 return false;
274 }
275
276 int x = v->x_pos;
277 int y = v->y_pos;
278 int z = GetSlopePixelZ(x, y);
279 if (z < v->z_pos) z = v->z_pos - 1;
280 v->UpdatePosition(x, y, z);
281
282 if (++v->age == 1) {
283 CreateEffectVehicleRel(v, 0, 7, 8, EV_EXPLOSION_LARGE);
284 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, v);
285 v->image_override = SPR_BLIMP_CRASHING;
286 } else if (v->age == 70) {
287 v->image_override = SPR_BLIMP_CRASHED;
288 } else if (v->age <= 300) {
289 if (GB(v->tick_counter, 0, 3) == 0) {
290 uint32_t r = Random();
291
292 CreateEffectVehicleRel(v,
293 GB(r, 0, 4) - 7,
294 GB(r, 4, 4) - 7,
295 GB(r, 8, 3) + 5,
296 EV_EXPLOSION_SMALL);
297 }
298 } else if (v->age == 350) {
299 v->state = 3;
300 v->age = 0;
301 }
302
303 if (IsValidTile(v->tile) && IsAirportTile(v->tile)) {
304 SETBITS(Station::GetByTile(v->tile)->airport.flags, RUNWAY_IN_block);
305 }
306
307 return true;
308}
309
316 static bool DisasterTick_Ufo(DisasterVehicle *v)
317{
318 v->image_override = (HasBit(++v->tick_counter, 3)) ? SPR_UFO_SMALL_SCOUT_DARKER : SPR_UFO_SMALL_SCOUT;
319
320 if (v->state == 0) {
321 /* Fly around randomly */
322 int x = TileX(v->dest_tile) * TILE_SIZE;
323 int y = TileY(v->dest_tile) * TILE_SIZE;
324 if (Delta(x, v->x_pos) + Delta(y, v->y_pos) >= (int)TILE_SIZE) {
325 v->direction = GetDirectionTowards(v, x, y);
326 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
327 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
328 return true;
329 }
330 if (++v->age < 6) {
331 v->dest_tile = RandomTile();
332 return true;
333 }
334 v->state = 1;
335
336 uint n = 0; // Total number of targetable road vehicles.
337 for (const Company *c : Company::Iterate()) {
338 n += c->group_all[VEH_ROAD].num_vehicle;
339 }
340
341 if (n == 0) {
342 /* If there are no targetable road vehicles, destroy the UFO. */
343 delete v;
344 return false;
345 }
346
347 n = RandomRange(n); // Choose one of them.
348 for (RoadVehicle *u : RoadVehicle::Iterate()) {
349 /* Find (n+1)-th road vehicle. */
350 if (u->IsFrontEngine() && (n-- == 0)) {
351 if (u->crashed_ctr != 0 || u->disaster_vehicle != INVALID_VEHICLE) {
352 /* Targetted vehicle is crashed or already a target, destroy the UFO. */
353 delete v;
354 return false;
355 }
356 /* Target it. */
357 v->dest_tile = u->index;
358 v->age = 0;
359 u->disaster_vehicle = v->index;
360 break;
361 }
362 }
363
364 return true;
365 } else {
366 /* Target a vehicle */
367 RoadVehicle *u = RoadVehicle::Get(v->dest_tile.base());
368 assert(u != nullptr && u->type == VEH_ROAD && u->IsFrontEngine());
369
370 uint dist = Delta(v->x_pos, u->x_pos) + Delta(v->y_pos, u->y_pos);
371
372 if (dist < TILE_SIZE && !(u->vehstatus & VS_HIDDEN) && u->breakdown_ctr == 0) {
373 u->breakdown_ctr = 3;
374 u->breakdown_delay = 140;
375 }
376
377 v->direction = GetDirectionTowards(v, u->x_pos, u->y_pos);
378 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
379
380 int z = v->z_pos;
381 if (dist <= TILE_SIZE && z > u->z_pos) z--;
382 v->UpdatePosition(gp.x, gp.y, z);
383
384 if (z <= u->z_pos && (u->vehstatus & VS_HIDDEN) == 0) {
385 v->age++;
386 if (u->crashed_ctr == 0) {
387 uint victims = u->Crash();
388 u->disaster_vehicle = INVALID_VEHICLE;
389
390 AddTileNewsItem(STR_NEWS_DISASTER_SMALL_UFO, NT_ACCIDENT, u->tile);
391
392 AI::NewEvent(u->owner, new ScriptEventVehicleCrashed(u->index, u->tile, ScriptEventVehicleCrashed::CRASH_RV_UFO, victims));
393 Game::NewEvent(new ScriptEventVehicleCrashed(u->index, u->tile, ScriptEventVehicleCrashed::CRASH_RV_UFO, victims));
394 }
395 }
396
397 /* Destroy? */
398 if (v->age > 50) {
399 CreateEffectVehicleRel(v, 0, 7, 8, EV_EXPLOSION_LARGE);
400 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, v);
401 delete v;
402 return false;
403 }
404 }
405
406 return true;
407}
408
409static void DestructIndustry(Industry *i)
410{
411 for (const auto tile : Map::Iterate()) {
412 if (i->TileBelongsToIndustry(tile)) {
413 ResetIndustryConstructionStage(tile);
414 MarkTileDirtyByTile(tile);
415 }
416 }
417}
418
432 static bool DisasterTick_Aircraft(DisasterVehicle *v, uint16_t image_override, bool leave_at_top, StringID news_message, IndustryBehaviour industry_flag)
433{
434 v->tick_counter++;
435 v->image_override = (v->state == 1 && HasBit(v->tick_counter, 2)) ? image_override : 0;
436
437 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
438 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
439
440 if ((leave_at_top && gp.x < (-10 * (int)TILE_SIZE)) || (!leave_at_top && gp.x > (int)(Map::SizeX() * TILE_SIZE + 9 * TILE_SIZE) - 1)) {
441 delete v;
442 return false;
443 }
444
445 if (v->state == 2) {
446 if (GB(v->tick_counter, 0, 2) == 0) {
447 Industry *i = Industry::Get(v->dest_tile.base()); // Industry destructor calls ReleaseDisastersTargetingIndustry, so this is valid
448 int x = TileX(i->location.tile) * TILE_SIZE;
449 int y = TileY(i->location.tile) * TILE_SIZE;
450 uint32_t r = Random();
451
452 CreateEffectVehicleAbove(
453 GB(r, 0, 6) + x,
454 GB(r, 6, 6) + y,
455 GB(r, 12, 4),
456 EV_EXPLOSION_SMALL);
457
458 if (++v->age >= 55) v->state = 3;
459 }
460 } else if (v->state == 1) {
461 if (++v->age == 112) {
462 v->state = 2;
463 v->age = 0;
464
465 Industry *i = Industry::Get(v->dest_tile.base()); // Industry destructor calls ReleaseDisastersTargetingIndustry, so this is valid
466 DestructIndustry(i);
467
468 SetDParam(0, i->town->index);
469 AddIndustryNewsItem(news_message, NT_ACCIDENT, i->index);
470 if (_settings_client.sound.disaster) SndPlayTileFx(SND_12_EXPLOSION, i->location.tile);
471 }
472 } else if (v->state == 0) {
473 int x = v->x_pos + ((leave_at_top ? -15 : 15) * TILE_SIZE);
474 int y = v->y_pos;
475
476 if ((uint)x > Map::MaxX() * TILE_SIZE - 1) return true;
477
478 TileIndex tile = TileVirtXY(x, y);
479 if (!IsTileType(tile, MP_INDUSTRY)) return true;
480
481 IndustryID ind = GetIndustryIndex(tile);
482 v->dest_tile = ind;
483
484 if (GetIndustrySpec(Industry::Get(ind)->type)->behaviour & industry_flag) {
485 v->state = 1;
486 v->age = 0;
487 }
488 }
489
490 return true;
491}
492
494 static bool DisasterTick_Airplane(DisasterVehicle *v)
495{
496 return DisasterTick_Aircraft(v, SPR_F_15_FIRING, true, STR_NEWS_DISASTER_AIRPLANE_OIL_REFINERY, INDUSTRYBEH_AIRPLANE_ATTACKS);
497}
498
500 static bool DisasterTick_Helicopter(DisasterVehicle *v)
501{
502 return DisasterTick_Aircraft(v, SPR_AH_64A_FIRING, false, STR_NEWS_DISASTER_HELICOPTER_FACTORY, INDUSTRYBEH_CHOPPER_ATTACKS);
503}
504
506 static bool DisasterTick_Helicopter_Rotors(DisasterVehicle *v)
507{
508 v->tick_counter++;
509 if (HasBit(v->tick_counter, 0)) return true;
510
511 SpriteID &cur_image = v->sprite_cache.sprite_seq.seq[0].sprite;
512 if (++cur_image > SPR_ROTOR_MOVING_3) cur_image = SPR_ROTOR_MOVING_1;
513
514 v->UpdatePositionAndViewport();
515
516 return true;
517}
518
525 static bool DisasterTick_Big_Ufo(DisasterVehicle *v)
526{
527 v->tick_counter++;
528
529 if (v->state == 1) {
530 int x = TileX(v->dest_tile) * TILE_SIZE + TILE_SIZE / 2;
531 int y = TileY(v->dest_tile) * TILE_SIZE + TILE_SIZE / 2;
532 if (Delta(v->x_pos, x) + Delta(v->y_pos, y) >= 8) {
533 v->direction = GetDirectionTowards(v, x, y);
534
535 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
536 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
537 return true;
538 }
539
540 if (!IsValidTile(v->dest_tile)) {
541 /* Make sure we don't land outside the map. */
542 delete v;
543 return false;
544 }
545
546 int z = GetSlopePixelZ(v->x_pos, v->y_pos);
547 if (z < v->z_pos) {
548 v->UpdatePosition(v->x_pos, v->y_pos, v->z_pos - 1);
549 return true;
550 }
551
552 v->state = 2;
553
554 for (Vehicle *target : Vehicle::Iterate()) {
555 if (target->IsGroundVehicle()) {
556 if (Delta(target->x_pos, v->x_pos) + Delta(target->y_pos, v->y_pos) <= 12 * (int)TILE_SIZE) {
557 target->breakdown_ctr = 5;
558 target->breakdown_delay = 0xF0;
559 }
560 }
561 }
562
563 Town *t = ClosestTownFromTile(v->dest_tile, UINT_MAX);
564 SetDParam(0, t->index);
565 AddTileNewsItem(STR_NEWS_DISASTER_BIG_UFO, NT_ACCIDENT, v->tile);
566
567 if (!Vehicle::CanAllocateItem(2)) {
568 delete v;
569 return false;
570 }
571 DisasterVehicle *u = new DisasterVehicle(-6 * (int)TILE_SIZE, v->y_pos, DIR_SW, ST_BIG_UFO_DESTROYER, v->index);
572 DisasterVehicle *w = new DisasterVehicle(-6 * (int)TILE_SIZE, v->y_pos, DIR_SW, ST_BIG_UFO_DESTROYER_SHADOW);
573 u->SetNext(w);
574 } else if (v->state == 0) {
575 int x = TileX(v->dest_tile) * TILE_SIZE;
576 int y = TileY(v->dest_tile) * TILE_SIZE;
577 if (Delta(x, v->x_pos) + Delta(y, v->y_pos) >= (int)TILE_SIZE) {
578 v->direction = GetDirectionTowards(v, x, y);
579 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
580 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
581 return true;
582 }
583
584 if (++v->age < 6) {
585 v->dest_tile = RandomTile();
586 return true;
587 }
588 v->state = 1;
589
590 const auto is_valid_target = [](const Train *t) {
591 return t->IsFrontEngine() // Only the engines
592 && Company::IsHumanID(t->owner) // Don't break AIs
593 && IsPlainRailTile(t->tile) // No tunnels
594 && (t->vehstatus & VS_CRASHED) == 0; // Not crashed
595 };
596
597 uint n = 0; // Total number of targetable trains.
598 for (const Train *t : Train::Iterate()) {
599 if (is_valid_target(t)) n++;
600 }
601
602 if (n == 0) {
603 /* If there are no targetable trains, destroy the UFO. */
604 delete v;
605 return false;
606 }
607
608 n = RandomRange(n); // Choose one of them.
609 for (const Train *t : Train::Iterate()) {
610 /* Find (n+1)-th train. */
611 if (is_valid_target(t) && (n-- == 0)) {
612 /* Target it. */
613 v->dest_tile = t->tile;
614 v->age = 0;
615 break;
616 }
617 }
618 }
619
620 return true;
621}
622
627 static bool DisasterTick_Big_Ufo_Destroyer(DisasterVehicle *v)
628{
629 v->tick_counter++;
630
631 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
632 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
633
634 if (gp.x > (int)(Map::SizeX() * TILE_SIZE + 9 * TILE_SIZE) - 1) {
635 delete v;
636 return false;
637 }
638
639 if (v->state == 0) {
640 Vehicle *u = Vehicle::Get(v->big_ufo_destroyer_target);
641 if (Delta(v->x_pos, u->x_pos) > (int)TILE_SIZE) return true;
642 v->state = 1;
643
644 CreateEffectVehicleRel(u, 0, 7, 8, EV_EXPLOSION_LARGE);
645 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, u);
646
647 delete u;
648
649 for (int i = 0; i != 80; i++) {
650 uint32_t r = Random();
651 CreateEffectVehicleAbove(
652 GB(r, 0, 6) + v->x_pos - 32,
653 GB(r, 5, 6) + v->y_pos - 32,
654 0,
655 EV_EXPLOSION_SMALL);
656 }
657
658 for (int dy = -3; dy < 3; dy++) {
659 for (int dx = -3; dx < 3; dx++) {
660 TileIndex tile = TileAddWrap(v->tile, dx, dy);
661 if (tile != INVALID_TILE) DisasterClearSquare(tile);
662 }
663 }
664 }
665
666 return true;
667}
668
673 static bool DisasterTick_Submarine(DisasterVehicle *v)
674{
675 v->tick_counter++;
676
677 if (++v->age > 8880) {
678 delete v;
679 return false;
680 }
681
682 if (!HasBit(v->tick_counter, 0)) return true;
683
684 TileIndex tile = v->tile + TileOffsByDiagDir(DirToDiagDir(v->direction));
685 if (IsValidTile(tile)) {
686 TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0));
687 if (trackbits == TRACK_BIT_ALL && !Chance16(1, 90)) {
688 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
689 v->UpdatePosition(gp.x, gp.y, v->z_pos);
690 return true;
691 }
692 }
693
694 v->direction = ChangeDir(v->direction, GB(Random(), 0, 1) ? DIRDIFF_90RIGHT : DIRDIFF_90LEFT);
695
696 return true;
697}
698
699
700static bool DisasterTick_NULL(DisasterVehicle *)
701{
702 return true;
703}
704
705typedef bool DisasterVehicleTickProc(DisasterVehicle *v);
706
707static DisasterVehicleTickProc * const _disastervehicle_tick_procs[] = {
708 DisasterTick_Zeppeliner, DisasterTick_NULL,
709 DisasterTick_Ufo, DisasterTick_NULL,
710 DisasterTick_Airplane, DisasterTick_NULL,
711 DisasterTick_Helicopter, DisasterTick_NULL, DisasterTick_Helicopter_Rotors,
712 DisasterTick_Big_Ufo, DisasterTick_NULL, DisasterTick_Big_Ufo_Destroyer,
713 DisasterTick_NULL,
714 DisasterTick_Submarine,
715 DisasterTick_Submarine,
716};
717
718
719 bool DisasterVehicle::Tick()
720{
721 return _disastervehicle_tick_procs[this->subtype](this);
722}
723
724typedef void DisasterInitProc();
725
726
731 static void Disaster_Zeppeliner_Init()
732{
733 if (!Vehicle::CanAllocateItem(2)) return;
734
735 /* Pick a random place, unless we find a small airport */
736 int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;
737
738 for (const Station *st : Station::Iterate()) {
739 if (st->airport.tile != INVALID_TILE && (st->airport.type == AT_SMALL || st->airport.type == AT_LARGE)) {
740 x = (TileX(st->airport.tile) + 2) * TILE_SIZE;
741 break;
742 }
743 }
744
745 DisasterVehicle *v = new DisasterVehicle(x, 0, DIR_SE, ST_ZEPPELINER);
746 /* Allocate shadow */
747 DisasterVehicle *u = new DisasterVehicle(x, 0, DIR_SE, ST_ZEPPELINER_SHADOW);
748 v->SetNext(u);
749}
750
751
756 static void Disaster_Small_Ufo_Init()
757{
758 if (!Vehicle::CanAllocateItem(2)) return;
759
760 int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;
761 DisasterVehicle *v = new DisasterVehicle(x, 0, DIR_SE, ST_SMALL_UFO);
762 v->dest_tile = TileXY(Map::SizeX() / 2, Map::SizeY() / 2);
763
764 /* Allocate shadow */
765 DisasterVehicle *u = new DisasterVehicle(x, 0, DIR_SE, ST_SMALL_UFO_SHADOW);
766 v->SetNext(u);
767}
768
769
770/* Combat airplane which destroys an oil refinery */
771static void Disaster_Airplane_Init()
772{
773 if (!Vehicle::CanAllocateItem(2)) return;
774
775 Industry *found = nullptr;
776
777 for (Industry *i : Industry::Iterate()) {
778 if ((GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_AIRPLANE_ATTACKS) &&
779 (found == nullptr || Chance16(1, 2))) {
780 found = i;
781 }
782 }
783
784 if (found == nullptr) return;
785
786 /* Start from the bottom (south side) of the map */
787 int x = (Map::SizeX() + 9) * TILE_SIZE - 1;
788 int y = TileY(found->location.tile) * TILE_SIZE + 37;
789
790 DisasterVehicle *v = new DisasterVehicle(x, y, DIR_NE, ST_AIRPLANE);
791 DisasterVehicle *u = new DisasterVehicle(x, y, DIR_NE, ST_AIRPLANE_SHADOW);
792 v->SetNext(u);
793}
794
795
797 static void Disaster_Helicopter_Init()
798{
799 if (!Vehicle::CanAllocateItem(3)) return;
800
801 Industry *found = nullptr;
802
803 for (Industry *i : Industry::Iterate()) {
804 if ((GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_CHOPPER_ATTACKS) &&
805 (found == nullptr || Chance16(1, 2))) {
806 found = i;
807 }
808 }
809
810 if (found == nullptr) return;
811
812 int x = -16 * (int)TILE_SIZE;
813 int y = TileY(found->location.tile) * TILE_SIZE + 37;
814
815 DisasterVehicle *v = new DisasterVehicle(x, y, DIR_SW, ST_HELICOPTER);
816 DisasterVehicle *u = new DisasterVehicle(x, y, DIR_SW, ST_HELICOPTER_SHADOW);
817 v->SetNext(u);
818
819 DisasterVehicle *w = new DisasterVehicle(x, y, DIR_SW, ST_HELICOPTER_ROTORS);
820 u->SetNext(w);
821}
822
823
824/* Big Ufo which lands on a piece of rail and will consequently be shot
825 * down by a combat airplane, destroying the surroundings */
826static void Disaster_Big_Ufo_Init()
827{
828 if (!Vehicle::CanAllocateItem(2)) return;
829
830 int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;
831 int y = Map::MaxX() * TILE_SIZE - 1;
832
833 DisasterVehicle *v = new DisasterVehicle(x, y, DIR_NW, ST_BIG_UFO);
834 v->dest_tile = TileXY(Map::SizeX() / 2, Map::SizeY() / 2);
835
836 /* Allocate shadow */
837 DisasterVehicle *u = new DisasterVehicle(x, y, DIR_NW, ST_BIG_UFO_SHADOW);
838 v->SetNext(u);
839}
840
841
842static void Disaster_Submarine_Init(DisasterSubType subtype)
843{
844 if (!Vehicle::CanAllocateItem()) return;
845
846 int y;
847 Direction dir;
848 uint32_t r = Random();
849 int x = TileX(r) * TILE_SIZE + TILE_SIZE / 2;
850
851 if (HasBit(r, 31)) {
852 y = Map::MaxY() * TILE_SIZE - TILE_SIZE / 2 - 1;
853 dir = DIR_NW;
854 } else {
855 y = TILE_SIZE / 2;
856 if (_settings_game.construction.freeform_edges) y += TILE_SIZE;
857 dir = DIR_SE;
858 }
859 if (!IsWaterTile(TileVirtXY(x, y))) return;
860
861 new DisasterVehicle(x, y, dir, subtype);
862}
863
864/* Curious submarine #1, just floats around */
865static void Disaster_Small_Submarine_Init()
866{
867 Disaster_Submarine_Init(ST_SMALL_SUBMARINE);
868}
869
870
871/* Curious submarine #2, just floats around */
872static void Disaster_Big_Submarine_Init()
873{
874 Disaster_Submarine_Init(ST_BIG_SUBMARINE);
875}
876
877
882 static void Disaster_CoalMine_Init()
883{
884 int index = GB(Random(), 0, 4);
885 uint m;
886
887 for (m = 0; m < 15; m++) {
888 for (const Industry *i : Industry::Iterate()) {
889 if ((GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_CAN_SUBSIDENCE) && --index < 0) {
890 SetDParam(0, i->town->index);
891 AddTileNewsItem(STR_NEWS_DISASTER_COAL_MINE_SUBSIDENCE, NT_ACCIDENT, i->location.tile + TileDiffXY(1, 1)); // keep the news, even when the mine closes
892
893 {
894 TileIndex tile = i->location.tile;
895 TileIndexDiff step = TileOffsByDiagDir((DiagDirection)GB(Random(), 0, 2));
896
897 for (uint n = 0; n < 30; n++) {
898 DisasterClearSquare(tile);
899 tile += step;
900 if (!IsValidTile(tile)) break;
901 }
902 }
903 return;
904 }
905 }
906 }
907}
908
909 struct Disaster {
910 DisasterInitProc *init_proc;
911 TimerGameCalendar::Year min_year;
912 TimerGameCalendar::Year max_year;
913};
914
915static const Disaster _disasters[] = {
916 {Disaster_Zeppeliner_Init, 1930, 1955}, // zeppeliner
917 {Disaster_Small_Ufo_Init, 1940, 1970}, // ufo (small)
918 {Disaster_Airplane_Init, 1960, 1990}, // airplane
919 {Disaster_Helicopter_Init, 1970, 2000}, // helicopter
920 {Disaster_Big_Ufo_Init, 2000, 2100}, // ufo (big)
921 {Disaster_Small_Submarine_Init, 1940, 1965}, // submarine (small)
922 {Disaster_Big_Submarine_Init, 1975, 2010}, // submarine (big)
923 {Disaster_CoalMine_Init, 1950, 1985}, // coalmine
924};
925
926static void DoDisaster()
927{
928 std::vector<DisasterInitProc *> available_disasters;
929
930 for (auto &disaster : _disasters) {
931 if (TimerGameCalendar::year >= disaster.min_year && TimerGameCalendar::year < disaster.max_year) {
932 available_disasters.push_back(disaster.init_proc);
933 }
934 }
935
936 if (available_disasters.empty()) return;
937
938 available_disasters[RandomRange(static_cast<uint32_t>(available_disasters.size()))]();
939}
940
941
942static void ResetDisasterDelay()
943{
944 _disaster_delay = GB(Random(), 0, 9) + 730;
945}
946
947static IntervalTimer<TimerGameEconomy> _economy_disaster_daily({TimerGameEconomy::DAY, TimerGameEconomy::Priority::DISASTER}, [](auto)
948{
949 if (--_disaster_delay != 0) return;
950
951 ResetDisasterDelay();
952
953 if (_settings_game.difficulty.disasters != 0) DoDisaster();
954});
955
956void StartupDisasters()
957{
958 ResetDisasterDelay();
959}
960
966 void ReleaseDisastersTargetingIndustry(IndustryID i)
967{
968 for (DisasterVehicle *v : DisasterVehicle::Iterate()) {
969 /* primary disaster vehicles that have chosen target */
970 if (v->subtype == ST_AIRPLANE || v->subtype == ST_HELICOPTER) {
971 /* if it has chosen target, and it is this industry (yes, dest_tile is IndustryID here), set order to "leaving map peacefully" */
972 if (v->state > 0 && v->dest_tile == (uint32_t)i) v->state = 3;
973 }
974 }
975}
976
981 void ReleaseDisasterVehicle(VehicleID vehicle)
982{
983 DisasterVehicle *v = DisasterVehicle::GetIfValid(vehicle);
984 if (v == nullptr) return;
985
986 /* primary disaster vehicles that have chosen target */
987 assert(v->subtype == ST_SMALL_UFO);
988 assert(v->state != 0);
989
990 /* Revert to target-searching */
991 v->state = 0;
992 v->dest_tile = RandomTile();
993 GetAircraftFlightLevelBounds(v, &v->z_pos, nullptr);
994 v->age = 0;
995}
996
997 void DisasterVehicle::UpdateDeltaXY()
998{
999 this->x_offs = -1;
1000 this->y_offs = -1;
1001 this->x_extent = 2;
1002 this->y_extent = 2;
1003 this->z_extent = 5;
1004}
ai.hpp
Base functions for all AIs.
aircraft.h
Base for aircraft.
GetAircraftFlightLevelBounds
void GetAircraftFlightLevelBounds(const Vehicle *v, int *min, int *max)
Get the 'flight level' bounds, in pixels from 'z_pos' 0 for a particular vehicle for normal flight si...
Definition aircraft_cmd.cpp:728
ROTOR_Z_OFFSET
static const int ROTOR_Z_OFFSET
Z Offset between helicopter- and rotorsprite.
Definition aircraft.h:48
AT_SMALL
@ AT_SMALL
Small airport.
Definition airport.h:29
AT_LARGE
@ AT_LARGE
Large airport.
Definition airport.h:30
backup_type.hpp
Class for backupping variables and making sure they are restored later.
HasBit
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition bitmath_func.hpp:103
CLRBITS
#define CLRBITS(x, y)
Clears several bits in a variable.
Definition bitmath_func.hpp:166
SETBITS
#define SETBITS(x, y)
Sets several bits in a variable.
Definition bitmath_func.hpp:136
GB
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Definition bitmath_func.hpp:32
AI::NewEvent
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition ai_core.cpp:243
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition game_core.cpp:146
IntervalTimer
An interval timer will fire every interval, and will continue to fire until it is deleted.
Definition timer.h:76
TimerGameCalendar::year
static Year year
Current year, starting at 0.
Definition timer_game_calendar.h:31
command_func.h
Functions related to commands.
DC_EXEC
@ DC_EXEC
execute the given command
Definition command_type.h:376
company_base.h
Definition of stuff that is very close to a company, like the company struct itself.
_current_company
CompanyID _current_company
Company currently doing an action.
Definition company_cmd.cpp:53
company_func.h
Functions related to companies.
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition company_type.h:25
OWNER_WATER
@ OWNER_WATER
The tile/execution is done by "water".
Definition company_type.h:26
ChangeDir
Direction ChangeDir(Direction d, DirDiff delta)
Change a direction by a given difference.
Definition direction_func.h:104
DirToDiagDir
DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
Definition direction_func.h:166
Direction
Direction
Defines the 8 directions on the map.
Definition direction_type.h:24
DIR_SW
@ DIR_SW
Southwest.
Definition direction_type.h:31
DIR_NW
@ DIR_NW
Northwest.
Definition direction_type.h:33
DIR_SE
@ DIR_SE
Southeast.
Definition direction_type.h:29
DIR_NE
@ DIR_NE
Northeast.
Definition direction_type.h:27
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition direction_type.h:73
DIRDIFF_90LEFT
@ DIRDIFF_90LEFT
Angle of 90 degrees left.
Definition direction_type.h:63
DIRDIFF_90RIGHT
@ DIRDIFF_90RIGHT
Angle of 90 degrees right.
Definition direction_type.h:61
DisasterTick_Big_Ufo_Destroyer
static bool DisasterTick_Big_Ufo_Destroyer(DisasterVehicle *v)
Skyranger destroying (Big) Ufo handling, v->state states: 0: Home in on landed Ufo and shoot it down.
Definition disaster_vehicle.cpp:627
Disaster_Small_Ufo_Init
static void Disaster_Small_Ufo_Init()
Ufo which flies around aimlessly from the middle of the map a bit until it locates a road vehicle whi...
Definition disaster_vehicle.cpp:756
DisasterTick_Big_Ufo
static bool DisasterTick_Big_Ufo(DisasterVehicle *v)
(Big) Ufo handling, v->state states: 0: Fly around to the middle of the map, then randomly for a whil...
Definition disaster_vehicle.cpp:525
Disaster_Helicopter_Init
static void Disaster_Helicopter_Init()
Combat helicopter that destroys a factory.
Definition disaster_vehicle.cpp:797
DisasterTick_Zeppeliner
static bool DisasterTick_Zeppeliner(DisasterVehicle *v)
Zeppeliner handling, v->state states: 0: Zeppeliner initialization has found a small airport,...
Definition disaster_vehicle.cpp:224
DisasterTick_Helicopter_Rotors
static bool DisasterTick_Helicopter_Rotors(DisasterVehicle *v)
Helicopter rotor blades; keep these spinning.
Definition disaster_vehicle.cpp:506
DisasterTick_Ufo
static bool DisasterTick_Ufo(DisasterVehicle *v)
(Small) Ufo handling, v->state states: 0: Fly around to the middle of the map, then randomly,...
Definition disaster_vehicle.cpp:316
DisasterTick_Airplane
static bool DisasterTick_Airplane(DisasterVehicle *v)
Airplane handling.
Definition disaster_vehicle.cpp:494
Disaster_Zeppeliner_Init
static void Disaster_Zeppeliner_Init()
Zeppeliner which crashes on a small airport if one found, otherwise crashes on a random tile.
Definition disaster_vehicle.cpp:731
_disaster_delay
uint16_t _disaster_delay
Delay counter for considering the next disaster.
Definition disaster_vehicle.cpp:57
ReleaseDisasterVehicle
void ReleaseDisasterVehicle(VehicleID vehicle)
Notify disasters that we are about to delete a vehicle.
Definition disaster_vehicle.cpp:981
DisasterTick_Aircraft
static bool DisasterTick_Aircraft(DisasterVehicle *v, uint16_t image_override, bool leave_at_top, StringID news_message, IndustryBehaviour industry_flag)
Aircraft handling, v->state states: 0: Fly towards the targeted industry 1: If within 15 tiles,...
Definition disaster_vehicle.cpp:432
DisasterTick_Submarine
static bool DisasterTick_Submarine(DisasterVehicle *v)
Submarine, v->state states: Unused, just float around aimlessly and pop up at different places,...
Definition disaster_vehicle.cpp:673
DisasterTick_Helicopter
static bool DisasterTick_Helicopter(DisasterVehicle *v)
Helicopter handling.
Definition disaster_vehicle.cpp:500
ReleaseDisastersTargetingIndustry
void ReleaseDisastersTargetingIndustry(IndustryID i)
Marks all disasters targeting this industry in such a way they won't call Industry::Get(v->dest_tile)...
Definition disaster_vehicle.cpp:966
Disaster_CoalMine_Init
static void Disaster_CoalMine_Init()
Coal mine catastrophe, destroys a stretch of 30 tiles of land in a certain direction.
Definition disaster_vehicle.cpp:882
disaster_vehicle.h
All disaster vehicles.
DisasterSubType
DisasterSubType
Different sub types of disaster vehicles.
Definition disaster_vehicle.h:16
ST_ZEPPELINER_SHADOW
@ ST_ZEPPELINER_SHADOW
Shadow of the zeppelin.
Definition disaster_vehicle.h:18
ST_HELICOPTER_SHADOW
@ ST_HELICOPTER_SHADOW
Shadow of helicopter.
Definition disaster_vehicle.h:24
ST_SMALL_UFO_SHADOW
@ ST_SMALL_UFO_SHADOW
Shadow of small UFO.
Definition disaster_vehicle.h:20
ST_SMALL_UFO
@ ST_SMALL_UFO
Small UFO, tries to find a road vehicle to destroy.
Definition disaster_vehicle.h:19
ST_BIG_UFO
@ ST_BIG_UFO
Big UFO, finds a piece of railroad to "park" on.
Definition disaster_vehicle.h:26
ST_BIG_UFO_SHADOW
@ ST_BIG_UFO_SHADOW
Shadow of the big UFO.
Definition disaster_vehicle.h:27
ST_ZEPPELINER
@ ST_ZEPPELINER
Zeppelin, crashes at airports.
Definition disaster_vehicle.h:17
ST_BIG_UFO_DESTROYER_SHADOW
@ ST_BIG_UFO_DESTROYER_SHADOW
Shadow of the aircraft.
Definition disaster_vehicle.h:29
ST_BIG_UFO_DESTROYER
@ ST_BIG_UFO_DESTROYER
Aircraft the will bomb the big UFO.
Definition disaster_vehicle.h:28
ST_BIG_SUBMARINE
@ ST_BIG_SUBMARINE
Big submarine, pops up in the oceans but doesn't do anything.
Definition disaster_vehicle.h:31
ST_SMALL_SUBMARINE
@ ST_SMALL_SUBMARINE
Small submarine, pops up in the oceans but doesn't do anything.
Definition disaster_vehicle.h:30
ST_HELICOPTER
@ ST_HELICOPTER
Helicopter destroying a factory.
Definition disaster_vehicle.h:23
ST_AIRPLANE
@ ST_AIRPLANE
Airplane destroying an oil refinery.
Definition disaster_vehicle.h:21
ST_HELICOPTER_ROTORS
@ ST_HELICOPTER_ROTORS
Rotors of helicopter.
Definition disaster_vehicle.h:25
ST_AIRPLANE_SHADOW
@ ST_AIRPLANE_SHADOW
Shadow of airplane.
Definition disaster_vehicle.h:22
CreateEffectVehicleRel
EffectVehicle * CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular vehicle.
Definition effectvehicle.cpp:610
CreateEffectVehicleAbove
EffectVehicle * CreateEffectVehicleAbove(int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular location.
Definition effectvehicle.cpp:594
effectvehicle_func.h
Functions related to effect vehicles.
EV_CRASH_SMOKE
@ EV_CRASH_SMOKE
Smoke of disasters.
Definition effectvehicle_func.h:21
EV_EXPLOSION_SMALL
@ EV_EXPLOSION_SMALL
Various explosions.
Definition effectvehicle_func.h:24
EV_EXPLOSION_LARGE
@ EV_EXPLOSION_LARGE
Various explosions.
Definition effectvehicle_func.h:22
game.hpp
Base functions for all Games.
SpriteID
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:18
MarkTileDirtyByTile
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Definition viewport.cpp:2057
industry.h
Base of all industries.
GetIndustrySpec
const IndustrySpec * GetIndustrySpec(IndustryType thistype)
Accessor for array _industry_specs.
Definition industry_cmd.cpp:123
ResetIndustryConstructionStage
void ResetIndustryConstructionStage(Tile tile)
Reset the construction stage counter of the industry, as well as the completion bit.
Definition industry_map.h:187
GetIndustryIndex
IndustryID GetIndustryIndex(Tile t)
Get the industry ID of the given tile.
Definition industry_map.h:63
IndustryBehaviour
IndustryBehaviour
Various industry behaviours mostly to represent original TTD specialities.
Definition industrytype.h:55
INDUSTRYBEH_CAN_SUBSIDENCE
@ INDUSTRYBEH_CAN_SUBSIDENCE
can cause a subsidence (coal mine, shaft that collapses)
Definition industrytype.h:70
INDUSTRYBEH_AIRPLANE_ATTACKS
@ INDUSTRYBEH_AIRPLANE_ATTACKS
can be exploded by a military airplane (oil refinery)
Definition industrytype.h:68
INDUSTRYBEH_CHOPPER_ATTACKS
@ INDUSTRYBEH_CHOPPER_ATTACKS
can be exploded by a military helicopter (factory)
Definition industrytype.h:69
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition landscape.cpp:554
GetSlopePixelZ
int GetSlopePixelZ(int x, int y, bool ground_vehicle)
Return world Z coordinate of a given point of a tile.
Definition landscape.cpp:303
landscape_cmd.h
Command definitions related to landscape (slopes etc.).
TileAddWrap
TileIndex TileAddWrap(TileIndex tile, int addx, int addy)
This function checks if we add addx/addy to tile, if we do wrap around the edges.
Definition map.cpp:97
TileXY
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition map_func.h:373
TileDiffXY
TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition map_func.h:389
RandomTile
#define RandomTile()
Get a valid random tile.
Definition map_func.h:661
TileY
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:425
TileX
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:415
TileOffsByDiagDir
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition map_func.h:567
TileVirtXY
static debug_inline TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition map_func.h:404
TileIndexDiff
int32_t TileIndexDiff
An offset value between two tiles.
Definition map_type.h:23
Delta
constexpr T Delta(const T a, const T b)
Returns the (absolute) difference between two (scalar) variables.
Definition math_func.hpp:234
Clamp
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition math_func.hpp:79
news_func.h
Functions related to news.
NT_ACCIDENT
@ NT_ACCIDENT
An accident or disaster has occurred.
Definition news_type.h:26
IsRailDepot
static debug_inline bool IsRailDepot(Tile t)
Is this rail tile a rail depot?
Definition rail_map.h:95
IsPlainRailTile
static debug_inline bool IsPlainRailTile(Tile t)
Checks whether the tile is a rail tile or rail tile with signals.
Definition rail_map.h:60
random_func.hpp
Pseudo random number generator.
RandomRange
uint32_t RandomRange(uint32_t limit, const std::source_location location=std::source_location::current())
Pick a random number between 0 and limit - 1, inclusive.
Definition random_func.hpp:88
Chance16
bool Chance16(const uint32_t a, const uint32_t b, const std::source_location location=std::source_location::current())
Flips a coin with given probability.
Definition random_func.hpp:134
roadveh.h
Road vehicle states.
safeguards.h
A number of safeguards to prevent using unsafe methods.
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:57
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:56
UpdateSignalsInBuffer
void UpdateSignalsInBuffer()
Update signals in buffer Called from 'outside'.
Definition signal.cpp:576
sound_func.h
Functions related to sound.
SND_12_EXPLOSION
@ SND_12_EXPLOSION
16 == 0x10 Destruction, crashes, disasters, ...
Definition sound_type.h:63
station_base.h
Base classes/functions for stations.
IsAirportTile
bool IsAirportTile(Tile t)
Is this tile a station tile and an airport tile?
Definition station_map.h:167
GetStationIndex
StationID GetStationIndex(Tile t)
Get StationID from a tile.
Definition station_map.h:28
stdafx.h
Definition of base types and functions in a cross-platform compatible way.
SetDParam
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Definition strings.cpp:104
strings_func.h
Functions related to OTTD's strings.
StringID
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition strings_type.h:16
Airport::flags
uint64_t flags
stores which blocks on the airport are taken. was 16 bit earlier on, then 32
Definition station_base.h:293
Backup
Class to backup a specific variable and restore it later.
Definition backup_type.hpp:21
Backup::Restore
void Restore()
Restore the variable.
Definition backup_type.hpp:110
BaseStation::GetByTile
static BaseStation * GetByTile(TileIndex tile)
Get the base station belonging to a specific tile.
Definition base_station_base.h:166
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition vehicle_type.h:51
ClientSettings::sound
SoundSettings sound
sound effect settings
Definition settings_type.h:613
CommandHelper
Definition command_func.h:83
Company
Definition company_base.h:133
Company::IsHumanID
static bool IsHumanID(size_t index)
Is this company a company not controlled by a NoAI program?
Definition company_base.h:184
ConstructionSettings::freeform_edges
bool freeform_edges
allow terraforming the tiles at the map edges
Definition settings_type.h:395
DifficultySettings::disasters
bool disasters
are disasters enabled
Definition settings_type.h:115
DisasterVehicle
Disasters, like submarines, skyrangers and their shadows, belong to this class.
Definition disaster_vehicle.h:37
DisasterVehicle::UpdateDeltaXY
void UpdateDeltaXY() override
Updates the x and y offsets and the size of the sprite used for this vehicle.
Definition disaster_vehicle.cpp:997
DisasterVehicle::image_override
SpriteID image_override
Override for the default disaster vehicle sprite.
Definition disaster_vehicle.h:38
DisasterVehicle::UpdatePosition
void UpdatePosition(int x, int y, int z)
Update the position of the vehicle.
Definition disaster_vehicle.cpp:183
DisasterVehicle::DisasterVehicle
DisasterVehicle()
For use by saveload.
Definition disaster_vehicle.h:44
DisasterVehicle::big_ufo_destroyer_target
VehicleID big_ufo_destroyer_target
The big UFO that this destroyer is supposed to bomb.
Definition disaster_vehicle.h:39
DisasterVehicle::Tick
bool Tick() override
Calls the tick handler of the vehicle.
Definition disaster_vehicle.cpp:719
DisasterVehicle::state
uint16_t state
Action stage of the disaster vehicle.
Definition disaster_vehicle.h:41
Disaster
Definition disaster_vehicle.cpp:909
Disaster::init_proc
DisasterInitProc * init_proc
The init function for this disaster.
Definition disaster_vehicle.cpp:910
Disaster::min_year
TimerGameCalendar::Year min_year
The first year this disaster will occur.
Definition disaster_vehicle.cpp:911
Disaster::max_year
TimerGameCalendar::Year max_year
The last year this disaster will occur.
Definition disaster_vehicle.cpp:912
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition settings_type.h:594
GameSettings::difficulty
DifficultySettings difficulty
settings related to the difficulty
Definition settings_type.h:592
GetNewVehiclePosResult
Position information of a vehicle after it moved.
Definition vehicle_func.h:77
GetNewVehiclePosResult::y
int y
x and y position of the vehicle after moving
Definition vehicle_func.h:78
IndustrySpec::behaviour
IndustryBehaviour behaviour
How this industry will behave, and how others entities can use it.
Definition industrytype.h:119
Industry
Defines the internal data of a functional industry.
Definition industry.h:66
Industry::type
IndustryType type
type of industry.
Definition industry.h:102
Industry::town
Town * town
Nearest town.
Definition industry.h:95
Industry::location
TileArea location
Location of the industry.
Definition industry.h:94
Industry::TileBelongsToIndustry
bool TileBelongsToIndustry(TileIndex tile) const
Check if a given tile belongs to this industry.
Definition industry.h:135
Map
Size related data of the map.
Definition map_func.h:206
Map::SizeY
static uint SizeY()
Get the size of the map along the Y.
Definition map_func.h:279
Map::SizeX
static debug_inline uint SizeX()
Get the size of the map along the X.
Definition map_func.h:270
Map::MaxY
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition map_func.h:306
Map::MaxX
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition map_func.h:297
MutableSpriteCache::sprite_seq
VehicleSpriteSeq sprite_seq
Vehicle appearance.
Definition vehicle_base.h:200
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition tilearea_type.h:19
PalSpriteID::sprite
SpriteID sprite
The 'real' sprite.
Definition gfx_type.h:24
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition pool_type.hpp:238
Pool::PoolItem<&_company_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition pool_type.hpp:388
Pool::PoolItem<&_vehicle_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition pool_type.hpp:350
Pool::PoolItem<&_vehicle_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition pool_type.hpp:309
Pool::PoolItem<&_industry_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition pool_type.hpp:339
RoadVehicle
Buses, trucks and trams belong to this class.
Definition roadveh.h:98
RoadVehicle::Crash
uint Crash(bool flooded=false) override
Common code executed for crashed ground vehicles.
Definition roadveh_cmd.cpp:529
RoadVehicle::crashed_ctr
uint16_t crashed_ctr
Animation counter when the vehicle has crashed.
Definition roadveh.h:105
RoadVehicle::disaster_vehicle
VehicleID disaster_vehicle
NOSAVE: Disaster vehicle targetting this vehicle.
Definition roadveh.h:109
SoundSettings::disaster
bool disaster
Play disaster and accident sounds.
Definition settings_type.h:250
SpecializedStation< Station, false >::Iterate
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Definition base_station_base.h:305
SpecializedVehicle
Class defining several overloaded accessors so we don't have to cast vehicle types that often.
Definition vehicle_base.h:1095
SpecializedVehicle< DisasterVehicle, VEH_DISASTER >::Next
DisasterVehicle * Next() const
Get next vehicle in the chain.
Definition vehicle_base.h:1130
SpecializedVehicle::Iterate
static Pool::IterateWrapper< T > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
Definition vehicle_base.h:1284
SpecializedVehicle::Get
static T * Get(size_t index)
Gets vehicle with given index.
Definition vehicle_base.h:1196
Station
Station data structure.
Definition station_base.h:439
Station::airport
Airport airport
Tile area the airport covers.
Definition station_base.h:453
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
Town
Town data structure.
Definition town.h:54
Train
'Train' is either a loco or a wagon.
Definition train.h:89
VehicleSpriteSeq::Set
void Set(SpriteID sprite)
Assign a single sprite to the sequence.
Definition vehicle_base.h:168
Vehicle
Vehicle data structure.
Definition vehicle_base.h:244
Vehicle::z_pos
int32_t z_pos
z coordinate.
Definition vehicle_base.h:306
Vehicle::direction
Direction direction
facing
Definition vehicle_base.h:307
Vehicle::x_extent
uint8_t x_extent
x-extent of vehicle bounding box
Definition vehicle_base.h:316
Vehicle::subtype
uint8_t subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
Definition vehicle_base.h:355
Vehicle::breakdown_ctr
uint8_t breakdown_ctr
Counter for managing breakdown events.
Definition vehicle_base.h:299
Vehicle::breakdown_delay
uint8_t breakdown_delay
Counter for managing breakdown length.
Definition vehicle_base.h:300
Vehicle::z_extent
uint8_t z_extent
z-extent of vehicle bounding box
Definition vehicle_base.h:318
Vehicle::y_offs
int8_t y_offs
y offset for vehicle sprite
Definition vehicle_base.h:322
Vehicle::IsFrontEngine
debug_inline bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition vehicle_base.h:945
Vehicle::x_offs
int8_t x_offs
x offset for vehicle sprite
Definition vehicle_base.h:321
Vehicle::y_pos
int32_t y_pos
y coordinate.
Definition vehicle_base.h:305
Vehicle::x_pos
int32_t x_pos
x coordinate.
Definition vehicle_base.h:304
Vehicle::y_extent
uint8_t y_extent
y-extent of vehicle bounding box
Definition vehicle_base.h:317
Vehicle::vehstatus
uint8_t vehstatus
Status.
Definition vehicle_base.h:354
Vehicle::age
TimerGameCalendar::Date age
Age in calendar days.
Definition vehicle_base.h:292
Vehicle::SetNext
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
Definition vehicle.cpp:2937
Vehicle::sprite_cache
MutableSpriteCache sprite_cache
Cache of sprites and values related to recalculating them, see MutableSpriteCache.
Definition vehicle_base.h:368
Vehicle::UpdatePositionAndViewport
void UpdatePositionAndViewport()
Update the position of the vehicle, and update the viewport.
Definition vehicle.cpp:1764
Vehicle::tick_counter
uint8_t tick_counter
Increased by one for each tick.
Definition vehicle_base.h:350
Vehicle::tile
TileIndex tile
Current tile index.
Definition vehicle_base.h:264
Vehicle::dest_tile
TileIndex dest_tile
Heading for this tile.
Definition vehicle_base.h:271
Vehicle::UpdatePosition
void UpdatePosition()
Update the position of the vehicle.
Definition vehicle.cpp:1693
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition vehicle_base.h:309
GetTileOwner
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition tile_map.h:178
GetTileType
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition tile_map.h:96
IsValidTile
bool IsValidTile(Tile tile)
Checks if a tile is valid.
Definition tile_map.h:161
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:95
MP_TREES
@ MP_TREES
Tile got trees.
Definition tile_type.h:52
MP_CLEAR
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition tile_type.h:48
MP_HOUSE
@ MP_HOUSE
A house by a town.
Definition tile_type.h:51
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition tile_type.h:49
MP_INDUSTRY
@ MP_INDUSTRY
Part of an industry.
Definition tile_type.h:56
timer.h
Definition of Interval and OneShot timers.
timer_game_economy.h
Definition of the game-economy-timer.
town.h
Base of the town class.
ClosestTownFromTile
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
Definition town_cmd.cpp:3896
TrackStatusToTrackBits
TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition track_func.h:363
TrackBits
TrackBits
Allow incrementing of Track variables.
Definition track_type.h:35
TRACK_BIT_ALL
@ TRACK_BIT_ALL
All possible tracks.
Definition track_type.h:50
train.h
Base for the train class.
TRANSPORT_WATER
@ TRANSPORT_WATER
Transport over water.
Definition transport_type.h:29
EnsureNoVehicleOnGround
CommandCost EnsureNoVehicleOnGround(TileIndex tile)
Ensure there is no vehicle at the ground at the given position.
Definition vehicle.cpp:546
GetNewVehiclePos
GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v)
Get position information of a vehicle when moving one pixel in the direction it is facing.
Definition vehicle.cpp:1784
VS_UNCLICKABLE
@ VS_UNCLICKABLE
Vehicle is not clickable by the user (shadow vehicles).
Definition vehicle_base.h:35
VS_SHADOW
@ VS_SHADOW
Vehicle is a shadow vehicle.
Definition vehicle_base.h:38
VS_HIDDEN
@ VS_HIDDEN
Vehicle is not visible.
Definition vehicle_base.h:33
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition vehicle_base.h:40
vehicle_func.h
Functions related to vehicles.
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition vehicle_type.h:25
VehicleID
uint32_t VehicleID
The type all our vehicle IDs have.
Definition vehicle_type.h:16
INVALID_VEHICLE
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
Definition vehicle_type.h:54
viewport_func.h
Functions related to (drawing on) viewports.
IsWaterTile
bool IsWaterTile(Tile t)
Is it a water tile with plain water?
Definition water_map.h:190