water_map.h

Go to the documentation of this file.
00001 /* $Id$ */
00002 
00003 /*
00004  * This file is part of OpenTTD.
00005  * 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.
00006  * 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.
00007  * 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/>.
00008  */
00009 
00012 #ifndef WATER_MAP_H
00013 #define WATER_MAP_H
00014 
00015 #include "depot_type.h"
00016 #include "tile_map.h"
00017 
00019 enum WaterTileType {
00020   WATER_TILE_CLEAR, 
00021   WATER_TILE_COAST, 
00022   WATER_TILE_LOCK,  
00023   WATER_TILE_DEPOT, 
00024 };
00025 
00027 enum WaterClass {
00028   WATER_CLASS_SEA,     
00029   WATER_CLASS_CANAL,   
00030   WATER_CLASS_RIVER,   
00031   WATER_CLASS_INVALID, 
00032 };
00034 template <> struct EnumPropsT<WaterClass> : MakeEnumPropsT<WaterClass, byte, WATER_CLASS_SEA, WATER_CLASS_INVALID, WATER_CLASS_INVALID, 2> {};
00035 
00037 enum DepotPart {
00038   DEPOT_NORTH = 0x80,
00039   DEPOT_SOUTH = 0x81,
00040   DEPOT_END   = 0x84,
00041 };
00042 
00044 enum LockPart {
00045   LOCK_MIDDLE = 0x10,
00046   LOCK_LOWER  = 0x14,
00047   LOCK_UPPER  = 0x18,
00048   LOCK_END    = 0x1C
00049 };
00050 
00056 static inline WaterTileType GetWaterTileType(TileIndex t)
00057 {
00058   assert(IsTileType(t, MP_WATER));
00059 
00060   if (_m[t].m5 == 0) return WATER_TILE_CLEAR;
00061   if (_m[t].m5 == 1) return WATER_TILE_COAST;
00062   if (IsInsideMM(_m[t].m5, LOCK_MIDDLE, LOCK_END)) return WATER_TILE_LOCK;
00063 
00064   assert(IsInsideMM(_m[t].m5, DEPOT_NORTH, DEPOT_END));
00065   return WATER_TILE_DEPOT;
00066 }
00067 
00074 static inline bool HasTileWaterClass(TileIndex t)
00075 {
00076   return IsTileType(t, MP_WATER) || IsTileType(t, MP_STATION) || IsTileType(t, MP_INDUSTRY) || IsTileType(t, MP_OBJECT);
00077 }
00078 
00085 static inline WaterClass GetWaterClass(TileIndex t)
00086 {
00087   assert(HasTileWaterClass(t));
00088   return (WaterClass)GB(_m[t].m1, 5, 2);
00089 }
00090 
00097 static inline void SetWaterClass(TileIndex t, WaterClass wc)
00098 {
00099   assert(HasTileWaterClass(t));
00100   SB(_m[t].m1, 5, 2, wc);
00101 }
00102 
00109 static inline bool IsTileOnWater(TileIndex t)
00110 {
00111   return (GetWaterClass(t) != WATER_CLASS_INVALID);
00112 }
00113 
00119 static inline bool IsWater(TileIndex t)
00120 {
00121   return GetWaterTileType(t) == WATER_TILE_CLEAR;
00122 }
00123 
00129 static inline bool IsSea(TileIndex t)
00130 {
00131   return IsWater(t) && GetWaterClass(t) == WATER_CLASS_SEA;
00132 }
00133 
00139 static inline bool IsCanal(TileIndex t)
00140 {
00141   return IsWater(t) && GetWaterClass(t) == WATER_CLASS_CANAL;
00142 }
00143 
00149 static inline bool IsRiver(TileIndex t)
00150 {
00151   return IsWater(t) && GetWaterClass(t) == WATER_CLASS_RIVER;
00152 }
00153 
00159 static inline bool IsWaterTile(TileIndex t)
00160 {
00161   return IsTileType(t, MP_WATER) && IsWater(t);
00162 }
00163 
00169 static inline bool IsCoast(TileIndex t)
00170 {
00171   return GetWaterTileType(t) == WATER_TILE_COAST;
00172 }
00173 
00179 static inline bool IsCoastTile(TileIndex t)
00180 {
00181   return IsTileType(t, MP_WATER) && IsCoast(t);
00182 }
00183 
00189 static inline TileIndex GetOtherShipDepotTile(TileIndex t)
00190 {
00191   return t + (HasBit(_m[t].m5, 0) ? -1 : 1) * (HasBit(_m[t].m5, 1) ? TileDiffXY(0, 1) : TileDiffXY(1, 0));
00192 }
00193 
00199 static inline bool IsShipDepot(TileIndex t)
00200 {
00201   return IsInsideMM(_m[t].m5, DEPOT_NORTH, DEPOT_END);
00202 }
00203 
00209 static inline bool IsShipDepotTile(TileIndex t)
00210 {
00211   return IsTileType(t, MP_WATER) && IsShipDepot(t);
00212 }
00213 
00219 static inline Axis GetShipDepotAxis(TileIndex t)
00220 {
00221   return (Axis)GB(_m[t].m5, 1, 1);
00222 }
00223 
00229 static inline DiagDirection GetShipDepotDirection(TileIndex t)
00230 {
00231   return XYNSToDiagDir(GetShipDepotAxis(t), GB(_m[t].m5, 0, 1));
00232 }
00233 
00239 static inline TileIndex GetShipDepotNorthTile(TileIndex t)
00240 {
00241   assert(IsShipDepot(t));
00242   TileIndex tile2 = GetOtherShipDepotTile(t);
00243 
00244   return t < tile2 ? t : tile2;
00245 }
00246 
00252 static inline bool IsLock(TileIndex t)
00253 {
00254   return IsInsideMM(_m[t].m5, LOCK_MIDDLE, LOCK_END);
00255 }
00256 
00262 static inline DiagDirection GetLockDirection(TileIndex t)
00263 {
00264   return (DiagDirection)GB(_m[t].m5, 0, 2);
00265 }
00266 
00272 static inline byte GetSection(TileIndex t)
00273 {
00274   assert(GetWaterTileType(t) == WATER_TILE_LOCK || GetWaterTileType(t) == WATER_TILE_DEPOT);
00275   return GB(_m[t].m5, 0, 4);
00276 }
00277 
00283 static inline byte GetWaterTileRandomBits(TileIndex t)
00284 {
00285   return _m[t].m4;
00286 }
00287 
00294 static inline bool HasTileWaterGround(TileIndex t)
00295 {
00296   return HasTileWaterClass(t) && IsTileOnWater(t) && !IsCoastTile(t);
00297 }
00298 
00299 
00304 static inline void MakeShore(TileIndex t)
00305 {
00306   SetTileType(t, MP_WATER);
00307   SetTileOwner(t, OWNER_WATER);
00308   SetWaterClass(t, WATER_CLASS_SEA);
00309   _m[t].m2 = 0;
00310   _m[t].m3 = 0;
00311   _m[t].m4 = 0;
00312   _m[t].m5 = 1;
00313   SB(_m[t].m6, 2, 4, 0);
00314   _me[t].m7 = 0;
00315 }
00316 
00324 static inline void MakeWater(TileIndex t, Owner o, WaterClass wc, uint8 random_bits)
00325 {
00326   SetTileType(t, MP_WATER);
00327   SetTileOwner(t, o);
00328   SetWaterClass(t, wc);
00329   _m[t].m2 = 0;
00330   _m[t].m3 = 0;
00331   _m[t].m4 = random_bits;
00332   _m[t].m5 = 0;
00333   SB(_m[t].m6, 2, 4, 0);
00334   _me[t].m7 = 0;
00335 }
00336 
00341 static inline void MakeSea(TileIndex t)
00342 {
00343   MakeWater(t, OWNER_WATER, WATER_CLASS_SEA, 0);
00344 }
00345 
00351 static inline void MakeRiver(TileIndex t, uint8 random_bits)
00352 {
00353   MakeWater(t, OWNER_WATER, WATER_CLASS_RIVER, random_bits);
00354 }
00355 
00362 static inline void MakeCanal(TileIndex t, Owner o, uint8 random_bits)
00363 {
00364   assert(o != OWNER_WATER);
00365   MakeWater(t, o, WATER_CLASS_CANAL, random_bits);
00366 }
00367 
00377 static inline void MakeShipDepot(TileIndex t, Owner o, DepotID did, DepotPart base, Axis a, WaterClass original_water_class)
00378 {
00379   SetTileType(t, MP_WATER);
00380   SetTileOwner(t, o);
00381   SetWaterClass(t, original_water_class);
00382   _m[t].m2 = did;
00383   _m[t].m3 = 0;
00384   _m[t].m4 = 0;
00385   _m[t].m5 = base + a * 2;
00386   SB(_m[t].m6, 2, 4, 0);
00387   _me[t].m7 = 0;
00388 }
00389 
00398 static inline void MakeLockTile(TileIndex t, Owner o, byte section, WaterClass original_water_class)
00399 {
00400   SetTileType(t, MP_WATER);
00401   SetTileOwner(t, o);
00402   SetWaterClass(t, original_water_class);
00403   _m[t].m2 = 0;
00404   _m[t].m3 = 0;
00405   _m[t].m4 = 0;
00406   _m[t].m5 = section;
00407   SB(_m[t].m6, 2, 4, 0);
00408   _me[t].m7 = 0;
00409 }
00410 
00419 static inline void MakeLock(TileIndex t, Owner o, DiagDirection d, WaterClass wc_lower, WaterClass wc_upper)
00420 {
00421   TileIndexDiff delta = TileOffsByDiagDir(d);
00422 
00423   MakeLockTile(t, o, LOCK_MIDDLE + d, WATER_CLASS_CANAL);
00424   MakeLockTile(t - delta, o, LOCK_LOWER + d, wc_lower);
00425   MakeLockTile(t + delta, o, LOCK_UPPER + d, wc_upper);
00426 }
00427 
00428 #endif /* WATER_MAP_H */

Generated on Sun Jun 5 04:20:07 2011 for OpenTTD by  doxygen 1.6.1