tile_cmd.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#ifndef TILE_CMD_H
#define TILE_CMD_H
 
#include "command_type.h"
#include "vehicle_type.h"
#include "cargo_type.h"
#include "track_type.h"
#include "tile_map.h"
#include "timer/timer_game_calendar.h"
 
enum VehicleEnterTileStatus : uint32_t {
  VETS_ENTERED_STATION  = 1, 
  VETS_ENTERED_WORMHOLE = 2, 
  VETS_CANNOT_ENTER     = 3, 
 
  VETS_STATION_ID_OFFSET = 8,
  VETS_STATION_MASK      = 0xFFFF << VETS_STATION_ID_OFFSET,
 
  VETSB_CONTINUE         = 0,                          
  VETSB_ENTERED_STATION  = 1 << VETS_ENTERED_STATION,  
  VETSB_ENTERED_WORMHOLE = 1 << VETS_ENTERED_WORMHOLE, 
  VETSB_CANNOT_ENTER     = 1 << VETS_CANNOT_ENTER,     
};
DECLARE_ENUM_AS_BIT_SET(VehicleEnterTileStatus)
 
 
struct TileInfo {
  int x;          
  int y;          
  Slope tileh;    
  TileIndex tile; 
  int z;          
};
 
struct TileDesc {
  StringID str{}; 
  uint64_t dparam = 0; 
  std::array<Owner, 4> owner{}; 
  std::array<StringID, 4> owner_type{}; 
  TimerGameCalendar::Date build_date = CalendarTime::INVALID_DATE; 
  StringID station_class{}; 
  StringID station_name{}; 
  StringID airport_class{}; 
  StringID airport_name{}; 
  StringID airport_tile_name{}; 
  const char *grf = nullptr; 
  StringID railtype{}; 
  uint16_t rail_speed = 0; 
  StringID roadtype{}; 
  uint16_t road_speed = 0; 
  StringID tramtype{}; 
  uint16_t tram_speed = 0; 
  std::optional<bool> town_can_upgrade = std::nullopt; 
};
 
typedef void DrawTileProc(TileInfo *ti);
 
typedef int GetSlopeZProc(TileIndex tile, uint x, uint y, bool ground_vehicle);
typedef CommandCost ClearTileProc(TileIndex tile, DoCommandFlags flags);
 
typedef void AddAcceptedCargoProc(TileIndex tile, CargoArray &acceptance, CargoTypes &always_accepted);
 
typedef void GetTileDescProc(TileIndex tile, TileDesc &td);
 
typedef TrackStatus GetTileTrackStatusProc(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side);
 
typedef void AddProducedCargoProc(TileIndex tile, CargoArray &produced);
typedef bool ClickTileProc(TileIndex tile);
typedef void AnimateTileProc(TileIndex tile);
typedef void TileLoopProc(TileIndex tile);
typedef void ChangeTileOwnerProc(TileIndex tile, Owner old_owner, Owner new_owner);
 
typedef VehicleEnterTileStatus VehicleEnterTileProc(Vehicle *v, TileIndex tile, int x, int y);
typedef Foundation GetFoundationProc(TileIndex tile, Slope tileh);
 
typedef CommandCost TerraformTileProc(TileIndex tile, DoCommandFlags flags, int z_new, Slope tileh_new);
 
struct TileTypeProcs {
  DrawTileProc *draw_tile_proc;                  
  GetSlopeZProc *get_slope_z_proc;
  ClearTileProc *clear_tile_proc;
  AddAcceptedCargoProc *add_accepted_cargo_proc; 
  GetTileDescProc *get_tile_desc_proc;           
  GetTileTrackStatusProc *get_tile_track_status_proc; 
  ClickTileProc *click_tile_proc;                
  AnimateTileProc *animate_tile_proc;
  TileLoopProc *tile_loop_proc;
  ChangeTileOwnerProc *change_tile_owner_proc;
  AddProducedCargoProc *add_produced_cargo_proc; 
  VehicleEnterTileProc *vehicle_enter_tile_proc; 
  GetFoundationProc *get_foundation_proc;
  TerraformTileProc *terraform_tile_proc;        
};
 
extern const TileTypeProcs * const _tile_type_procs[16];
 
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side = INVALID_DIAGDIR);
VehicleEnterTileStatus VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y);
void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner);
void GetTileDesc(TileIndex tile, TileDesc &td);
 
inline void AddAcceptedCargo(TileIndex tile, CargoArray &acceptance, CargoTypes *always_accepted)
{
  AddAcceptedCargoProc *proc = _tile_type_procs[GetTileType(tile)]->add_accepted_cargo_proc;
  if (proc == nullptr) return;
  CargoTypes dummy = 0; // use dummy bitmask so there don't need to be several 'always_accepted != nullptr' checks
  proc(tile, acceptance, always_accepted == nullptr ? dummy : *always_accepted);
}
 
inline void AddProducedCargo(TileIndex tile, CargoArray &produced)
{
  AddProducedCargoProc *proc = _tile_type_procs[GetTileType(tile)]->add_produced_cargo_proc;
  if (proc == nullptr) return;
  proc(tile, produced);
}
 
inline bool MayAnimateTile(TileIndex tile)
{
  return _tile_type_procs[GetTileType(tile)]->animate_tile_proc != nullptr;
}
 
inline void AnimateTile(TileIndex tile)
{
  AnimateTileProc *proc = _tile_type_procs[GetTileType(tile)]->animate_tile_proc;
  assert(proc != nullptr);
  proc(tile);
}
 
inline bool ClickTile(TileIndex tile)
{
  ClickTileProc *proc = _tile_type_procs[GetTileType(tile)]->click_tile_proc;
  if (proc == nullptr) return false;
  return proc(tile);
}
 
#endif /* TILE_CMD_H */