← Back to branch summary

~ubuntu-branches/debian/squeeze/openttd/squeeze

« back to all changes in this revision

Viewing changes to src/ai/api/ai_marine.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jordi Mallach, Matthijs Kooijman, Jordi Mallach
  • Date: 2009-04-15 18:22:10 UTC
  • mfrom: (1.1.6 upstream) (2.1.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090415182210-22ktb8kdbp2tf3bm
[ Matthijs Kooijman ]
* New upstream release.
* Remove Debian specific desktop file, upstream provides one now. 
* Add debian/watch file.

[ Jordi Mallach ]
* Bump Standards-Version to 3.8.1, with no changes required.
* Move to debhelper compat 7. Bump Build-Depends accordingly.
* Use dh_prep.
* Add "set -e" to config script.
* Remove a few extra doc files that get installed by upstream Makefile.
* Add more complete copyright information.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ai/api/ai_marine.cpp
 
1
/* $Id: ai_marine.cpp 15491 2009-02-14 21:19:33Z yexo $ */
 
2
 
 
3
/** @file ai_marine.cpp Implementation of AIMarine. */
 
4
 
 
5
#include "ai_marine.hpp"
 
6
#include "ai_station.hpp"
 
7
#include "../../station_map.h"
 
8
#include "../../tile_cmd.h"
 
9
 
 
10
 
 
11
/* static */ bool AIMarine::IsWaterDepotTile(TileIndex tile)
 
12
{
 
13
        if (!::IsValidTile(tile)) return false;
 
14
 
 
15
        return ::IsTileType(tile, MP_WATER) && ::GetWaterTileType(tile) == WATER_TILE_DEPOT;
 
16
}
 
17
 
 
18
/* static */ bool AIMarine::IsDockTile(TileIndex tile)
 
19
{
 
20
        if (!::IsValidTile(tile)) return false;
 
21
 
 
22
        return ::IsTileType(tile, MP_STATION) && ::IsDock(tile);
 
23
}
 
24
 
 
25
/* static */ bool AIMarine::IsBuoyTile(TileIndex tile)
 
26
{
 
27
        if (!::IsValidTile(tile)) return false;
 
28
 
 
29
        return ::IsTileType(tile, MP_STATION) && ::IsBuoy(tile);
 
30
}
 
31
 
 
32
/* static */ bool AIMarine::IsLockTile(TileIndex tile)
 
33
{
 
34
        if (!::IsValidTile(tile)) return false;
 
35
 
 
36
        return ::IsTileType(tile, MP_WATER) && ::GetWaterTileType(tile) == WATER_TILE_LOCK;
 
37
}
 
38
 
 
39
/* static */ bool AIMarine::IsCanalTile(TileIndex tile)
 
40
{
 
41
        if (!::IsValidTile(tile)) return false;
 
42
 
 
43
        return ::IsTileType(tile, MP_WATER) && ::IsCanal(tile);
 
44
}
 
45
 
 
46
/* static */ bool AIMarine::AreWaterTilesConnected(TileIndex t1, TileIndex t2)
 
47
{
 
48
        if (!::IsValidTile(t1)) return false;
 
49
        if (!::IsValidTile(t2)) return false;
 
50
 
 
51
        /* Tiles not neighbouring */
 
52
        if (::DistanceManhattan(t1, t2) != 1) return false;
 
53
        if (t1 > t2) Swap(t1, t2);
 
54
 
 
55
        DiagDirection to_other_tile = (TileX(t1) == TileX(t2)) ? DIAGDIR_SE : DIAGDIR_SW;
 
56
 
 
57
        /* Determine the reachable tracks from the shared edge */
 
58
        TrackBits gtts2 = ::TrackStatusToTrackBits(::GetTileTrackStatus(t2, TRANSPORT_WATER, 0, to_other_tile)) & ::DiagdirReachesTracks(to_other_tile);
 
59
        if (gtts2 == TRACK_BIT_NONE) return false;
 
60
 
 
61
        to_other_tile = ReverseDiagDir(to_other_tile);
 
62
        TrackBits gtts1 = ::TrackStatusToTrackBits(::GetTileTrackStatus(t1, TRANSPORT_WATER, 0, to_other_tile)) & ::DiagdirReachesTracks(to_other_tile);
 
63
 
 
64
        return gtts1 != TRACK_BIT_NONE;
 
65
}
 
66
 
 
67
/* static */ bool AIMarine::BuildWaterDepot(TileIndex tile, TileIndex front)
 
68
{
 
69
        EnforcePrecondition(false, ::IsValidTile(tile));
 
70
        EnforcePrecondition(false, ::IsValidTile(front));
 
71
        EnforcePrecondition(false, (::TileX(front) == ::TileX(tile)) != (::TileY(front) == ::TileY(tile)));
 
72
 
 
73
        return AIObject::DoCommand(tile, ::TileY(front) == ::TileY(tile), 0, CMD_BUILD_SHIP_DEPOT);
 
74
}
 
75
 
 
76
/* static */ bool AIMarine::BuildDock(TileIndex tile, StationID station_id)
 
77
{
 
78
        EnforcePrecondition(false, ::IsValidTile(tile));
 
79
        EnforcePrecondition(false, station_id == AIStation::STATION_NEW || station_id == AIStation::STATION_JOIN_ADJACENT || AIStation::IsValidStation(station_id));
 
80
 
 
81
        uint p1 = station_id == AIStation::STATION_JOIN_ADJACENT ? 0 : 1;
 
82
        uint p2 = (AIStation::IsValidStation(station_id) ? station_id : INVALID_STATION) << 16;
 
83
        return AIObject::DoCommand(tile, p1, p2, CMD_BUILD_DOCK);
 
84
}
 
85
 
 
86
/* static */ bool AIMarine::BuildBuoy(TileIndex tile)
 
87
{
 
88
        EnforcePrecondition(false, ::IsValidTile(tile));
 
89
 
 
90
        return AIObject::DoCommand(tile, 0, 0, CMD_BUILD_BUOY);
 
91
}
 
92
 
 
93
/* static */ bool AIMarine::BuildLock(TileIndex tile)
 
94
{
 
95
        EnforcePrecondition(false, ::IsValidTile(tile));
 
96
 
 
97
        return AIObject::DoCommand(tile, 0, 0, CMD_BUILD_LOCK);
 
98
}
 
99
 
 
100
/* static */ bool AIMarine::BuildCanal(TileIndex tile)
 
101
{
 
102
        EnforcePrecondition(false, ::IsValidTile(tile));
 
103
 
 
104
        return AIObject::DoCommand(tile, tile, 0, CMD_BUILD_CANAL);
 
105
}
 
106
 
 
107
/* static */ bool AIMarine::RemoveWaterDepot(TileIndex tile)
 
108
{
 
109
        EnforcePrecondition(false, ::IsValidTile(tile));
 
110
        EnforcePrecondition(false, IsWaterDepotTile(tile));
 
111
 
 
112
        return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR);
 
113
}
 
114
 
 
115
/* static */ bool AIMarine::RemoveDock(TileIndex tile)
 
116
{
 
117
        EnforcePrecondition(false, ::IsValidTile(tile));
 
118
        EnforcePrecondition(false, IsDockTile(tile));
 
119
 
 
120
        return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR);
 
121
}
 
122
 
 
123
/* static */ bool AIMarine::RemoveBuoy(TileIndex tile)
 
124
{
 
125
        EnforcePrecondition(false, ::IsValidTile(tile));
 
126
        EnforcePrecondition(false, IsBuoyTile(tile));
 
127
 
 
128
        return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR);
 
129
}
 
130
 
 
131
/* static */ bool AIMarine::RemoveLock(TileIndex tile)
 
132
{
 
133
        EnforcePrecondition(false, ::IsValidTile(tile));
 
134
        EnforcePrecondition(false, IsLockTile(tile));
 
135
 
 
136
        return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR);
 
137
}
 
138
 
 
139
/* static */ bool AIMarine::RemoveCanal(TileIndex tile)
 
140
{
 
141
        EnforcePrecondition(false, ::IsValidTile(tile));
 
142
        EnforcePrecondition(false, IsCanalTile(tile));
 
143
 
 
144
        return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR);
 
145
}