OpenTTD Source  1.11.0-beta2
ship_cmd.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 
10 #include "stdafx.h"
11 #include "ship.h"
12 #include "landscape.h"
13 #include "timetable.h"
14 #include "news_func.h"
15 #include "company_func.h"
17 #include "depot_base.h"
18 #include "station_base.h"
19 #include "newgrf_engine.h"
20 #include "pathfinder/yapf/yapf.h"
21 #include "newgrf_sound.h"
22 #include "spritecache.h"
23 #include "strings_func.h"
24 #include "window_func.h"
25 #include "date_func.h"
26 #include "vehicle_func.h"
27 #include "sound_func.h"
28 #include "ai/ai.hpp"
29 #include "game/game.hpp"
30 #include "engine_base.h"
31 #include "company_base.h"
32 #include "tunnelbridge_map.h"
33 #include "zoom_func.h"
34 #include "framerate_type.h"
35 #include "industry.h"
36 #include "industry_map.h"
37 
38 #include "table/strings.h"
39 
40 #include "safeguards.h"
41 
48 {
49  if (HasTileWaterClass(tile)) return GetWaterClass(tile);
50  if (IsTileType(tile, MP_TUNNELBRIDGE)) {
52  return WATER_CLASS_CANAL;
53  }
54  if (IsTileType(tile, MP_RAILWAY)) {
55  assert(GetRailGroundType(tile) == RAIL_GROUND_WATER);
56  return WATER_CLASS_SEA;
57  }
58  NOT_REACHED();
59 }
60 
61 static const uint16 _ship_sprites[] = {0x0E5D, 0x0E55, 0x0E65, 0x0E6D};
62 
63 template <>
64 bool IsValidImageIndex<VEH_SHIP>(uint8 image_index)
65 {
66  return image_index < lengthof(_ship_sprites);
67 }
68 
69 static inline TrackBits GetTileShipTrackStatus(TileIndex tile)
70 {
72 }
73 
74 static void GetShipIcon(EngineID engine, EngineImageType image_type, VehicleSpriteSeq *result)
75 {
76  const Engine *e = Engine::Get(engine);
77  uint8 spritenum = e->u.ship.image_index;
78 
79  if (is_custom_sprite(spritenum)) {
80  GetCustomVehicleIcon(engine, DIR_W, image_type, result);
81  if (result->IsValid()) return;
82 
83  spritenum = e->original_image_index;
84  }
85 
86  assert(IsValidImageIndex<VEH_SHIP>(spritenum));
87  result->Set(DIR_W + _ship_sprites[spritenum]);
88 }
89 
90 void DrawShipEngine(int left, int right, int preferred_x, int y, EngineID engine, PaletteID pal, EngineImageType image_type)
91 {
92  VehicleSpriteSeq seq;
93  GetShipIcon(engine, image_type, &seq);
94 
95  Rect rect;
96  seq.GetBounds(&rect);
97  preferred_x = Clamp(preferred_x,
98  left - UnScaleGUI(rect.left),
99  right - UnScaleGUI(rect.right));
100 
101  seq.Draw(preferred_x, y, pal, pal == PALETTE_CRASH);
102 }
103 
113 void GetShipSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
114 {
115  VehicleSpriteSeq seq;
116  GetShipIcon(engine, image_type, &seq);
117 
118  Rect rect;
119  seq.GetBounds(&rect);
120 
121  width = UnScaleGUI(rect.right - rect.left + 1);
122  height = UnScaleGUI(rect.bottom - rect.top + 1);
123  xoffs = UnScaleGUI(rect.left);
124  yoffs = UnScaleGUI(rect.top);
125 }
126 
127 void Ship::GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
128 {
129  uint8 spritenum = this->spritenum;
130 
131  if (image_type == EIT_ON_MAP) direction = this->rotation;
132 
133  if (is_custom_sprite(spritenum)) {
134  GetCustomVehicleSprite(this, direction, image_type, result);
135  if (result->IsValid()) return;
136 
138  }
139 
140  assert(IsValidImageIndex<VEH_SHIP>(spritenum));
141  result->Set(_ship_sprites[spritenum] + direction);
142 }
143 
144 static const Depot *FindClosestShipDepot(const Vehicle *v, uint max_distance)
145 {
146  /* Find the closest depot */
147  const Depot *best_depot = nullptr;
148  /* If we don't have a maximum distance, i.e. distance = 0,
149  * we want to find any depot so the best distance of no
150  * depot must be more than any correct distance. On the
151  * other hand if we have set a maximum distance, any depot
152  * further away than max_distance can safely be ignored. */
153  uint best_dist = max_distance == 0 ? UINT_MAX : max_distance + 1;
154 
155  for (const Depot *depot : Depot::Iterate()) {
156  TileIndex tile = depot->xy;
157  if (IsShipDepotTile(tile) && IsTileOwner(tile, v->owner)) {
158  uint dist = DistanceManhattan(tile, v->tile);
159  if (dist < best_dist) {
160  best_dist = dist;
161  best_depot = depot;
162  }
163  }
164  }
165 
166  return best_depot;
167 }
168 
169 static void CheckIfShipNeedsService(Vehicle *v)
170 {
171  if (Company::Get(v->owner)->settings.vehicle.servint_ships == 0 || !v->NeedsAutomaticServicing()) return;
172  if (v->IsChainInDepot()) {
174  return;
175  }
176 
177  uint max_distance;
181  default: NOT_REACHED();
182  }
183 
184  const Depot *depot = FindClosestShipDepot(v, max_distance);
185 
186  if (depot == nullptr) {
187  if (v->current_order.IsType(OT_GOTO_DEPOT)) {
190  }
191  return;
192  }
193 
195  v->SetDestTile(depot->xy);
197 }
198 
203 {
204  const ShipVehicleInfo *svi = ShipVehInfo(this->engine_type);
205 
206  /* Get speed fraction for the current water type. Aqueducts are always canals. */
207  bool is_ocean = GetEffectiveWaterClass(this->tile) == WATER_CLASS_SEA;
208  uint raw_speed = GetVehicleProperty(this, PROP_SHIP_SPEED, svi->max_speed);
209  this->vcache.cached_max_speed = svi->ApplyWaterClassSpeedFrac(raw_speed, is_ocean);
210 
211  /* Update cargo aging period. */
212  this->vcache.cached_cargo_age_period = GetVehicleProperty(this, PROP_SHIP_CARGO_AGE_PERIOD, EngInfo(this->engine_type)->cargo_age_period);
213 
214  this->UpdateVisualEffect();
215 }
216 
218 {
219  const Engine *e = this->GetEngine();
220  uint cost_factor = GetVehicleProperty(this, PROP_SHIP_RUNNING_COST_FACTOR, e->u.ship.running_cost);
221  return GetPrice(PR_RUNNING_SHIP, cost_factor, e->GetGRF());
222 }
223 
225 {
226  if ((++this->day_counter & 7) == 0) {
227  DecreaseVehicleValue(this);
228  }
229 
230  CheckVehicleBreakdown(this);
231  AgeVehicle(this);
232  CheckIfShipNeedsService(this);
233 
234  CheckOrders(this);
235 
236  if (this->running_ticks == 0) return;
237 
239 
240  this->profit_this_year -= cost.GetCost();
241  this->running_ticks = 0;
242 
244 
246  /* we need this for the profit */
248 }
249 
251 {
252  if (this->vehstatus & VS_CRASHED) return INVALID_TRACKDIR;
253 
254  if (this->IsInDepot()) {
255  /* We'll assume the ship is facing outwards */
256  return DiagDirToDiagTrackdir(GetShipDepotDirection(this->tile));
257  }
258 
259  if (this->state == TRACK_BIT_WORMHOLE) {
260  /* ship on aqueduct, so just use his direction and assume a diagonal track */
262  }
263 
265 }
266 
268 {
269  this->colourmap = PAL_NONE;
270  this->UpdateViewport(true, false);
271  this->UpdateCache();
272 }
273 
274 static void PlayShipSound(const Vehicle *v)
275 {
276  if (!PlayVehicleSound(v, VSE_START)) {
277  SndPlayVehicleFx(ShipVehInfo(v->engine_type)->sfx, v);
278  }
279 }
280 
282 {
283  PlayShipSound(this);
284 }
285 
287 {
288  if (station == this->last_station_visited) this->last_station_visited = INVALID_STATION;
289 
290  const Station *st = Station::Get(station);
291  if (CanVehicleUseStation(this, st)) {
292  return st->xy;
293  } else {
294  this->IncrementRealOrderIndex();
295  return 0;
296  }
297 }
298 
300 {
301  static const int8 _delta_xy_table[8][4] = {
302  /* y_extent, x_extent, y_offs, x_offs */
303  { 6, 6, -3, -3}, // N
304  { 6, 32, -3, -16}, // NE
305  { 6, 6, -3, -3}, // E
306  {32, 6, -16, -3}, // SE
307  { 6, 6, -3, -3}, // S
308  { 6, 32, -3, -16}, // SW
309  { 6, 6, -3, -3}, // W
310  {32, 6, -16, -3}, // NW
311  };
312 
313  const int8 *bb = _delta_xy_table[this->rotation];
314  this->x_offs = bb[3];
315  this->y_offs = bb[2];
316  this->x_extent = bb[1];
317  this->y_extent = bb[0];
318  this->z_extent = 6;
319 
320  if (this->direction != this->rotation) {
321  /* If we are rotating, then it is possible the ship was moved to its next position. In that
322  * case, because we are still showing the old direction, the ship will appear to glitch sideways
323  * slightly. We can work around this by applying an additional offset to make the ship appear
324  * where it was before it moved. */
325  this->x_offs -= this->x_pos - this->rotation_x_pos;
326  this->y_offs -= this->y_pos - this->rotation_y_pos;
327  }
328 }
329 
333 static Vehicle *EnsureNoMovingShipProc(Vehicle *v, void *data)
334 {
335  return v->type == VEH_SHIP && (v->vehstatus & (VS_HIDDEN | VS_STOPPED)) == 0 ? v : nullptr;
336 }
337 
338 static bool CheckShipLeaveDepot(Ship *v)
339 {
340  if (!v->IsChainInDepot()) return false;
341 
342  /* We are leaving a depot, but have to go to the exact same one; re-enter */
343  if (v->current_order.IsType(OT_GOTO_DEPOT) &&
346  return true;
347  }
348 
349  /* Don't leave depot if no destination set */
350  if (v->dest_tile == 0) return true;
351 
352  /* Don't leave depot if another vehicle is already entering/leaving */
353  /* This helps avoid CPU load if many ships are set to start at the same time */
354  if (HasVehicleOnPos(v->tile, nullptr, &EnsureNoMovingShipProc)) return true;
355 
356  TileIndex tile = v->tile;
357  Axis axis = GetShipDepotAxis(tile);
358 
359  DiagDirection north_dir = ReverseDiagDir(AxisToDiagDir(axis));
360  TileIndex north_neighbour = TILE_ADD(tile, TileOffsByDiagDir(north_dir));
361  DiagDirection south_dir = AxisToDiagDir(axis);
362  TileIndex south_neighbour = TILE_ADD(tile, 2 * TileOffsByDiagDir(south_dir));
363 
364  TrackBits north_tracks = DiagdirReachesTracks(north_dir) & GetTileShipTrackStatus(north_neighbour);
365  TrackBits south_tracks = DiagdirReachesTracks(south_dir) & GetTileShipTrackStatus(south_neighbour);
366  if (north_tracks && south_tracks) {
367  /* Ask pathfinder for best direction */
368  bool reverse = false;
370  case VPF_NPF: reverse = NPFShipCheckReverse(v); break;
371  case VPF_YAPF: reverse = YapfShipCheckReverse(v); break;
372  default: NOT_REACHED();
373  }
374  if (reverse) north_tracks = TRACK_BIT_NONE;
375  }
376 
377  if (north_tracks) {
378  /* Leave towards north */
379  v->rotation = v->direction = DiagDirToDir(north_dir);
380  } else if (south_tracks) {
381  /* Leave towards south */
382  v->rotation = v->direction = DiagDirToDir(south_dir);
383  } else {
384  /* Both ways blocked */
385  return false;
386  }
387 
388  v->state = AxisToTrackBits(axis);
389  v->vehstatus &= ~VS_HIDDEN;
390 
391  v->cur_speed = 0;
392  v->UpdateViewport(true, true);
394 
395  PlayShipSound(v);
399 
400  return false;
401 }
402 
403 static bool ShipAccelerate(Vehicle *v)
404 {
405  uint spd;
406  byte t;
407 
408  spd = std::min<uint>(v->cur_speed + 1, v->vcache.cached_max_speed);
409  spd = std::min<uint>(spd, v->current_order.GetMaxSpeed() * 2);
410 
411  /* updates statusbar only if speed have changed to save CPU time */
412  if (spd != v->cur_speed) {
413  v->cur_speed = spd;
415  }
416 
417  /* Convert direction-independent speed into direction-dependent speed. (old movement method) */
418  spd = v->GetOldAdvanceSpeed(spd);
419 
420  if (spd == 0) return false;
421  if ((byte)++spd == 0) return true;
422 
423  v->progress = (t = v->progress) - (byte)spd;
424 
425  return (t < v->progress);
426 }
427 
433 static void ShipArrivesAt(const Vehicle *v, Station *st)
434 {
435  /* Check if station was ever visited before */
436  if (!(st->had_vehicle_of_type & HVOT_SHIP)) {
437  st->had_vehicle_of_type |= HVOT_SHIP;
438 
439  SetDParam(0, st->index);
441  STR_NEWS_FIRST_SHIP_ARRIVAL,
443  v->index,
444  st->index
445  );
446  AI::NewEvent(v->owner, new ScriptEventStationFirstVehicle(st->index, v->index));
447  Game::NewEvent(new ScriptEventStationFirstVehicle(st->index, v->index));
448  }
449 }
450 
451 
461 static Track ChooseShipTrack(Ship *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks)
462 {
463  assert(IsValidDiagDirection(enterdir));
464 
465  bool path_found = true;
466  Track track;
467 
468  if (v->dest_tile == 0) {
469  /* No destination, don't invoke pathfinder. */
470  track = TrackBitsToTrack(v->state);
471  if (!IsDiagonalTrack(track)) track = TrackToOppositeTrack(track);
472  if (!HasBit(tracks, track)) track = FindFirstTrack(tracks);
473  path_found = false;
474  } else {
475  /* Attempt to follow cached path. */
476  if (!v->path.empty()) {
477  track = TrackdirToTrack(v->path.front());
478 
479  if (HasBit(tracks, track)) {
480  v->path.pop_front();
481  /* HandlePathfindResult() is not called here because this is not a new pathfinder result. */
482  return track;
483  }
484 
485  /* Cached path is invalid so continue with pathfinder. */
486  v->path.clear();
487  }
488 
490  case VPF_NPF: track = NPFShipChooseTrack(v, path_found); break;
491  case VPF_YAPF: track = YapfShipChooseTrack(v, tile, enterdir, tracks, path_found, v->path); break;
492  default: NOT_REACHED();
493  }
494  }
495 
496  v->HandlePathfindingResult(path_found);
497  return track;
498 }
499 
507 {
508  TrackBits tracks = GetTileShipTrackStatus(tile) & DiagdirReachesTracks(dir);
509 
510  return tracks;
511 }
512 
513 static const byte _ship_subcoord[4][6][3] = {
514  {
515  {15, 8, 1},
516  { 0, 0, 0},
517  { 0, 0, 0},
518  {15, 8, 2},
519  {15, 7, 0},
520  { 0, 0, 0},
521  },
522  {
523  { 0, 0, 0},
524  { 8, 0, 3},
525  { 7, 0, 2},
526  { 0, 0, 0},
527  { 8, 0, 4},
528  { 0, 0, 0},
529  },
530  {
531  { 0, 8, 5},
532  { 0, 0, 0},
533  { 0, 7, 6},
534  { 0, 0, 0},
535  { 0, 0, 0},
536  { 0, 8, 4},
537  },
538  {
539  { 0, 0, 0},
540  { 8, 15, 7},
541  { 0, 0, 0},
542  { 8, 15, 6},
543  { 0, 0, 0},
544  { 7, 15, 0},
545  }
546 };
547 
553 static int ShipTestUpDownOnLock(const Ship *v)
554 {
555  /* Suitable tile? */
556  if (!IsTileType(v->tile, MP_WATER) || !IsLock(v->tile) || GetLockPart(v->tile) != LOCK_PART_MIDDLE) return 0;
557 
558  /* Must be at the centre of the lock */
559  if ((v->x_pos & 0xF) != 8 || (v->y_pos & 0xF) != 8) return 0;
560 
562  assert(IsValidDiagDirection(diagdir));
563 
564  if (DirToDiagDir(v->direction) == diagdir) {
565  /* Move up */
566  return (v->z_pos < GetTileMaxZ(v->tile) * (int)TILE_HEIGHT) ? 1 : 0;
567  } else {
568  /* Move down */
569  return (v->z_pos > GetTileZ(v->tile) * (int)TILE_HEIGHT) ? -1 : 0;
570  }
571 }
572 
578 static bool ShipMoveUpDownOnLock(Ship *v)
579 {
580  /* Moving up/down through lock */
581  int dz = ShipTestUpDownOnLock(v);
582  if (dz == 0) return false;
583 
584  if (v->cur_speed != 0) {
585  v->cur_speed = 0;
587  }
588 
589  if ((v->tick_counter & 7) == 0) {
590  v->z_pos += dz;
591  v->UpdatePosition();
592  v->UpdateViewport(true, true);
593  }
594 
595  return true;
596 }
597 
604 bool IsShipDestinationTile(TileIndex tile, StationID station)
605 {
606  assert(IsDockingTile(tile));
607  /* Check each tile adjacent to docking tile. */
608  for (DiagDirection d = DIAGDIR_BEGIN; d != DIAGDIR_END; d++) {
609  TileIndex t = tile + TileOffsByDiagDir(d);
610  if (!IsValidTile(t)) continue;
611  if (IsDockTile(t) && GetStationIndex(t) == station && IsValidDockingDirectionForDock(t, d)) return true;
612  if (IsTileType(t, MP_INDUSTRY)) {
613  const Industry *i = Industry::GetByTile(t);
614  if (i->neutral_station != nullptr && i->neutral_station->index == station) return true;
615  }
616  if (IsTileType(t, MP_STATION) && IsOilRig(t) && GetStationIndex(t) == station) return true;
617  }
618  return false;
619 }
620 
621 static void ShipController(Ship *v)
622 {
623  uint32 r;
624  const byte *b;
625  Track track;
626  TrackBits tracks;
627 
628  v->tick_counter++;
629  v->current_order_time++;
630 
631  if (v->HandleBreakdown()) return;
632 
633  if (v->vehstatus & VS_STOPPED) return;
634 
635  ProcessOrders(v);
636  v->HandleLoading();
637 
638  if (v->current_order.IsType(OT_LOADING)) return;
639 
640  if (CheckShipLeaveDepot(v)) return;
641 
642  v->ShowVisualEffect();
643 
644  /* Rotating on spot */
645  if (v->direction != v->rotation) {
646  if ((v->tick_counter & 7) == 0) {
647  DirDiff diff = DirDifference(v->direction, v->rotation);
649  /* Invalidate the sprite cache direction to force recalculation of viewport */
651  v->UpdateViewport(true, true);
652  }
653  return;
654  }
655 
656  if (ShipMoveUpDownOnLock(v)) return;
657 
658  if (!ShipAccelerate(v)) return;
659 
661  if (v->state != TRACK_BIT_WORMHOLE) {
662  /* Not on a bridge */
663  if (gp.old_tile == gp.new_tile) {
664  /* Staying in tile */
665  if (v->IsInDepot()) {
666  gp.x = v->x_pos;
667  gp.y = v->y_pos;
668  } else {
669  /* Not inside depot */
670  r = VehicleEnterTile(v, gp.new_tile, gp.x, gp.y);
671  if (HasBit(r, VETS_CANNOT_ENTER)) goto reverse_direction;
672 
673  /* A leave station order only needs one tick to get processed, so we can
674  * always skip ahead. */
675  if (v->current_order.IsType(OT_LEAVESTATION)) {
676  v->current_order.Free();
678  /* Test if continuing forward would lead to a dead-end, moving into the dock. */
679  DiagDirection exitdir = VehicleExitDir(v->direction, v->state);
680  TileIndex tile = TileAddByDiagDir(v->tile, exitdir);
681  if (TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0, exitdir)) == TRACK_BIT_NONE) goto reverse_direction;
682  } else if (v->dest_tile != 0) {
683  /* We have a target, let's see if we reached it... */
684  if (v->current_order.IsType(OT_GOTO_WAYPOINT) &&
685  DistanceManhattan(v->dest_tile, gp.new_tile) <= 3) {
686  /* We got within 3 tiles of our target buoy, so let's skip to our
687  * next order */
688  UpdateVehicleTimetable(v, true);
691  } else if (v->current_order.IsType(OT_GOTO_DEPOT) &&
692  v->dest_tile == gp.new_tile) {
693  /* Depot orders really need to reach the tile */
694  if ((gp.x & 0xF) == 8 && (gp.y & 0xF) == 8) {
696  return;
697  }
698  } else if (v->current_order.IsType(OT_GOTO_STATION) && IsDockingTile(gp.new_tile)) {
699  /* Process station in the orderlist. */
702  v->last_station_visited = st->index;
703  if (st->facilities & FACIL_DOCK) { // ugly, ugly workaround for problem with ships able to drop off cargo at wrong stations
704  ShipArrivesAt(v, st);
705  v->BeginLoading();
706  } else { // leave stations without docks right away
709  }
710  }
711  }
712  }
713  }
714  } else {
715  /* New tile */
716  if (!IsValidTile(gp.new_tile)) goto reverse_direction;
717 
719  assert(diagdir != INVALID_DIAGDIR);
720  tracks = GetAvailShipTracks(gp.new_tile, diagdir);
721  if (tracks == TRACK_BIT_NONE) goto reverse_direction;
722 
723  /* Choose a direction, and continue if we find one */
724  track = ChooseShipTrack(v, gp.new_tile, diagdir, tracks);
725  if (track == INVALID_TRACK) goto reverse_direction;
726 
727  b = _ship_subcoord[diagdir][track];
728 
729  gp.x = (gp.x & ~0xF) | b[0];
730  gp.y = (gp.y & ~0xF) | b[1];
731 
732  /* Call the landscape function and tell it that the vehicle entered the tile */
733  r = VehicleEnterTile(v, gp.new_tile, gp.x, gp.y);
734  if (HasBit(r, VETS_CANNOT_ENTER)) goto reverse_direction;
735 
736  if (!HasBit(r, VETS_ENTERED_WORMHOLE)) {
737  v->tile = gp.new_tile;
738  v->state = TrackToTrackBits(track);
739 
740  /* Update ship cache when the water class changes. Aqueducts are always canals. */
743  if (old_wc != new_wc) v->UpdateCache();
744  }
745 
746  Direction new_direction = (Direction)b[2];
747  DirDiff diff = DirDifference(new_direction, v->direction);
748  switch (diff) {
749  case DIRDIFF_SAME:
750  case DIRDIFF_45RIGHT:
751  case DIRDIFF_45LEFT:
752  /* Continue at speed */
753  v->rotation = v->direction = new_direction;
754  break;
755 
756  default:
757  /* Stop for rotation */
758  v->cur_speed = 0;
759  v->direction = new_direction;
760  /* Remember our current location to avoid movement glitch */
761  v->rotation_x_pos = v->x_pos;
762  v->rotation_y_pos = v->y_pos;
763  break;
764  }
765  }
766  } else {
767  /* On a bridge */
769  v->x_pos = gp.x;
770  v->y_pos = gp.y;
771  v->UpdatePosition();
772  if ((v->vehstatus & VS_HIDDEN) == 0) v->Vehicle::UpdateViewport(true);
773  return;
774  }
775 
776  /* Ship is back on the bridge head, we need to consume its path
777  * cache entry here as we didn't have to choose a ship track. */
778  if (!v->path.empty()) v->path.pop_front();
779  }
780 
781  /* update image of ship, as well as delta XY */
782  v->x_pos = gp.x;
783  v->y_pos = gp.y;
784 
785 getout:
786  v->UpdatePosition();
787  v->UpdateViewport(true, true);
788  return;
789 
790 reverse_direction:
791  v->direction = ReverseDir(v->direction);
792  /* Remember our current location to avoid movement glitch */
793  v->rotation_x_pos = v->x_pos;
794  v->rotation_y_pos = v->y_pos;
795  v->cur_speed = 0;
796  v->path.clear();
797  goto getout;
798 }
799 
801 {
803 
804  if (!(this->vehstatus & VS_STOPPED)) this->running_ticks++;
805 
806  ShipController(this);
807 
808  return true;
809 }
810 
811 void Ship::SetDestTile(TileIndex tile)
812 {
813  if (tile == this->dest_tile) return;
814  this->path.clear();
815  this->dest_tile = tile;
816 }
817 
827 CommandCost CmdBuildShip(TileIndex tile, DoCommandFlag flags, const Engine *e, uint16 data, Vehicle **ret)
828 {
829  tile = GetShipDepotNorthTile(tile);
830  if (flags & DC_EXEC) {
831  int x;
832  int y;
833 
834  const ShipVehicleInfo *svi = &e->u.ship;
835 
836  Ship *v = new Ship();
837  *ret = v;
838 
839  v->owner = _current_company;
840  v->tile = tile;
841  x = TileX(tile) * TILE_SIZE + TILE_SIZE / 2;
842  y = TileY(tile) * TILE_SIZE + TILE_SIZE / 2;
843  v->x_pos = x;
844  v->y_pos = y;
845  v->z_pos = GetSlopePixelZ(x, y);
846 
847  v->UpdateDeltaXY();
849 
850  v->spritenum = svi->image_index;
852  v->cargo_cap = svi->capacity;
853  v->refit_cap = 0;
854 
855  v->last_station_visited = INVALID_STATION;
856  v->last_loading_station = INVALID_STATION;
857  v->engine_type = e->index;
858 
859  v->reliability = e->reliability;
861  v->max_age = e->GetLifeLengthInDays();
862  _new_vehicle_id = v->index;
863 
864  v->state = TRACK_BIT_DEPOT;
865 
866  v->SetServiceInterval(Company::Get(_current_company)->settings.vehicle.servint_ships);
868  v->build_year = _cur_year;
869  v->sprite_cache.sprite_seq.Set(SPR_IMG_QUERY);
871 
872  v->UpdateCache();
873 
875  v->SetServiceIntervalIsPercent(Company::Get(_current_company)->settings.vehicle.servint_ispercent);
876 
878 
879  v->cargo_cap = e->DetermineCapacity(v);
880 
882 
883  v->UpdatePosition();
884  }
885 
886  return CommandCost();
887 }
888 
889 bool Ship::FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)
890 {
891  const Depot *depot = FindClosestShipDepot(this, 0);
892 
893  if (depot == nullptr) return false;
894 
895  if (location != nullptr) *location = depot->xy;
896  if (destination != nullptr) *destination = depot->index;
897 
898  return true;
899 }
VSE_START
@ VSE_START
Vehicle starting, i.e. leaving, the station.
Definition: newgrf_sound.h:19
game.hpp
ChooseShipTrack
static Track ChooseShipTrack(Ship *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks)
Runs the pathfinder to choose a track to continue along.
Definition: ship_cmd.cpp:461
VehicleExitDir
static DiagDirection VehicleExitDir(Direction direction, TrackBits track)
Determine the side in which the vehicle will leave the tile.
Definition: track_func.h:722
Vehicle::IsChainInDepot
virtual bool IsChainInDepot() const
Check whether the whole vehicle chain is in the depot.
Definition: vehicle_base.h:521
BaseStation::facilities
StationFacility facilities
The facilities that this station has.
Definition: base_station_base.h:63
TRACK_BIT_WORMHOLE
@ TRACK_BIT_WORMHOLE
Bitflag for a wormhole (used for tunnels)
Definition: track_type.h:55
PlayVehicleSound
bool PlayVehicleSound(const Vehicle *v, VehicleSoundEvent event)
Checks whether a NewGRF wants to play a different vehicle sound effect.
Definition: newgrf_sound.cpp:185
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
PathfinderSettings::npf
NPFSettings npf
pathfinder settings for the new pathfinder
Definition: settings_type.h:435
ShipTestUpDownOnLock
static int ShipTestUpDownOnLock(const Ship *v)
Test if a ship is in the centre of a lock and should move up or down.
Definition: ship_cmd.cpp:553
TILE_ADD
#define TILE_ADD(x, y)
Adds to tiles together.
Definition: map_func.h:244
Station::docking_station
TileArea docking_station
Tile area the docking tiles cover.
Definition: station_base.h:466
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3321
Order::MakeDummy
void MakeDummy()
Makes this order a Dummy order.
Definition: order_cmd.cpp:132
sound_func.h
UpdateVehicleTimetable
void UpdateVehicleTimetable(Vehicle *v, bool travelling)
Update the timetable for the vehicle.
Definition: timetable_cmd.cpp:372
MutableSpriteCache::last_direction
Direction last_direction
Last direction we obtained sprites for.
Definition: vehicle_base.h:189
TRACK_BIT_NONE
@ TRACK_BIT_NONE
No track.
Definition: track_type.h:39
DIRDIFF_REVERSE
@ DIRDIFF_REVERSE
One direction is the opposite of the other one.
Definition: direction_type.h:66
Order::IsType
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:61
Pool::PoolItem<&_engine_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:329
TileOffsByDiagDir
static TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition: map_func.h:341
Direction
Direction
Defines the 8 directions on the map.
Definition: direction_type.h:24
Vehicle::y_pos
int32 y_pos
y coordinate.
Definition: vehicle_base.h:279
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3220
MutableSpriteCache::sprite_seq
VehicleSpriteSeq sprite_seq
Vehicle appearance.
Definition: vehicle_base.h:193
GetTileMaxZ
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
Definition: tile_map.cpp:141
Ship::Tick
bool Tick()
Calls the tick handler of the vehicle.
Definition: ship_cmd.cpp:800
GetPrice
Money GetPrice(Price index, uint cost_factor, const GRFFile *grf_file, int shift)
Determine a certain price.
Definition: economy.cpp:950
NT_ARRIVAL_OTHER
@ NT_ARRIVAL_OTHER
First vehicle arrived for competitor.
Definition: news_type.h:23
Vehicle::x_pos
int32 x_pos
x coordinate.
Definition: vehicle_base.h:278
DIRDIFF_45LEFT
@ DIRDIFF_45LEFT
Angle of 45 degrees left.
Definition: direction_type.h:68
ChangeDir
static Direction ChangeDir(Direction d, DirDiff delta)
Change a direction by a given difference.
Definition: direction_func.h:104
HasTileWaterClass
static bool HasTileWaterClass(TileIndex t)
Checks whether the tile has an waterclass associated.
Definition: water_map.h:95
ODTFB_SERVICE
@ ODTFB_SERVICE
This depot order is because of the servicing limit.
Definition: order_type.h:95
Ship::FindClosestDepot
bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)
Find the closest depot for this vehicle and tell us the location, DestinationID and whether we should...
Definition: ship_cmd.cpp:889
EnsureNoMovingShipProc
static Vehicle * EnsureNoMovingShipProc(Vehicle *v, void *data)
Test-procedure for HasVehicleOnPos to check for any ships which are visible and not stopped by the pl...
Definition: ship_cmd.cpp:333
HasVehicleOnPos
bool HasVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Checks whether a vehicle is on a specific location.
Definition: vehicle.cpp:513
CheckOrders
void CheckOrders(const Vehicle *v)
Check the orders of a vehicle, to see if there are invalid orders and stuff.
Definition: order_cmd.cpp:1729
Engine::reliability_spd_dec
uint16 reliability_spd_dec
Speed of reliability decay between services (per day).
Definition: engine_base.h:26
Order::MakeLeaveStation
void MakeLeaveStation()
Makes this order a Leave Station order.
Definition: order_cmd.cpp:123
company_base.h
_cur_year
Year _cur_year
Current year, starting at 0.
Definition: date.cpp:26
tunnelbridge_map.h
DIRDIFF_SAME
@ DIRDIFF_SAME
Both directions faces to the same direction.
Definition: direction_type.h:63
Vehicle::y_extent
byte y_extent
y-extent of vehicle bounding box
Definition: vehicle_base.h:291
Station
Station data structure.
Definition: station_base.h:450
Order::GetDestination
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:94
Vehicle::NeedsAutomaticServicing
bool NeedsAutomaticServicing() const
Checks if the current order should be interrupted for a service-in-depot order.
Definition: vehicle.cpp:252
Vehicle::z_pos
int32 z_pos
z coordinate.
Definition: vehicle_base.h:280
VehicleSpriteSeq::Set
void Set(SpriteID sprite)
Assign a single sprite to the sequence.
Definition: vehicle_base.h:161
Ship::path
ShipPathCache path
Cached path.
Definition: ship.h:28
Vehicle::random_bits
byte random_bits
Bits used for determining which randomized variational spritegroups to use when drawing.
Definition: vehicle_base.h:308
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:326
DIAGDIR_END
@ DIAGDIR_END
Used for iterations.
Definition: direction_type.h:83
VPF_YAPF
@ VPF_YAPF
Yet Another PathFinder.
Definition: vehicle_type.h:61
VS_DEFPAL
@ VS_DEFPAL
Use default vehicle palette.
Definition: vehicle_base.h:33
Ship::PlayLeaveStationSound
void PlayLeaveStationSound() const
Play the sound associated with leaving the station.
Definition: ship_cmd.cpp:281
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:227
AxisToTrackBits
static TrackBits AxisToTrackBits(Axis a)
Maps an Axis to the corresponding TrackBits value.
Definition: track_func.h:96
Order::Free
void Free()
'Free' the order
Definition: order_cmd.cpp:62
YapfShipCheckReverse
bool YapfShipCheckReverse(const Ship *v)
Returns true if it is better to reverse the ship before leaving depot using YAPF.
Definition: yapf_ship.cpp:366
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
GetTileZ
int GetTileZ(TileIndex tile)
Get bottom height of the tile.
Definition: tile_map.cpp:121
ship.h
UnScaleGUI
static int UnScaleGUI(int value)
Short-hand to apply GUI zoom level.
Definition: zoom_func.h:66
Ship::rotation
Direction rotation
Visible direction.
Definition: ship.h:29
DiagDirToDiagTrackdir
static Trackdir DiagDirToDiagTrackdir(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal trackdir that runs in that direction.
Definition: track_func.h:545
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition: tile_type.h:42
WaterClass
WaterClass
classes of water (for WATER_TILE_CLEAR water tile type).
Definition: water_map.h:47
IsValidDiagDirection
static bool IsValidDiagDirection(DiagDirection d)
Checks if an integer value is a valid DiagDirection.
Definition: direction_func.h:21
zoom_func.h
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:13
AddVehicleNewsItem
static void AddVehicleNewsItem(StringID string, NewsType type, VehicleID vehicle, StationID station=INVALID_STATION)
Adds a newsitem referencing a vehicle.
Definition: news_func.h:30
Vehicle::running_ticks
byte running_ticks
Number of ticks this vehicle was not stopped this day.
Definition: vehicle_base.h:324
SpecializedStation< Station, false >::Get
static Station * Get(size_t index)
Gets station with given index.
Definition: base_station_base.h:219
DirDifference
static DirDiff DirDifference(Direction d0, Direction d1)
Calculate the difference between two directions.
Definition: direction_func.h:68
VehicleEnterDepot
void VehicleEnterDepot(Vehicle *v)
Vehicle entirely entered the depot, update its status, orders, vehicle windows, service it,...
Definition: vehicle.cpp:1472
Ship::IsInDepot
bool IsInDepot() const
Check whether the vehicle is in the depot.
Definition: ship.h:48
MP_INDUSTRY
@ MP_INDUSTRY
Part of an industry.
Definition: tile_type.h:49
TileY
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
Engine::GetLifeLengthInDays
Date GetLifeLengthInDays() const
Returns the vehicle's (not model's!) life length in days.
Definition: engine.cpp:442
DIR_W
@ DIR_W
West.
Definition: direction_type.h:32
EngineImageType
EngineImageType
Visualisation contexts of vehicles and engines.
Definition: vehicle_type.h:85
Engine
Definition: engine_base.h:21
Vehicle::cur_speed
uint16 cur_speed
current speed
Definition: vehicle_base.h:302
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:222
Industry
Defines the internal data of a functional industry.
Definition: industry.h:66
Engine::GetDefaultCargoType
CargoID GetDefaultCargoType() const
Determines the default cargo type of an engine.
Definition: engine_base.h:79
VehicleSpriteSeq::Draw
void Draw(int x, int y, PaletteID default_pal, bool force_pal) const
Draw the sprite sequence.
Definition: vehicle.cpp:126
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:283
VehicleCache::cached_cargo_age_period
uint16 cached_cargo_age_period
Number of ticks before carried cargo is aged.
Definition: vehicle_base.h:122
DC_EXEC
@ DC_EXEC
execute the given command
Definition: command_type.h:348
GetAvailShipTracks
static TrackBits GetAvailShipTracks(TileIndex tile, DiagDirection dir)
Get the available water tracks on a tile for a ship entering a tile.
Definition: ship_cmd.cpp:506
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:199
GetShipDepotDirection
static DiagDirection GetShipDepotDirection(TileIndex t)
Get the direction of the ship depot.
Definition: water_map.h:261
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:346
VehicleServiceInDepot
void VehicleServiceInDepot(Vehicle *v)
Service a vehicle and all subsequent vehicles in the consist.
Definition: vehicle.cpp:162
Industry::neutral_station
Station * neutral_station
Associated neutral station.
Definition: industry.h:69
TrackToTrackBits
static TrackBits TrackToTrackBits(Track track)
Maps a Track to the corresponding TrackBits value.
Definition: track_func.h:85
TileX
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
industry_map.h
GetLockPart
static byte GetLockPart(TileIndex t)
Get the part of a lock.
Definition: water_map.h:320
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:589
ai.hpp
Order::MakeGoToDepot
void MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type=ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS, OrderDepotActionFlags action=ODATF_SERVICE_ONLY, CargoID cargo=CT_NO_REFIT)
Makes this order a Go To Depot order.
Definition: order_cmd.cpp:89
Order::GetMaxSpeed
uint16 GetMaxSpeed() const
Get the maxmimum speed in km-ish/h a vehicle is allowed to reach on the way to the destination.
Definition: order_base.h:192
Ship::UpdateCache
void UpdateCache()
Update the caches of this ship.
Definition: ship_cmd.cpp:202
GetShipDepotNorthTile
static TileIndex GetShipDepotNorthTile(TileIndex t)
Get the most northern tile of a ship depot.
Definition: water_map.h:283
Engine::GetGRF
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
Definition: engine_base.h:138
SetWindowWidgetDirty
void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, byte widget_index)
Mark a particular widget in a particular window as dirty (in need of repainting)
Definition: window.cpp:3234
ENGINE_EXCLUSIVE_PREVIEW
@ ENGINE_EXCLUSIVE_PREVIEW
This vehicle is in the exclusive preview stage, either being used or being offered to a company.
Definition: engine_type.h:169
Ship::rotation_y_pos
int16 rotation_y_pos
NOSAVE: Y Position before rotation.
Definition: ship.h:31
Vehicle::BeginLoading
void BeginLoading()
Prepare everything to begin the loading when arriving at a station.
Definition: vehicle.cpp:2092
GameSettings::pf
PathfinderSettings pf
settings for all pathfinders
Definition: settings_type.h:556
DistanceManhattan
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition: map.cpp:157
VS_HIDDEN
@ VS_HIDDEN
Vehicle is not visible.
Definition: vehicle_base.h:30
EngineID
uint16 EngineID
Unique identification number of an engine.
Definition: engine_type.h:21
depot_base.h
Vehicle::UpdateVisualEffect
void UpdateVisualEffect(bool allow_power_change=true)
Update the cached visual effect.
Definition: vehicle.cpp:2445
VehicleSpriteSeq::IsValid
bool IsValid() const
Check whether the sequence contains any sprites.
Definition: vehicle_base.h:145
Vehicle::dest_tile
TileIndex dest_tile
Heading for this tile.
Definition: vehicle_base.h:247
DirToDiagDir
static DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
Definition: direction_func.h:166
Vehicle::HandlePathfindingResult
void HandlePathfindingResult(bool path_found)
Handle the pathfinding result, especially the lost status.
Definition: vehicle.cpp:773
TrackBitsToTrack
static Track TrackBitsToTrack(TrackBits tracks)
Converts TrackBits to Track.
Definition: track_func.h:201
timetable.h
AI::NewEvent
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition: ai_core.cpp:234
CommandCost
Common return value for all commands.
Definition: command_type.h:23
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
WC_VEHICLE_VIEW
@ WC_VEHICLE_VIEW
Vehicle view; Window numbers:
Definition: window_type.h:332
newgrf_engine.h
Industry::GetByTile
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition: industry.h:144
YapfShipChooseTrack
Track YapfShipChooseTrack(const Ship *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found, ShipPathCache &path_cache)
Finds the best path for given ship using YAPF.
Definition: yapf_ship.cpp:351
YAPF_TILE_LENGTH
static const int YAPF_TILE_LENGTH
Length (penalty) of one tile with YAPF.
Definition: pathfinder_type.h:28
SubtractMoneyFromCompanyFract
void SubtractMoneyFromCompanyFract(CompanyID company, const CommandCost &cst)
Subtract money from a company, including the money fraction.
Definition: company_cmd.cpp:253
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:240
TrackStatusToTrackBits
static TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition: track_func.h:371
Ship::MarkDirty
void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
Definition: ship_cmd.cpp:267
npf_func.h
EIT_ON_MAP
@ EIT_ON_MAP
Vehicle drawn in viewport.
Definition: vehicle_type.h:86
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:297
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:37
IsDiagonalTrack
static bool IsDiagonalTrack(Track track)
Checks if a given Track is diagonal.
Definition: track_func.h:627
VETS_CANNOT_ENTER
@ VETS_CANNOT_ENTER
The vehicle cannot enter the tile.
Definition: tile_cmd.h:23
VehicleSpriteSeq
Sprite sequence for a vehicle part.
Definition: vehicle_base.h:128
Vehicle::last_station_visited
StationID last_station_visited
The last station we stopped at.
Definition: vehicle_base.h:311
MP_WATER
@ MP_WATER
Water tile.
Definition: tile_type.h:47
PFE_GL_SHIPS
@ PFE_GL_SHIPS
Time spent processing ships.
Definition: framerate_type.h:53
NPFSettings::maximum_go_to_depot_penalty
uint32 maximum_go_to_depot_penalty
What is the maximum penalty that may be endured for going to a depot.
Definition: settings_type.h:355
TrackToOppositeTrack
static Track TrackToOppositeTrack(Track t)
Find the opposite track to a given track.
Definition: track_func.h:239
Ship::OnNewDay
void OnNewDay()
Calls the new day handler of the vehicle.
Definition: ship_cmd.cpp:224
Vehicle::GetOldAdvanceSpeed
uint GetOldAdvanceSpeed(uint speed)
Determines the effective direction-specific vehicle movement speed.
Definition: vehicle_base.h:396
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:327
Vehicle::max_age
Date max_age
Maximum age.
Definition: vehicle_base.h:269
LOCK_PART_MIDDLE
@ LOCK_PART_MIDDLE
Middle part of a lock.
Definition: water_map.h:65
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:80
HVOT_SHIP
@ HVOT_SHIP
Station has seen a ship.
Definition: station_type.h:68
Ship::GetImage
void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const
Gets the sprite to show for the given direction.
Definition: ship_cmd.cpp:127
WC_VEHICLE_DETAILS
@ WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
Definition: window_type.h:193
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:141
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:31
Vehicle::ShowVisualEffect
void ShowVisualEffect() const
Draw visual effects (smoke and/or sparks) for a vehicle chain.
Definition: vehicle.cpp:2568
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
PROP_SHIP_CARGO_AGE_PERIOD
@ PROP_SHIP_CARGO_AGE_PERIOD
Number of ticks before carried cargo is aged.
Definition: newgrf_properties.h:46
Vehicle::GetEngine
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:741
VehicleEnterTile
VehicleEnterTileStatus VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y)
Call the tile callback function for a vehicle entering a tile.
Definition: vehicle.cpp:1734
industry.h
DiagdirReachesTracks
static TrackBits DiagdirReachesTracks(DiagDirection diagdir)
Returns all tracks that can be reached when entering a tile from a given (diagonal) direction.
Definition: track_func.h:581
safeguards.h
GetNewVehiclePosResult::new_tile
TileIndex new_tile
Tile of the vehicle after moving.
Definition: vehicle_func.h:78
Vehicle::reliability_spd_dec
uint16 reliability_spd_dec
Reliability decrease speed.
Definition: vehicle_base.h:272
Vehicle::last_loading_station
StationID last_loading_station
Last station the vehicle has stopped at and could possibly leave from with any cargo loaded.
Definition: vehicle_base.h:312
DiagDirToDir
static Direction DiagDirToDir(DiagDirection dir)
Convert a DiagDirection to a Direction.
Definition: direction_func.h:182
IsValidTile
static bool IsValidTile(TileIndex tile)
Checks if a tile is valid.
Definition: tile_map.h:161
CommandCost::GetCost
Money GetCost() const
The costs as made up to this moment.
Definition: command_type.h:82
TileAddByDiagDir
static TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
Adds a DiagDir to a tile.
Definition: map_func.h:382
GetTileSlope
Slope GetTileSlope(TileIndex tile, int *h)
Return the slope of a given tile inside the map.
Definition: tile_map.cpp:59
ReverseDiagDir
static DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
Definition: direction_func.h:118
WC_SHIPS_LIST
@ WC_SHIPS_LIST
Ships list; Window numbers:
Definition: window_type.h:313
Vehicle::profit_this_year
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
Definition: vehicle_base.h:249
IsTileOwner
static bool IsTileOwner(TileIndex tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition: tile_map.h:214
settings
fluid_settings_t * settings
FluidSynth settings handle.
Definition: fluidsynth.cpp:21
INVALID_DIAGDIR
@ INVALID_DIAGDIR
Flag for an invalid DiagDirection.
Definition: direction_type.h:84
Ship::UpdateDeltaXY
void UpdateDeltaXY()
Updates the x and y offsets and the size of the sprite used for this vehicle.
Definition: ship_cmd.cpp:299
MP_TUNNELBRIDGE
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition: tile_type.h:50
INVALID_TRACKDIR
@ INVALID_TRACKDIR
Flag for an invalid trackdir.
Definition: track_type.h:89
DirDiff
DirDiff
Enumeration for the difference between two directions.
Definition: direction_type.h:62
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition: direction_type.h:77
Vehicle::HandleLoading
void HandleLoading(bool mode=false)
Handle the loading of the vehicle; when not it skips through dummy orders and does nothing in all oth...
Definition: vehicle.cpp:2301
FACIL_DOCK
@ FACIL_DOCK
Station with a dock.
Definition: station_type.h:56
GetShipSpriteSize
void GetShipSpriteSize(EngineID engine, uint &width, uint &height, int &xoffs, int &yoffs, EngineImageType image_type)
Get the size of the sprite of a ship sprite heading west (used for lists).
Definition: ship_cmd.cpp:113
date_func.h
WATER_CLASS_CANAL
@ WATER_CLASS_CANAL
Canal.
Definition: water_map.h:49
stdafx.h
BaseConsist::vehicle_flags
uint16 vehicle_flags
Used for gradual loading and other miscellaneous things (.
Definition: base_consist.h:31
WID_VV_START_STOP
@ WID_VV_START_STOP
Start or stop this vehicle, and show information about the current state.
Definition: vehicle_widget.h:17
Vehicle::sprite_cache
MutableSpriteCache sprite_cache
Cache of sprites and values related to recalculating them, see MutableSpriteCache.
Definition: vehicle_base.h:341
landscape.h
VPF_NPF
@ VPF_NPF
New PathFinder.
Definition: vehicle_type.h:60
IsValidDockingDirectionForDock
bool IsValidDockingDirectionForDock(TileIndex t, DiagDirection d)
Check if a dock tile can be docked from the given direction.
Definition: station_cmd.cpp:2642
Vehicle::y_offs
int8 y_offs
y offset for vehicle sprite
Definition: vehicle_base.h:296
Vehicle::colourmap
SpriteID colourmap
NOSAVE: cached colour mapping.
Definition: vehicle_base.h:264
AxisToDiagDir
static DiagDirection AxisToDiagDir(Axis a)
Converts an Axis to a DiagDirection.
Definition: direction_func.h:232
PROP_SHIP_RUNNING_COST_FACTOR
@ PROP_SHIP_RUNNING_COST_FACTOR
Yearly runningcost.
Definition: newgrf_properties.h:45
IsTileType
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
Vehicle::IncrementRealOrderIndex
void IncrementRealOrderIndex()
Advanced cur_real_order_index to the next real order, keeps care of the wrap-around and invalidates t...
Definition: vehicle_base.h:836
VF_BUILT_AS_PROTOTYPE
@ VF_BUILT_AS_PROTOTYPE
Vehicle is a prototype (accepted as exclusive preview).
Definition: vehicle_base.h:44
Ship::GetVehicleTrackdir
Trackdir GetVehicleTrackdir() const
Returns the Trackdir on which the vehicle is currently located.
Definition: ship_cmd.cpp:250
RAIL_GROUND_WATER
@ RAIL_GROUND_WATER
Grass with a fence and shore or water on the free halftile.
Definition: rail_map.h:499
Vehicle::direction
Direction direction
facing
Definition: vehicle_base.h:281
TRACK_BIT_DEPOT
@ TRACK_BIT_DEPOT
Bitflag for a depot.
Definition: track_type.h:56
PerformanceAccumulator
RAII class for measuring multi-step elements of performance.
Definition: framerate_type.h:114
ProcessOrders
bool ProcessOrders(Vehicle *v)
Handle the orders of a vehicle and determine the next place to go to if needed.
Definition: order_cmd.cpp:2130
spritecache.h
ReverseDir
static Direction ReverseDir(Direction d)
Return the reverse of a direction.
Definition: direction_func.h:54
Vehicle::x_extent
byte x_extent
x-extent of vehicle bounding box
Definition: vehicle_base.h:290
IsDockTile
static bool IsDockTile(TileIndex t)
Is tile t a dock tile?
Definition: station_map.h:295
Vehicle::vcache
VehicleCache vcache
Cache of often used vehicle values.
Definition: vehicle_base.h:339
Ship
All ships have this type.
Definition: ship.h:26
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
vehicle_func.h
station_base.h
newgrf_sound.h
Clamp
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:77
Pool::PoolItem<&_depot_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:378
PALETTE_CRASH
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition: sprites.h:1594
strings_func.h
IsShipDestinationTile
bool IsShipDestinationTile(TileIndex tile, StationID station)
Test if a tile is a docking tile for the given station.
Definition: ship_cmd.cpp:604
GetWaterClass
static WaterClass GetWaterClass(TileIndex t)
Get the water class at a tile.
Definition: water_map.h:106
Vehicle::tick_counter
byte tick_counter
Increased by one for each tick.
Definition: vehicle_base.h:323
yapf.h
Vehicle::cargo_cap
uint16 cargo_cap
total capacity
Definition: vehicle_base.h:316
Vehicle::x_offs
int8 x_offs
x offset for vehicle sprite
Definition: vehicle_base.h:295
DiagdirBetweenTiles
static DiagDirection DiagdirBetweenTiles(TileIndex tile_from, TileIndex tile_to)
Determines the DiagDirection to get from one tile to another.
Definition: map_func.h:394
DIRDIFF_45RIGHT
@ DIRDIFF_45RIGHT
Angle of 45 degrees right.
Definition: direction_type.h:64
Vehicle::z_extent
byte z_extent
z-extent of vehicle bounding box
Definition: vehicle_base.h:292
VehicleRandomBits
byte VehicleRandomBits()
Get a value for a vehicle's random_bits.
Definition: vehicle.cpp:363
Vehicle::InvalidateNewGRFCacheOfChain
void InvalidateNewGRFCacheOfChain()
Invalidates cached NewGRF variables of all vehicles in the chain (after the current vehicle)
Definition: vehicle_base.h:471
Ship::GetOrderStationLocation
TileIndex GetOrderStationLocation(StationID station)
Determine the location for the station where the vehicle goes to next.
Definition: ship_cmd.cpp:286
PaletteID
uint32 PaletteID
The number of the palette.
Definition: gfx_type.h:18
NPFShipCheckReverse
bool NPFShipCheckReverse(const Ship *v)
Returns true if it is better to reverse the ship before leaving depot using NPF.
Definition: npf.cpp:1218
framerate_type.h
PathfinderSettings::pathfinder_for_ships
uint8 pathfinder_for_ships
the pathfinder to use for ships
Definition: settings_type.h:421
BaseConsist::current_order_time
uint32 current_order_time
How many ticks have passed since this order started.
Definition: base_consist.h:22
TRANSPORT_WATER
@ TRANSPORT_WATER
Transport over water.
Definition: transport_type.h:29
Ship::state
TrackBits state
The "track" the ship is following.
Definition: ship.h:27
GetNewVehiclePosResult
Position information of a vehicle after it moved.
Definition: vehicle_func.h:75
WC_VEHICLE_DEPOT
@ WC_VEHICLE_DEPOT
Depot view; Window numbers:
Definition: window_type.h:344
CmdBuildShip
CommandCost CmdBuildShip(TileIndex tile, DoCommandFlag flags, const Engine *e, uint16 data, Vehicle **ret)
Build a ship.
Definition: ship_cmd.cpp:827
MP_STATION
@ MP_STATION
A tile of a station.
Definition: tile_type.h:46
GetStationIndex
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
Vehicle::build_year
Year build_year
Year the vehicle has been built.
Definition: vehicle_base.h:267
NPF_TILE_LENGTH
static const int NPF_TILE_LENGTH
Length (penalty) of one tile with NPF.
Definition: pathfinder_type.h:16
IsLock
static bool IsLock(TileIndex t)
Is there a lock on a given water tile?
Definition: water_map.h:297
ShipVehicleInfo
Information about a ship vehicle.
Definition: engine_type.h:65
DIAGDIR_BEGIN
@ DIAGDIR_BEGIN
Used for iterations.
Definition: direction_type.h:78
DAYS_IN_YEAR
static const int DAYS_IN_YEAR
days per year
Definition: date_type.h:29
TrackDirectionToTrackdir
static Trackdir TrackDirectionToTrackdir(Track track, Direction dir)
Maps a track and a full (8-way) direction to the trackdir that represents the track running in the gi...
Definition: track_func.h:506
GetShipDepotAxis
static Axis GetShipDepotAxis(TileIndex t)
Get the axis of the ship depot.
Definition: water_map.h:237
BaseStation::xy
TileIndex xy
Base tile of the station.
Definition: base_station_base.h:53
VehicleCache::cached_max_speed
uint16 cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Definition: vehicle_base.h:121
company_func.h
FindFirstTrack
static Track FindFirstTrack(TrackBits tracks)
Returns first Track from TrackBits or INVALID_TRACK.
Definition: track_func.h:185
NPFShipChooseTrack
Track NPFShipChooseTrack(const Ship *v, bool &path_found)
Finds the best path for given ship using NPF.
Definition: npf.cpp:1197
ShipArrivesAt
static void ShipArrivesAt(const Vehicle *v, Station *st)
Ship arrives at a dock.
Definition: ship_cmd.cpp:433
NT_ARRIVAL_COMPANY
@ NT_ARRIVAL_COMPANY
First vehicle arrived for company.
Definition: news_type.h:22
Engine::original_image_index
uint8 original_image_index
Original vehicle image index, thus the image index of the overridden vehicle.
Definition: engine_base.h:39
GetNewVehiclePosResult::old_tile
TileIndex old_tile
Current tile of the vehicle.
Definition: vehicle_func.h:77
TrackBits
TrackBits
Bitfield corresponding to Track.
Definition: track_type.h:38
IsDockingTile
static bool IsDockingTile(TileIndex t)
Checks whether the tile is marked as a dockling tile.
Definition: water_map.h:365
Vehicle::day_counter
byte day_counter
Increased by one for each day.
Definition: vehicle_base.h:322
window_func.h
Depot
Definition: depot_base.h:19
SetBit
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
Definition: bitmath_func.hpp:121
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:367
ShipMoveUpDownOnLock
static bool ShipMoveUpDownOnLock(Ship *v)
Test and move a ship up or down in a lock.
Definition: ship_cmd.cpp:578
PathfinderSettings::yapf
YAPFSettings yapf
pathfinder settings for the yet another pathfinder
Definition: settings_type.h:436
AgeVehicle
void AgeVehicle(Vehicle *v)
Update age of a vehicle.
Definition: vehicle.cpp:1363
Vehicle::progress
byte progress
The percentage (if divided by 256) this vehicle already crossed the tile unit.
Definition: vehicle_base.h:306
Ship::rotation_x_pos
int16 rotation_x_pos
NOSAVE: X Position before rotation.
Definition: ship.h:30
Engine::DetermineCapacity
uint DetermineCapacity(const Vehicle *v, uint16 *mail_capacity=nullptr) const
Determines capacity of a given vehicle from scratch.
Definition: engine.cpp:202
TILE_HEIGHT
static const uint TILE_HEIGHT
Height of a height level in world coordinate AND in pixels in #ZOOM_LVL_BASE.
Definition: tile_type.h:16
OverflowSafeInt< int64, INT64_MAX, INT64_MIN >
IsOilRig
static bool IsOilRig(TileIndex t)
Is tile t part of an oilrig?
Definition: station_map.h:274
Axis
Axis
Allow incrementing of DiagDirDiff variables.
Definition: direction_type.h:123
engine_base.h
Ship::GetRunningCost
Money GetRunningCost() const
Gets the running cost of a vehicle.
Definition: ship_cmd.cpp:217
Vehicle::cargo_type
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:314
Vehicle::spritenum
byte spritenum
currently displayed sprite index 0xfd == custom sprite, 0xfe == custom second head sprite 0xff == res...
Definition: vehicle_base.h:289
ShipVehicleInfo::max_speed
uint16 max_speed
Maximum speed (1 unit = 1/3.2 mph = 0.5 km-ish/h)
Definition: engine_type.h:68
Trackdir
Trackdir
Enumeration for tracks and directions.
Definition: track_type.h:70
PROP_SHIP_SPEED
@ PROP_SHIP_SPEED
Max. speed: 1 unit = 1/3.2 mph = 0.5 km-ish/h.
Definition: newgrf_properties.h:43
YAPFSettings::maximum_go_to_depot_penalty
uint32 maximum_go_to_depot_penalty
What is the maximum penalty that may be endured for going to a depot.
Definition: settings_type.h:379
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
WATER_CLASS_SEA
@ WATER_CLASS_SEA
Sea.
Definition: water_map.h:48
Vehicle::reliability
uint16 reliability
Reliability.
Definition: vehicle_base.h:271
Vehicle::UpdatePosition
void UpdatePosition()
Update the position of the vehicle.
Definition: vehicle.cpp:1595
Engine::flags
byte flags
Flags of the engine.
Definition: engine_base.h:33
INVALID_DIR
@ INVALID_DIR
Flag for an invalid direction.
Definition: direction_type.h:35
Track
Track
These are used to specify a single track.
Definition: track_type.h:19
CanVehicleUseStation
bool CanVehicleUseStation(EngineID engine_type, const Station *st)
Can this station be used by the given engine type?
Definition: vehicle.cpp:2838
Vehicle::HandleBreakdown
bool HandleBreakdown()
Handle all of the aspects of a vehicle breakdown This includes adding smoke and sounds,...
Definition: vehicle.cpp:1297
DecreaseVehicleValue
void DecreaseVehicleValue(Vehicle *v)
Decrease the value of a vehicle.
Definition: vehicle.cpp:1235
GetNewVehiclePosResult::y
int y
x and y position of the vehicle after moving
Definition: vehicle_func.h:76
GetTunnelBridgeTransportType
static TransportType GetTunnelBridgeTransportType(TileIndex t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
Definition: tunnelbridge_map.h:39
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
IsShipDepotTile
static bool IsShipDepotTile(TileIndex t)
Is it a ship depot tile?
Definition: water_map.h:226
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:47
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3248
VehicleSpriteSeq::GetBounds
void GetBounds(Rect *bounds) const
Determine shared bounds of all sprites.
Definition: vehicle.cpp:98
ShipVehicleInfo::ApplyWaterClassSpeedFrac
uint ApplyWaterClassSpeedFrac(uint raw_speed, bool is_ocean) const
Apply ocean/canal speed fraction to a velocity.
Definition: engine_type.h:78
SpecializedVehicle< Ship, VEH_SHIP >::UpdateViewport
void UpdateViewport(bool force_update, bool update_delta)
Update vehicle sprite- and position caches.
Definition: vehicle_base.h:1184
GetEffectiveWaterClass
WaterClass GetEffectiveWaterClass(TileIndex tile)
Determine the effective WaterClass for a ship travelling on a tile.
Definition: ship_cmd.cpp:47
DAY_TICKS
static const int DAY_TICKS
1 day is 74 ticks; _date_fract used to be uint16 and incremented by 885.
Definition: date_type.h:28
EXPENSES_SHIP_RUN
@ EXPENSES_SHIP_RUN
Running costs ships.
Definition: economy_type.h:163
GetDepotIndex
static DepotID GetDepotIndex(TileIndex t)
Get the index of which depot is attached to the tile.
Definition: depot_map.h:52
TrackdirToTrack
static Track TrackdirToTrack(Trackdir trackdir)
Returns the Track that a given Trackdir represents.
Definition: track_func.h:270
Engine::reliability
uint16 reliability
Current reliability of the engine.
Definition: engine_base.h:25
OrthogonalTileArea::Contains
bool Contains(TileIndex tile) const
Does this tile area contain a tile?
Definition: tilearea.cpp:104
Vehicle::refit_cap
uint16 refit_cap
Capacity left over from before last refit.
Definition: vehicle_base.h:317
GetInclinedSlopeDirection
static DiagDirection GetInclinedSlopeDirection(Slope s)
Returns the direction of an inclined slope.
Definition: slope_func.h:239
Vehicle::date_of_last_service
Date date_of_last_service
Last date the vehicle had a service at a depot.
Definition: vehicle_base.h:270
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:1680
news_func.h
VETS_ENTERED_WORMHOLE
@ VETS_ENTERED_WORMHOLE
The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/...
Definition: tile_cmd.h:22
INVALID_TRACK
@ INVALID_TRACK
Flag for an invalid track.
Definition: track_type.h:28