OpenTTD Source: src/disaster_vehicle.cpp Source File

OpenTTD Source 14.0-beta3

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
57 uint16_t _disaster_delay;
58
59 static 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, FILE_LINE);
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, FILE_LINE);
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
92 static const SpriteID _disaster_images_1[] = {SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP, SPR_BLIMP};
93 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};
94 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};
95 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};
96 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};
97 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};
98 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};
99 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};
100 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};
101
102 static 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
112 void 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 (const RoadVehicle *u : RoadVehicle::Iterate()) {
349 /* Find (n+1)-th road vehicle. */
350 if (u->IsFrontEngine() && (n-- == 0)) {
351 /* Target it. */
352 v->dest_tile = u->index;
353 v->age = 0;
354 break;
355 }
356 }
357
358 return true;
359 } else {
360 /* Target a vehicle */
361 RoadVehicle *u = RoadVehicle::Get(v->dest_tile.base());
362 assert(u != nullptr && u->type == VEH_ROAD && u->IsFrontEngine());
363
364 uint dist = Delta(v->x_pos, u->x_pos) + Delta(v->y_pos, u->y_pos);
365
366 if (dist < TILE_SIZE && !(u->vehstatus & VS_HIDDEN) && u->breakdown_ctr == 0) {
367 u->breakdown_ctr = 3;
368 u->breakdown_delay = 140;
369 }
370
371 v->direction = GetDirectionTowards(v, u->x_pos, u->y_pos);
372 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
373
374 int z = v->z_pos;
375 if (dist <= TILE_SIZE && z > u->z_pos) z--;
376 v->UpdatePosition(gp.x, gp.y, z);
377
378 if (z <= u->z_pos && (u->vehstatus & VS_HIDDEN) == 0) {
379 v->age++;
380 if (u->crashed_ctr == 0) {
381 u->Crash();
382
383 AddTileNewsItem(STR_NEWS_DISASTER_SMALL_UFO, NT_ACCIDENT, u->tile);
384
385 AI::NewEvent(u->owner, new ScriptEventVehicleCrashed(u->index, u->tile, ScriptEventVehicleCrashed::CRASH_RV_UFO));
386 Game::NewEvent(new ScriptEventVehicleCrashed(u->index, u->tile, ScriptEventVehicleCrashed::CRASH_RV_UFO));
387 }
388 }
389
390 /* Destroy? */
391 if (v->age > 50) {
392 CreateEffectVehicleRel(v, 0, 7, 8, EV_EXPLOSION_LARGE);
393 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, v);
394 delete v;
395 return false;
396 }
397 }
398
399 return true;
400 }
401
402 static void DestructIndustry(Industry *i)
403 {
404 for (TileIndex tile = 0; tile != Map::Size(); tile++) {
405 if (i->TileBelongsToIndustry(tile)) {
406 ResetIndustryConstructionStage(tile);
407 MarkTileDirtyByTile(tile);
408 }
409 }
410 }
411
425 static bool DisasterTick_Aircraft(DisasterVehicle *v, uint16_t image_override, bool leave_at_top, StringID news_message, IndustryBehaviour industry_flag)
426 {
427 v->tick_counter++;
428 v->image_override = (v->state == 1 && HasBit(v->tick_counter, 2)) ? image_override : 0;
429
430 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
431 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
432
433 if ((leave_at_top && gp.x < (-10 * (int)TILE_SIZE)) || (!leave_at_top && gp.x > (int)(Map::SizeX() * TILE_SIZE + 9 * TILE_SIZE) - 1)) {
434 delete v;
435 return false;
436 }
437
438 if (v->state == 2) {
439 if (GB(v->tick_counter, 0, 2) == 0) {
440 Industry *i = Industry::Get(v->dest_tile.base()); // Industry destructor calls ReleaseDisastersTargetingIndustry, so this is valid
441 int x = TileX(i->location.tile) * TILE_SIZE;
442 int y = TileY(i->location.tile) * TILE_SIZE;
443 uint32_t r = Random();
444
445 CreateEffectVehicleAbove(
446 GB(r, 0, 6) + x,
447 GB(r, 6, 6) + y,
448 GB(r, 12, 4),
449 EV_EXPLOSION_SMALL);
450
451 if (++v->age >= 55) v->state = 3;
452 }
453 } else if (v->state == 1) {
454 if (++v->age == 112) {
455 v->state = 2;
456 v->age = 0;
457
458 Industry *i = Industry::Get(v->dest_tile.base()); // Industry destructor calls ReleaseDisastersTargetingIndustry, so this is valid
459 DestructIndustry(i);
460
461 SetDParam(0, i->town->index);
462 AddIndustryNewsItem(news_message, NT_ACCIDENT, i->index);
463 if (_settings_client.sound.disaster) SndPlayTileFx(SND_12_EXPLOSION, i->location.tile);
464 }
465 } else if (v->state == 0) {
466 int x = v->x_pos + ((leave_at_top ? -15 : 15) * TILE_SIZE);
467 int y = v->y_pos;
468
469 if ((uint)x > Map::MaxX() * TILE_SIZE - 1) return true;
470
471 TileIndex tile = TileVirtXY(x, y);
472 if (!IsTileType(tile, MP_INDUSTRY)) return true;
473
474 IndustryID ind = GetIndustryIndex(tile);
475 v->dest_tile = ind;
476
477 if (GetIndustrySpec(Industry::Get(ind)->type)->behaviour & industry_flag) {
478 v->state = 1;
479 v->age = 0;
480 }
481 }
482
483 return true;
484 }
485
487 static bool DisasterTick_Airplane(DisasterVehicle *v)
488 {
489 return DisasterTick_Aircraft(v, SPR_F_15_FIRING, true, STR_NEWS_DISASTER_AIRPLANE_OIL_REFINERY, INDUSTRYBEH_AIRPLANE_ATTACKS);
490 }
491
493 static bool DisasterTick_Helicopter(DisasterVehicle *v)
494 {
495 return DisasterTick_Aircraft(v, SPR_AH_64A_FIRING, false, STR_NEWS_DISASTER_HELICOPTER_FACTORY, INDUSTRYBEH_CHOPPER_ATTACKS);
496 }
497
499 static bool DisasterTick_Helicopter_Rotors(DisasterVehicle *v)
500 {
501 v->tick_counter++;
502 if (HasBit(v->tick_counter, 0)) return true;
503
504 SpriteID &cur_image = v->sprite_cache.sprite_seq.seq[0].sprite;
505 if (++cur_image > SPR_ROTOR_MOVING_3) cur_image = SPR_ROTOR_MOVING_1;
506
507 v->UpdatePositionAndViewport();
508
509 return true;
510 }
511
518 static bool DisasterTick_Big_Ufo(DisasterVehicle *v)
519 {
520 v->tick_counter++;
521
522 if (v->state == 1) {
523 int x = TileX(v->dest_tile) * TILE_SIZE + TILE_SIZE / 2;
524 int y = TileY(v->dest_tile) * TILE_SIZE + TILE_SIZE / 2;
525 if (Delta(v->x_pos, x) + Delta(v->y_pos, y) >= 8) {
526 v->direction = GetDirectionTowards(v, x, y);
527
528 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
529 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
530 return true;
531 }
532
533 if (!IsValidTile(v->dest_tile)) {
534 /* Make sure we don't land outside the map. */
535 delete v;
536 return false;
537 }
538
539 int z = GetSlopePixelZ(v->x_pos, v->y_pos);
540 if (z < v->z_pos) {
541 v->UpdatePosition(v->x_pos, v->y_pos, v->z_pos - 1);
542 return true;
543 }
544
545 v->state = 2;
546
547 for (Vehicle *target : Vehicle::Iterate()) {
548 if (target->IsGroundVehicle()) {
549 if (Delta(target->x_pos, v->x_pos) + Delta(target->y_pos, v->y_pos) <= 12 * (int)TILE_SIZE) {
550 target->breakdown_ctr = 5;
551 target->breakdown_delay = 0xF0;
552 }
553 }
554 }
555
556 Town *t = ClosestTownFromTile(v->dest_tile, UINT_MAX);
557 SetDParam(0, t->index);
558 AddTileNewsItem(STR_NEWS_DISASTER_BIG_UFO, NT_ACCIDENT, v->tile);
559
560 if (!Vehicle::CanAllocateItem(2)) {
561 delete v;
562 return false;
563 }
564 DisasterVehicle *u = new DisasterVehicle(-6 * (int)TILE_SIZE, v->y_pos, DIR_SW, ST_BIG_UFO_DESTROYER, v->index);
565 DisasterVehicle *w = new DisasterVehicle(-6 * (int)TILE_SIZE, v->y_pos, DIR_SW, ST_BIG_UFO_DESTROYER_SHADOW);
566 u->SetNext(w);
567 } else if (v->state == 0) {
568 int x = TileX(v->dest_tile) * TILE_SIZE;
569 int y = TileY(v->dest_tile) * TILE_SIZE;
570 if (Delta(x, v->x_pos) + Delta(y, v->y_pos) >= (int)TILE_SIZE) {
571 v->direction = GetDirectionTowards(v, x, y);
572 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
573 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
574 return true;
575 }
576
577 if (++v->age < 6) {
578 v->dest_tile = RandomTile();
579 return true;
580 }
581 v->state = 1;
582
583 const auto is_valid_target = [](const Train *t) {
584 return t->IsFrontEngine() // Only the engines
585 && Company::IsHumanID(t->owner) // Don't break AIs
586 && IsPlainRailTile(t->tile) // No tunnels
587 && (t->vehstatus & VS_CRASHED) == 0; // Not crashed
588 };
589
590 uint n = 0; // Total number of targetable trains.
591 for (const Train *t : Train::Iterate()) {
592 if (is_valid_target(t)) n++;
593 }
594
595 if (n == 0) {
596 /* If there are no targetable trains, destroy the UFO. */
597 delete v;
598 return false;
599 }
600
601 n = RandomRange(n); // Choose one of them.
602 for (const Train *t : Train::Iterate()) {
603 /* Find (n+1)-th train. */
604 if (is_valid_target(t) && (n-- == 0)) {
605 /* Target it. */
606 v->dest_tile = t->tile;
607 v->age = 0;
608 break;
609 }
610 }
611 }
612
613 return true;
614 }
615
620 static bool DisasterTick_Big_Ufo_Destroyer(DisasterVehicle *v)
621 {
622 v->tick_counter++;
623
624 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
625 v->UpdatePosition(gp.x, gp.y, GetAircraftFlightLevel(v));
626
627 if (gp.x > (int)(Map::SizeX() * TILE_SIZE + 9 * TILE_SIZE) - 1) {
628 delete v;
629 return false;
630 }
631
632 if (v->state == 0) {
633 Vehicle *u = Vehicle::Get(v->big_ufo_destroyer_target);
634 if (Delta(v->x_pos, u->x_pos) > (int)TILE_SIZE) return true;
635 v->state = 1;
636
637 CreateEffectVehicleRel(u, 0, 7, 8, EV_EXPLOSION_LARGE);
638 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, u);
639
640 delete u;
641
642 for (int i = 0; i != 80; i++) {
643 uint32_t r = Random();
644 CreateEffectVehicleAbove(
645 GB(r, 0, 6) + v->x_pos - 32,
646 GB(r, 5, 6) + v->y_pos - 32,
647 0,
648 EV_EXPLOSION_SMALL);
649 }
650
651 for (int dy = -3; dy < 3; dy++) {
652 for (int dx = -3; dx < 3; dx++) {
653 TileIndex tile = TileAddWrap(v->tile, dx, dy);
654 if (tile != INVALID_TILE) DisasterClearSquare(tile);
655 }
656 }
657 }
658
659 return true;
660 }
661
666 static bool DisasterTick_Submarine(DisasterVehicle *v)
667 {
668 v->tick_counter++;
669
670 if (++v->age > 8880) {
671 delete v;
672 return false;
673 }
674
675 if (!HasBit(v->tick_counter, 0)) return true;
676
677 TileIndex tile = v->tile + TileOffsByDiagDir(DirToDiagDir(v->direction));
678 if (IsValidTile(tile)) {
679 TrackBits trackbits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0));
680 if (trackbits == TRACK_BIT_ALL && !Chance16(1, 90)) {
681 GetNewVehiclePosResult gp = GetNewVehiclePos(v);
682 v->UpdatePosition(gp.x, gp.y, v->z_pos);
683 return true;
684 }
685 }
686
687 v->direction = ChangeDir(v->direction, GB(Random(), 0, 1) ? DIRDIFF_90RIGHT : DIRDIFF_90LEFT);
688
689 return true;
690 }
691
692
693 static bool DisasterTick_NULL(DisasterVehicle *)
694 {
695 return true;
696 }
697
698 typedef bool DisasterVehicleTickProc(DisasterVehicle *v);
699
700 static DisasterVehicleTickProc * const _disastervehicle_tick_procs[] = {
701 DisasterTick_Zeppeliner, DisasterTick_NULL,
702 DisasterTick_Ufo, DisasterTick_NULL,
703 DisasterTick_Airplane, DisasterTick_NULL,
704 DisasterTick_Helicopter, DisasterTick_NULL, DisasterTick_Helicopter_Rotors,
705 DisasterTick_Big_Ufo, DisasterTick_NULL, DisasterTick_Big_Ufo_Destroyer,
706 DisasterTick_NULL,
707 DisasterTick_Submarine,
708 DisasterTick_Submarine,
709 };
710
711
712 bool DisasterVehicle::Tick()
713 {
714 return _disastervehicle_tick_procs[this->subtype](this);
715 }
716
717 typedef void DisasterInitProc();
718
719
724 static void Disaster_Zeppeliner_Init()
725 {
726 if (!Vehicle::CanAllocateItem(2)) return;
727
728 /* Pick a random place, unless we find a small airport */
729 int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;
730
731 for (const Station *st : Station::Iterate()) {
732 if (st->airport.tile != INVALID_TILE && (st->airport.type == AT_SMALL || st->airport.type == AT_LARGE)) {
733 x = (TileX(st->airport.tile) + 2) * TILE_SIZE;
734 break;
735 }
736 }
737
738 DisasterVehicle *v = new DisasterVehicle(x, 0, DIR_SE, ST_ZEPPELINER);
739 /* Allocate shadow */
740 DisasterVehicle *u = new DisasterVehicle(x, 0, DIR_SE, ST_ZEPPELINER_SHADOW);
741 v->SetNext(u);
742 }
743
744
749 static void Disaster_Small_Ufo_Init()
750 {
751 if (!Vehicle::CanAllocateItem(2)) return;
752
753 int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;
754 DisasterVehicle *v = new DisasterVehicle(x, 0, DIR_SE, ST_SMALL_UFO);
755 v->dest_tile = TileXY(Map::SizeX() / 2, Map::SizeY() / 2);
756
757 /* Allocate shadow */
758 DisasterVehicle *u = new DisasterVehicle(x, 0, DIR_SE, ST_SMALL_UFO_SHADOW);
759 v->SetNext(u);
760 }
761
762
763 /* Combat airplane which destroys an oil refinery */
764 static void Disaster_Airplane_Init()
765 {
766 if (!Vehicle::CanAllocateItem(2)) return;
767
768 Industry *found = nullptr;
769
770 for (Industry *i : Industry::Iterate()) {
771 if ((GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_AIRPLANE_ATTACKS) &&
772 (found == nullptr || Chance16(1, 2))) {
773 found = i;
774 }
775 }
776
777 if (found == nullptr) return;
778
779 /* Start from the bottom (south side) of the map */
780 int x = (Map::SizeX() + 9) * TILE_SIZE - 1;
781 int y = TileY(found->location.tile) * TILE_SIZE + 37;
782
783 DisasterVehicle *v = new DisasterVehicle(x, y, DIR_NE, ST_AIRPLANE);
784 DisasterVehicle *u = new DisasterVehicle(x, y, DIR_NE, ST_AIRPLANE_SHADOW);
785 v->SetNext(u);
786 }
787
788
790 static void Disaster_Helicopter_Init()
791 {
792 if (!Vehicle::CanAllocateItem(3)) return;
793
794 Industry *found = nullptr;
795
796 for (Industry *i : Industry::Iterate()) {
797 if ((GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_CHOPPER_ATTACKS) &&
798 (found == nullptr || Chance16(1, 2))) {
799 found = i;
800 }
801 }
802
803 if (found == nullptr) return;
804
805 int x = -16 * (int)TILE_SIZE;
806 int y = TileY(found->location.tile) * TILE_SIZE + 37;
807
808 DisasterVehicle *v = new DisasterVehicle(x, y, DIR_SW, ST_HELICOPTER);
809 DisasterVehicle *u = new DisasterVehicle(x, y, DIR_SW, ST_HELICOPTER_SHADOW);
810 v->SetNext(u);
811
812 DisasterVehicle *w = new DisasterVehicle(x, y, DIR_SW, ST_HELICOPTER_ROTORS);
813 u->SetNext(w);
814 }
815
816
817 /* Big Ufo which lands on a piece of rail and will consequently be shot
818 * down by a combat airplane, destroying the surroundings */
819 static void Disaster_Big_Ufo_Init()
820 {
821 if (!Vehicle::CanAllocateItem(2)) return;
822
823 int x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;
824 int y = Map::MaxX() * TILE_SIZE - 1;
825
826 DisasterVehicle *v = new DisasterVehicle(x, y, DIR_NW, ST_BIG_UFO);
827 v->dest_tile = TileXY(Map::SizeX() / 2, Map::SizeY() / 2);
828
829 /* Allocate shadow */
830 DisasterVehicle *u = new DisasterVehicle(x, y, DIR_NW, ST_BIG_UFO_SHADOW);
831 v->SetNext(u);
832 }
833
834
835 static void Disaster_Submarine_Init(DisasterSubType subtype)
836 {
837 if (!Vehicle::CanAllocateItem()) return;
838
839 int y;
840 Direction dir;
841 uint32_t r = Random();
842 int x = TileX(r) * TILE_SIZE + TILE_SIZE / 2;
843
844 if (HasBit(r, 31)) {
845 y = Map::MaxY() * TILE_SIZE - TILE_SIZE / 2 - 1;
846 dir = DIR_NW;
847 } else {
848 y = TILE_SIZE / 2;
849 if (_settings_game.construction.freeform_edges) y += TILE_SIZE;
850 dir = DIR_SE;
851 }
852 if (!IsWaterTile(TileVirtXY(x, y))) return;
853
854 new DisasterVehicle(x, y, dir, subtype);
855 }
856
857 /* Curious submarine #1, just floats around */
858 static void Disaster_Small_Submarine_Init()
859 {
860 Disaster_Submarine_Init(ST_SMALL_SUBMARINE);
861 }
862
863
864 /* Curious submarine #2, just floats around */
865 static void Disaster_Big_Submarine_Init()
866 {
867 Disaster_Submarine_Init(ST_BIG_SUBMARINE);
868 }
869
870
875 static void Disaster_CoalMine_Init()
876 {
877 int index = GB(Random(), 0, 4);
878 uint m;
879
880 for (m = 0; m < 15; m++) {
881 for (const Industry *i : Industry::Iterate()) {
882 if ((GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_CAN_SUBSIDENCE) && --index < 0) {
883 SetDParam(0, i->town->index);
884 AddTileNewsItem(STR_NEWS_DISASTER_COAL_MINE_SUBSIDENCE, NT_ACCIDENT, i->location.tile + TileDiffXY(1, 1)); // keep the news, even when the mine closes
885
886 {
887 TileIndex tile = i->location.tile;
888 TileIndexDiff step = TileOffsByDiagDir((DiagDirection)GB(Random(), 0, 2));
889
890 for (uint n = 0; n < 30; n++) {
891 DisasterClearSquare(tile);
892 tile += step;
893 if (!IsValidTile(tile)) break;
894 }
895 }
896 return;
897 }
898 }
899 }
900 }
901
902 struct Disaster {
903 DisasterInitProc *init_proc;
904 TimerGameCalendar::Year min_year;
905 TimerGameCalendar::Year max_year;
906 };
907
908 static const Disaster _disasters[] = {
909 {Disaster_Zeppeliner_Init, 1930, 1955}, // zeppeliner
910 {Disaster_Small_Ufo_Init, 1940, 1970}, // ufo (small)
911 {Disaster_Airplane_Init, 1960, 1990}, // airplane
912 {Disaster_Helicopter_Init, 1970, 2000}, // helicopter
913 {Disaster_Big_Ufo_Init, 2000, 2100}, // ufo (big)
914 {Disaster_Small_Submarine_Init, 1940, 1965}, // submarine (small)
915 {Disaster_Big_Submarine_Init, 1975, 2010}, // submarine (big)
916 {Disaster_CoalMine_Init, 1950, 1985}, // coalmine
917 };
918
919 static void DoDisaster()
920 {
921 byte buf[lengthof(_disasters)];
922
923 byte j = 0;
924 for (size_t i = 0; i != lengthof(_disasters); i++) {
925 if (TimerGameCalendar::year >= _disasters[i].min_year && TimerGameCalendar::year < _disasters[i].max_year) buf[j++] = (byte)i;
926 }
927
928 if (j == 0) return;
929
930 _disasters[buf[RandomRange(j)]].init_proc();
931 }
932
933
934 static void ResetDisasterDelay()
935 {
936 _disaster_delay = GB(Random(), 0, 9) + 730;
937 }
938
939 static IntervalTimer<TimerGameEconomy> _economy_disaster_daily({TimerGameEconomy::DAY, TimerGameEconomy::Priority::DISASTER}, [](auto)
940 {
941 if (--_disaster_delay != 0) return;
942
943 ResetDisasterDelay();
944
945 if (_settings_game.difficulty.disasters != 0) DoDisaster();
946 });
947
948 void StartupDisasters()
949 {
950 ResetDisasterDelay();
951 }
952
958 void ReleaseDisastersTargetingIndustry(IndustryID i)
959 {
960 for (DisasterVehicle *v : DisasterVehicle::Iterate()) {
961 /* primary disaster vehicles that have chosen target */
962 if (v->subtype == ST_AIRPLANE || v->subtype == ST_HELICOPTER) {
963 /* if it has chosen target, and it is this industry (yes, dest_tile is IndustryID here), set order to "leaving map peacefully" */
964 if (v->state > 0 && v->dest_tile == (uint32_t)i) v->state = 3;
965 }
966 }
967 }
968
973 void ReleaseDisastersTargetingVehicle(VehicleID vehicle)
974 {
975 for (DisasterVehicle *v : DisasterVehicle::Iterate()) {
976 /* primary disaster vehicles that have chosen target */
977 if (v->subtype == ST_SMALL_UFO) {
978 if (v->state != 0 && v->dest_tile == vehicle) {
979 /* Revert to target-searching */
980 v->state = 0;
981 v->dest_tile = RandomTile();
982 GetAircraftFlightLevelBounds(v, &v->z_pos, nullptr);
983 v->age = 0;
984 }
985 }
986 }
987 }
988
989 void DisasterVehicle::UpdateDeltaXY()
990 {
991 this->x_offs = -1;
992 this->y_offs = -1;
993 this->x_extent = 2;
994 this->y_extent = 2;
995 this->z_extent = 5;
996 }
DisasterVehicle::image_override
SpriteID image_override
Override for the default disaster vehicle sprite.
Definition: disaster_vehicle.h:38
game.hpp
RoadVehicle
Buses, trucks and trams belong to this class.
Definition: roadveh.h:106
TileY
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:437
MP_CLEAR
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition: tile_type.h:48
Vehicle::IsFrontEngine
debug_inline bool IsFrontEngine() const
Check if the vehicle is a front engine.
Definition: vehicle_base.h:931
MP_HOUSE
@ MP_HOUSE
A house by a town.
Definition: tile_type.h:51
DIR_SW
@ DIR_SW
Southwest.
Definition: direction_type.h:31
DisasterTick_Airplane
static bool DisasterTick_Airplane(DisasterVehicle *v)
Airplane handling.
Definition: disaster_vehicle.cpp:487
sound_func.h
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
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
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:666
Pool::PoolItem<&_industry_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:335
Direction
Direction
Defines the 8 directions on the map.
Definition: direction_type.h:24
MutableSpriteCache::sprite_seq
VehicleSpriteSeq sprite_seq
Vehicle appearance.
Definition: vehicle_base.h:196
train.h
UpdateSignalsInBuffer
static SigSegState UpdateSignalsInBuffer(Owner owner)
Updates blocks in _globset buffer.
Definition: signal.cpp:468
command_func.h
DIR_SE
@ DIR_SE
Southeast.
Definition: direction_type.h:29
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:3744
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
Map::MaxX
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:297
company_base.h
DisasterVehicle::Tick
bool Tick() override
Calls the tick handler of the vehicle.
Definition: disaster_vehicle.cpp:712
SpecializedVehicle< DisasterVehicle, VEH_DISASTER >::Next
DisasterVehicle * Next() const
Get next vehicle in the chain.
Definition: vehicle_base.h:1116
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
Vehicle::y_extent
byte y_extent
y-extent of vehicle bounding box
Definition: vehicle_base.h:312
Station
Station data structure.
Definition: station_base.h:442
StringID
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
VehicleSpriteSeq::Set
void Set(SpriteID sprite)
Assign a single sprite to the sequence.
Definition: vehicle_base.h:164
DIR_NW
@ DIR_NW
Northwest.
Definition: direction_type.h:33
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:348
INDUSTRYBEH_CAN_SUBSIDENCE
@ INDUSTRYBEH_CAN_SUBSIDENCE
can cause a subsidence (coal mine, shaft that collapses)
Definition: industrytype.h:74
IntervalTimer
An interval timer will fire every interval, and will continue to fire until it is deleted.
Definition: timer.h:76
GB
constexpr static debug_inline 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
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:234
Vehicle::SetNext
void SetNext(Vehicle *next)
Set the next vehicle of this vehicle.
Definition: vehicle.cpp:2862
PalSpriteID::sprite
SpriteID sprite
The 'real' sprite.
Definition: gfx_type.h:23
ST_SMALL_UFO_SHADOW
@ ST_SMALL_UFO_SHADOW
Shadow of small UFO.
Definition: disaster_vehicle.h:20
GameSettings::difficulty
DifficultySettings difficulty
settings related to the difficulty
Definition: settings_type.h:618
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:95
SND_12_EXPLOSION
@ SND_12_EXPLOSION
16 == 0x10 Destruction, crashes, disasters, ...
Definition: sound_type.h:55
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition: tile_type.h:49
aircraft.h
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:15
DisasterVehicle::UpdatePosition
void UpdatePosition(int x, int y, int z)
Update the position of the vehicle.
Definition: disaster_vehicle.cpp:183
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:54
MP_INDUSTRY
@ MP_INDUSTRY
Part of an industry.
Definition: tile_type.h:56
TRANSPORT_WATER
@ TRANSPORT_WATER
Transport over water.
Definition: transport_type.h:29
town.h
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
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:620
IsWaterTile
bool IsWaterTile(Tile t)
Is it a water tile with plain water?
Definition: water_map.h:193
EV_EXPLOSION_SMALL
@ EV_EXPLOSION_SMALL
Various explosions.
Definition: effectvehicle_func.h:24
ChangeDir
Direction ChangeDir(Direction d, DirDiff delta)
Change a direction by a given difference.
Definition: direction_func.h:104
DisasterSubType
DisasterSubType
Different sub types of disaster vehicles.
Definition: disaster_vehicle.h:16
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:240
Industry
Defines the internal data of a functional industry.
Definition: industry.h:68
Chance16
bool Chance16(const uint a, const uint b)
Flips a coin with given probability.
Definition: random_func.hpp:131
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:304
EV_EXPLOSION_LARGE
@ EV_EXPLOSION_LARGE
Various explosions.
Definition: effectvehicle_func.h:22
DC_EXEC
@ DC_EXEC
execute the given command
Definition: command_type.h:371
GetSlopePixelZ
int GetSlopePixelZ(int x, int y, bool ground_vehicle)
Return world Z coordinate of a given point of a tile.
Definition: landscape.cpp:299
ST_BIG_SUBMARINE
@ ST_BIG_SUBMARINE
Big submarine, pops up in the oceans but doesn't do anything.
Definition: disaster_vehicle.h:31
AT_LARGE
@ AT_LARGE
Large airport.
Definition: airport.h:30
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:724
EnsureNoVehicleOnGround
CommandCost EnsureNoVehicleOnGround(TileIndex tile)
Ensure there is no vehicle at the ground at the given position.
Definition: vehicle.cpp:546
SETBITS
#define SETBITS(x, y)
Sets several bits in a variable.
Definition: bitmath_func.hpp:136
RandomRange
static uint32_t RandomRange(uint32_t limit)
Pick a random number between 0 and limit - 1, inclusive.
Definition: random_func.hpp:81
Vehicle::x_pos
int32_t x_pos
x coordinate.
Definition: vehicle_base.h:299
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:556
effectvehicle_func.h
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:310
ai.hpp
GetTileType
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition: tile_map.h:96
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:875
Disaster
Definition: disaster_vehicle.cpp:902
DifficultySettings::disasters
bool disasters
are disasters enabled
Definition: settings_type.h:115
INDUSTRYBEH_AIRPLANE_ATTACKS
@ INDUSTRYBEH_AIRPLANE_ATTACKS
can be exploded by a military airplane (oil refinery)
Definition: industrytype.h:72
Vehicle::breakdown_ctr
byte breakdown_ctr
Counter for managing breakdown events.
Definition: vehicle_base.h:294
VS_HIDDEN
@ VS_HIDDEN
Vehicle is not visible.
Definition: vehicle_base.h:33
landscape_cmd.h
IsRailDepot
static debug_inline bool IsRailDepot(Tile t)
Is this rail tile a rail depot?
Definition: rail_map.h:95
ST_AIRPLANE
@ ST_AIRPLANE
Airplane destroying an oil refinery.
Definition: disaster_vehicle.h:21
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:989
Vehicle::dest_tile
TileIndex dest_tile
Heading for this tile.
Definition: vehicle_base.h:267
AI::NewEvent
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition: ai_core.cpp:235
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:116
Industry::location
TileArea location
Location of the industry.
Definition: industry.h:96
ST_ZEPPELINER
@ ST_ZEPPELINER
Zeppelin, crashes at airports.
Definition: disaster_vehicle.h:17
ClientSettings::sound
SoundSettings sound
sound effect settings
Definition: settings_type.h:639
DIRDIFF_90LEFT
@ DIRDIFF_90LEFT
Angle of 90 degrees left.
Definition: direction_type.h:63
Industry::type
IndustryType type
type of industry.
Definition: industry.h:104
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:260
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:40
ST_BIG_UFO_SHADOW
@ ST_BIG_UFO_SHADOW
Shadow of the big UFO.
Definition: disaster_vehicle.h:27
Disaster_Helicopter_Init
static void Disaster_Helicopter_Init()
Combat helicopter that destroys a factory.
Definition: disaster_vehicle.cpp:790
SpecializedVehicle
Class defining several overloaded accessors so we don't have to cast vehicle types that often.
Definition: vehicle_base.h:1081
Station::airport
Airport airport
Tile area the airport covers.
Definition: station_base.h:456
DIR_NE
@ DIR_NE
Northeast.
Definition: direction_type.h:27
TileDiffXY
TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition: map_func.h:401
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:55
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:749
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:729
SpecializedVehicle< RoadVehicle, Type >::Get
static RoadVehicle * Get(size_t index)
Gets vehicle with given index.
Definition: vehicle_base.h:1182
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:147
RoadVehicle::Crash
uint Crash(bool flooded=false) override
Crash the (whole) vehicle chain.
Definition: roadveh_cmd.cpp:535
Disaster::min_year
TimerGameCalendar::Year min_year
The first year this disaster will occur.
Definition: disaster_vehicle.cpp:904
GetIndustryIndex
IndustryID GetIndustryIndex(Tile t)
Get the industry ID of the given tile.
Definition: industry_map.h:63
industry.h
safeguards.h
timer.h
EV_CRASH_SMOKE
@ EV_CRASH_SMOKE
Smoke of disasters.
Definition: effectvehicle_func.h:21
Train
'Train' is either a loco or a wagon.
Definition: train.h:89
ConstructionSettings::freeform_edges
bool freeform_edges
allow terraforming the tiles at the map edges
Definition: settings_type.h:383
DirToDiagDir
DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
Definition: direction_func.h:166
RandomTile
#define RandomTile()
Get a valid random tile.
Definition: map_func.h:657
GetTileOwner
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition: tile_map.h:178
VehicleID
uint32_t VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
SoundSettings::disaster
bool disaster
Play disaster and accident sounds.
Definition: settings_type.h:242
TileIndexDiff
int32_t TileIndexDiff
An offset value between two tiles.
Definition: map_func.h:376
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition: direction_type.h:73
TRACK_BIT_ALL
@ TRACK_BIT_ALL
All possible tracks.
Definition: track_type.h:50
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:638
TrackStatusToTrackBits
TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition: track_func.h:363
stdafx.h
Company::IsHumanID
static bool IsHumanID(size_t index)
Is this company a company not controlled by a NoAI program?
Definition: company_base.h:163
ResetIndustryConstructionStage
void ResetIndustryConstructionStage(Tile tile)
Reset the construction stage counter of the industry, as well as the completion bit.
Definition: industry_map.h:187
Vehicle::sprite_cache
MutableSpriteCache sprite_cache
Cache of sprites and values related to recalculating them, see MutableSpriteCache.
Definition: vehicle_base.h:363
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:958
SpriteID
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
viewport_func.h
DisasterVehicle
Disasters, like submarines, skyrangers and their shadows, belong to this class.
Definition: disaster_vehicle.h:37
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
Vehicle::z_pos
int32_t z_pos
z coordinate.
Definition: vehicle_base.h:301
IsValidTile
bool IsValidTile(Tile tile)
Checks if a tile is valid.
Definition: tile_map.h:161
Vehicle::direction
Direction direction
facing
Definition: vehicle_base.h:302
TileOffsByDiagDir
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition: map_func.h:563
MP_TREES
@ MP_TREES
Tile got trees.
Definition: tile_type.h:52
Map::SizeX
static debug_inline uint SizeX()
Get the size of the map along the X.
Definition: map_func.h:270
Industry::town
Town * town
Nearest town.
Definition: industry.h:97
ST_HELICOPTER_SHADOW
@ ST_HELICOPTER_SHADOW
Shadow of helicopter.
Definition: disaster_vehicle.h:24
ST_SMALL_SUBMARINE
@ ST_SMALL_SUBMARINE
Small submarine, pops up in the oceans but doesn't do anything.
Definition: disaster_vehicle.h:30
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:518
Vehicle::x_extent
byte x_extent
x-extent of vehicle bounding box
Definition: vehicle_base.h:311
ST_BIG_UFO_DESTROYER_SHADOW
@ ST_BIG_UFO_DESTROYER_SHADOW
Shadow of the aircraft.
Definition: disaster_vehicle.h:29
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:50
vehicle_func.h
NT_ACCIDENT
@ NT_ACCIDENT
An accident or disaster has occurred.
Definition: news_type.h:26
station_base.h
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:384
Map::MaxY
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition: map_func.h:306
strings_func.h
DisasterTick_Helicopter_Rotors
static bool DisasterTick_Helicopter_Rotors(DisasterVehicle *v)
Helicopter rotor blades; keep these spinning.
Definition: disaster_vehicle.cpp:499
ST_AIRPLANE_SHADOW
@ ST_AIRPLANE_SHADOW
Shadow of airplane.
Definition: disaster_vehicle.h:22
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
Vehicle::tick_counter
byte tick_counter
Increased by one for each tick.
Definition: vehicle_base.h:345
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:112
Vehicle::x_offs
int8_t x_offs
x offset for vehicle sprite
Definition: vehicle_base.h:316
Vehicle::z_extent
byte z_extent
z-extent of vehicle bounding box
Definition: vehicle_base.h:313
Map::Size
static debug_inline uint Size()
Get the size of the map.
Definition: map_func.h:288
ST_HELICOPTER
@ ST_HELICOPTER
Helicopter destroying a factory.
Definition: disaster_vehicle.h:23
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
GetStationIndex
StationID GetStationIndex(Tile t)
Get StationID from a tile.
Definition: station_map.h:28
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:19
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:2051
ReleaseDisastersTargetingVehicle
void ReleaseDisastersTargetingVehicle(VehicleID vehicle)
Notify disasters that we are about to delete a vehicle.
Definition: disaster_vehicle.cpp:973
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition: company_type.h:25
GetNewVehiclePosResult
Position information of a vehicle after it moved.
Definition: vehicle_func.h:75
Vehicle::age
TimerGameCalendar::Date age
Age in days.
Definition: vehicle_base.h:288
SpecializedStation< Station, false >::GetByTile
static Station * GetByTile(TileIndex tile)
Get the station belonging to a specific tile.
Definition: base_station_base.h:278
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:305
DIRDIFF_90RIGHT
@ DIRDIFF_90RIGHT
Angle of 90 degrees right.
Definition: direction_type.h:61
CreateEffectVehicleAbove
EffectVehicle * CreateEffectVehicleAbove(int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular location.
Definition: effectvehicle.cpp:622
company_func.h
SpecializedVehicle< RoadVehicle, Type >::Iterate
static Pool::IterateWrapper< RoadVehicle > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
Definition: vehicle_base.h:1270
Vehicle::y_pos
int32_t y_pos
y coordinate.
Definition: vehicle_base.h:300
Vehicle::breakdown_delay
byte breakdown_delay
Counter for managing breakdown length.
Definition: vehicle_base.h:295
TrackBits
TrackBits
Allow incrementing of Track variables.
Definition: track_type.h:35
Vehicle::subtype
byte subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
Definition: vehicle_base.h:358
CommandHelper
Definition: command_func.h:93
VS_UNCLICKABLE
@ VS_UNCLICKABLE
Vehicle is not clickable by the user (shadow vehicles).
Definition: vehicle_base.h:35
IndustrySpec::behaviour
IndustryBehaviour behaviour
How this industry will behave, and how others entities can use it.
Definition: industrytype.h:125
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:300
Town
Town data structure.
Definition: town.h:50
Delta
constexpr T Delta(const T a, const T b)
Returns the (absolute) difference between two (scalar) variables.
Definition: math_func.hpp:234
ST_HELICOPTER_ROTORS
@ ST_HELICOPTER_ROTORS
Rotors of helicopter.
Definition: disaster_vehicle.h:25
TileXY
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition: map_func.h:385
random_func.hpp
TileVirtXY
static debug_inline TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition: map_func.h:416
INDUSTRYBEH_CHOPPER_ATTACKS
@ INDUSTRYBEH_CHOPPER_ATTACKS
can be exploded by a military helicopter (factory)
Definition: industrytype.h:73
RoadVehicle::crashed_ctr
uint16_t crashed_ctr
Animation counter when the vehicle has crashed.
Definition: roadveh.h:113
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition: settings_type.h:620
IsAirportTile
bool IsAirportTile(Tile t)
Is this tile a station tile and an airport tile?
Definition: station_map.h:167
GetIndustrySpec
const IndustrySpec * GetIndustrySpec(IndustryType thistype)
Accessor for array _industry_specs.
Definition: industry_cmd.cpp:123
ST_BIG_UFO_DESTROYER
@ ST_BIG_UFO_DESTROYER
Aircraft the will bomb the big UFO.
Definition: disaster_vehicle.h:28
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
IndustryBehaviour
IndustryBehaviour
Various industry behaviours mostly to represent original TTD specialities.
Definition: industrytype.h:59
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:51
ST_BIG_UFO
@ ST_BIG_UFO
Big UFO, finds a piece of railroad to "park" on.
Definition: disaster_vehicle.h:26
Clamp
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:79
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:425
Vehicle::UpdatePositionAndViewport
void UpdatePositionAndViewport()
Update the position of the vehicle, and update the viewport.
Definition: vehicle.cpp:1739
TileX
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:427
Vehicle::UpdatePosition
void UpdatePosition()
Update the position of the vehicle.
Definition: vehicle.cpp:1668
GetNewVehiclePosResult::y
int y
x and y position of the vehicle after moving
Definition: vehicle_func.h:76
ST_ZEPPELINER_SHADOW
@ ST_ZEPPELINER_SHADOW
Shadow of the zeppelin.
Definition: disaster_vehicle.h:18
disaster_vehicle.h
_disaster_delay
uint16_t _disaster_delay
Delay counter for considering the next disaster.
Definition: disaster_vehicle.cpp:57
AT_SMALL
@ AT_SMALL
Small airport.
Definition: airport.h:29
Company
Definition: company_base.h:116
DisasterVehicle::state
uint16_t state
Action stage of the disaster vehicle.
Definition: disaster_vehicle.h:41
DisasterVehicle::DisasterVehicle
DisasterVehicle()
For use by saveload.
Definition: disaster_vehicle.h:44
DisasterTick_Helicopter
static bool DisasterTick_Helicopter(DisasterVehicle *v)
Helicopter handling.
Definition: disaster_vehicle.cpp:493
OWNER_WATER
@ OWNER_WATER
The tile/execution is done by "water".
Definition: company_type.h:26
CLRBITS
#define CLRBITS(x, y)
Clears several bits in a variable.
Definition: bitmath_func.hpp:166
Disaster::init_proc
DisasterInitProc * init_proc
The init function for this disaster.
Definition: disaster_vehicle.cpp:903
VS_SHADOW
@ VS_SHADOW
Vehicle is a shadow vehicle.
Definition: vehicle_base.h:38
ST_SMALL_UFO
@ ST_SMALL_UFO
Small UFO, tries to find a road vehicle to destroy.
Definition: disaster_vehicle.h:19
timer_game_economy.h
Vehicle::y_offs
int8_t y_offs
y offset for vehicle sprite
Definition: vehicle_base.h:317
Map::SizeY
static uint SizeY()
Get the size of the map along the Y.
Definition: map_func.h:279
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:1759
Disaster::max_year
TimerGameCalendar::Year max_year
The last year this disaster will occur.
Definition: disaster_vehicle.cpp:905
news_func.h
roadveh.h
ROTOR_Z_OFFSET
static const int ROTOR_Z_OFFSET
Z Offset between helicopter- and rotorsprite.
Definition: aircraft.h:50
TimerGameCalendar::year
static Year year
Current year, starting at 0.
Definition: timer_game_calendar.h:32
Industry::TileBelongsToIndustry
bool TileBelongsToIndustry(TileIndex tile) const
Check if a given tile belongs to this industry.
Definition: industry.h:137
backup_type.hpp
HasBit
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103