_________ __                 __
        /   _____//  |_____________ _/  |______     ____  __ __  ______
        \_____  \\   __\_  __ \__  \\   __\__  \   / ___\|  |  \/  ___/
        /        \|  |  |  | \// __ \|  |  / __ \_/ /_/  >  |  /\___ \
       /_______  /|__|  |__|  (____  /__| (____  /\___  /|____//____  >
               \/                  \/          \//_____/            \/
    ______________________                           ______________________
                          T H E   W A R   B E G I N S
                   Stratagus - A free fantasy real time strategy game engine

unit_find.h
Go to the documentation of this file.
1 // _________ __ __
2 // / _____// |_____________ _/ |______ ____ __ __ ______
3 // \_____ \\ __\_ __ \__ \\ __\__ \ / ___\| | \/ ___/
4 // / \| | | | \// __ \| | / __ \_/ /_/ > | /\___ |
5 // /_______ /|__| |__| (____ /__| (____ /\___ /|____//____ >
6 // \/ \/ \//_____/ \/
7 // ______________________ ______________________
8 // T H E W A R B E G I N S
9 // Stratagus - A free fantasy real time strategy game engine
10 //
12 //
13 // (c) Copyright 1998-2015 by Lutz Sammer, Jimmy Salmon, Joris Dauphin
14 // and Andrettin
15 //
16 // This program is free software; you can redistribute it and/or modify
17 // it under the terms of the GNU General Public License as published by
18 // the Free Software Foundation; only version 2 of the License.
19 //
20 // This program is distributed in the hope that it will be useful,
21 // but WITHOUT ANY WARRANTY; without even the implied warranty of
22 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 // GNU General Public License for more details.
24 //
25 // You should have received a copy of the GNU General Public License
26 // along with this program; if not, write to the Free Software
27 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
28 // 02111-1307, USA.
29 //
30 
31 #ifndef __UNIT_FIND_H__
32 #define __UNIT_FIND_H__
33 
35 
36 #include "map.h"
37 #include "pathfinder.h"
38 #include "unit.h"
39 #include "unittype.h"
40 
41 /*----------------------------------------------------------------------------
42 -- Declarations
43 ----------------------------------------------------------------------------*/
44 
45 //
46 // Some predicates
47 //
48 
50 {
51 public:
52  bool operator()(const CUnit *unit) const { return true; };
53 };
54 
55 class NoFilter : public CUnitFilter
56 {
57 public:
58  bool operator()(const CUnit *) const { return true; }
59 };
60 
61 class HasSameTypeAs : public CUnitFilter
62 {
63 public:
64  explicit HasSameTypeAs(const CUnitType &_type) : type(&_type) {}
65  bool operator()(const CUnit *unit) const { return unit->Type == type; }
66 private:
67  const CUnitType *type;
68 };
69 
71 {
72 public:
73  explicit HasSamePlayerAs(const CPlayer &_player) : player(&_player) {}
74  bool operator()(const CUnit *unit) const { return unit->Player == player; }
75 private:
76  const CPlayer *player;
77 };
78 
80 {
81 public:
82  explicit HasNotSamePlayerAs(const CPlayer &_player) : player(&_player) {}
83  bool operator()(const CUnit *unit) const { return unit->Player != player; }
84 private:
85  const CPlayer *player;
86 };
87 
88 class IsAlliedWith : public CUnitFilter
89 {
90 public:
91  explicit IsAlliedWith(const CPlayer &_player) : player(&_player) {}
92  bool operator()(const CUnit *unit) const { return unit->IsAllied(*player); }
93 private:
94  const CPlayer *player;
95 };
96 
97 class IsEnemyWith : public CUnitFilter
98 {
99 public:
100  explicit IsEnemyWith(const CPlayer &_player) : player(&_player) {}
101  bool operator()(const CUnit *unit) const { return unit->IsEnemy(*player); }
102 private:
103  const CPlayer *player;
104 };
105 
107 {
108 public:
109  explicit HasSamePlayerAndTypeAs(const CUnit &unit) :
110  player(unit.Player), type(unit.Type)
111  {}
112  HasSamePlayerAndTypeAs(const CPlayer &_player, const CUnitType &_type) :
113  player(&_player), type(&_type)
114  {}
115 
116  bool operator()(const CUnit *unit) const
117  {
118  return (unit->Player == player && unit->Type == type);
119  }
120 
121 private:
122  const CPlayer *player;
123  const CUnitType *type;
124 };
125 
127 {
128 public:
129  explicit IsNotTheSameUnitAs(const CUnit &unit) : forbidden(&unit) {}
130  bool operator()(const CUnit *unit) const { return unit != forbidden; }
131 private:
132  const CUnit *forbidden;
133 };
134 
136 {
137 public:
138  bool operator()(const CUnit *unit) const { return unit->Type->Building; }
139 };
140 
142 {
143 public:
144  bool operator()(const CUnit *unit) const { return unit->IsAgressive(); }
145 };
146 
148 {
149 public:
150  explicit OutOfMinRange(const int range, const Vec2i pos) : range(range), pos(pos) {}
151  bool operator()(const CUnit *unit) const { return unit->MapDistanceTo(pos) >= range; }
152 private:
153  int range;
154  Vec2i pos;
155 };
156 
157 
158 template <typename Pred>
159 class NotPredicate : public CUnitFilter
160 {
161 public:
162  explicit NotPredicate(Pred _pred) : pred(_pred) {}
163  bool operator()(const CUnit *unit) const { return pred(unit) == false; }
164 private:
165  Pred pred;
166 };
167 
168 template <typename Pred>
170 
171 template <typename Pred1, typename Pred2>
172 class AndPredicate : public CUnitFilter
173 {
174 public:
175  AndPredicate(Pred1 _pred1, Pred2 _pred2) : pred1(_pred1), pred2(_pred2) {}
176  bool operator()(const CUnit *unit) const { return pred1(unit) && pred2(unit); }
177 private:
178  Pred1 pred1;
179  Pred2 pred2;
180 };
181 
182 template <typename Pred1, typename Pred2>
183 AndPredicate<Pred1, Pred2> MakeAndPredicate(Pred1 pred1, Pred2 pred2) { return AndPredicate<Pred1, Pred2>(pred1, pred2); }
184 
185 
186 //unit_find
188 {
189 public:
190  explicit CUnitTypeFinder(const UnitTypeType t) : unitTypeType(t) {}
191  bool operator()(const CUnit *const unit) const
192  {
193  const CUnitType &type = *unit->Type;
194  if (type.BoolFlag[VANISHES_INDEX].value || (unitTypeType != static_cast<UnitTypeType>(-1) && type.UnitType != unitTypeType)) {
195  return false;
196  }
197  return true;
198  }
199 private:
200  const UnitTypeType unitTypeType;
201 };
202 
203 
205 {
206 public:
207  UnitFinder(const CPlayer &player, const std::vector<CUnit *> &units, int maxDist, int movemask, CUnit **unitP) :
208  player(player), units(units), maxDist(maxDist), movemask(movemask), unitP(unitP) {}
209  VisitResult Visit(TerrainTraversal &terrainTraversal, const Vec2i &pos, const Vec2i &from);
210 private:
211  CUnit *FindUnitAtPos(const Vec2i &pos) const;
212 private:
213  const CPlayer &player;
214  const std::vector<CUnit *> &units;
215  int maxDist;
216  int movemask;
217  CUnit **unitP;
218 };
219 
220 void Select(const Vec2i &ltPos, const Vec2i &rbPos, std::vector<CUnit *> &units);
221 void SelectFixed(const Vec2i &ltPos, const Vec2i &rbPos, std::vector<CUnit *> &units);
222 void SelectAroundUnit(const CUnit &unit, int range, std::vector<CUnit *> &around);
223 
224 template <int selectMax = 0, typename Pred>
225 void SelectFixed(const Vec2i &ltPos, const Vec2i &rbPos, std::vector<CUnit *> &units, Pred pred)
226 {
227  Assert(Map.Info.IsPointOnMap(ltPos));
228  Assert(Map.Info.IsPointOnMap(rbPos));
229  Assert(units.empty());
230  units.reserve(selectMax << 1);
231  int max = selectMax || INT_MAX;
232 
233  for (Vec2i posIt = ltPos; posIt.y != rbPos.y + 1; ++posIt.y) {
234  for (posIt.x = ltPos.x; posIt.x != rbPos.x + 1; ++posIt.x) {
235  const CMapField &mf = *Map.Field(posIt);
236  const CUnitCache &cache = mf.UnitCache;
237 
238  for (size_t i = 0; i != cache.size(); ++i) {
239  CUnit &unit = *cache[i];
240 
241  if ((selectMax == 1 || unit.CacheLock == 0) && pred(&unit)) {
242  if (selectMax == 1) {
243  units.push_back(&unit);
244  return;
245  } else {
246  unit.CacheLock = 1;
247  units.push_back(&unit);
248  if (--max == 0) {
249  break;
250  }
251  }
252  }
253  }
254  }
255  }
256  for (size_t i = 0; i != units.size(); ++i) {
257  units[i]->CacheLock = 0;
258  }
259 }
260 
261 template <int selectMax = 0, typename Pred>
262 void Select(const Vec2i &ltPos, const Vec2i &rbPos, std::vector<CUnit *> &units, Pred pred)
263 {
264  Vec2i minPos = ltPos;
265  Vec2i maxPos = rbPos;
266 
267  Map.FixSelectionArea(minPos, maxPos);
268  SelectFixed<selectMax>(minPos, maxPos, units, pred);
269 }
270 
271 template <int selectMax = 0, typename Pred>
272 void SelectAroundUnit(const CUnit &unit, int range, std::vector<CUnit *> &around, Pred pred)
273 {
274  const Vec2i offset(range, range);
275  const Vec2i typeSize(unit.Type->TileWidth - 1, unit.Type->TileHeight - 1);
276 
277  Select<selectMax>(unit.tilePos - offset,
278  unit.tilePos + typeSize + offset, around,
279  MakeAndPredicate(IsNotTheSameUnitAs(unit), pred));
280 }
281 
282 template <typename Pred>
283 CUnit *FindUnit_IfFixed(const Vec2i &ltPos, const Vec2i &rbPos, Pred pred)
284 {
285  Assert(Map.Info.IsPointOnMap(ltPos));
286  Assert(Map.Info.IsPointOnMap(rbPos));
287 
288  for (Vec2i posIt = ltPos; posIt.y != rbPos.y + 1; ++posIt.y) {
289  for (posIt.x = ltPos.x; posIt.x != rbPos.x + 1; ++posIt.x) {
290  const CMapField &mf = *Map.Field(posIt);
291  const CUnitCache &cache = mf.UnitCache;
292 
293  CUnitCache::const_iterator it = std::find_if(cache.begin(), cache.end(), pred);
294  if (it != cache.end()) {
295  return *it;
296  }
297  }
298  }
299  return NULL;
300 }
301 
302 template <typename Pred>
303 CUnit *FindUnit_If(const Vec2i &ltPos, const Vec2i &rbPos, Pred pred)
304 {
305  Vec2i minPos = ltPos;
306  Vec2i maxPos = rbPos;
307 
308  Map.FixSelectionArea(minPos, maxPos);
309  return FindUnit_IfFixed(minPos, maxPos, pred);
310 }
311 
313 extern CUnit *UnitFindResource(const CUnit &unit, const CUnit &startUnit, int range,
314  int resource, bool check_usage = false, const CUnit *deposit = NULL);
315 
317 extern CUnit *FindDeposit(const CUnit &unit, int range, int resource);
319 extern CUnit *FindIdleWorker(const CPlayer &player, const CUnit *last);
320 
322 extern bool FindTerrainType(int movemask, int resmask, int range,
323  const CPlayer &player, const Vec2i &startPos, Vec2i *pos);
324 
325 extern void FindUnitsByType(const CUnitType &type, std::vector<CUnit *> &units, bool everybody = false);
326 
328 extern void FindPlayerUnitsByType(const CPlayer &player, const CUnitType &type, std::vector<CUnit *> &units, bool ai_active = false);
330 extern CUnit *UnitOnMapTile(const Vec2i &pos, unsigned int type);// = -1);
332 extern CUnit *TargetOnMap(const CUnit &unit, const Vec2i &pos1, const Vec2i &pos2);
333 
335 extern CUnit *ResourceOnMap(const Vec2i &pos, int resource, bool mine_on_top = true);
337 extern CUnit *ResourceDepositOnMap(const Vec2i &pos, int resource);
338 
340 extern bool CheckObstaclesBetweenTiles(const Vec2i &unitPos, const Vec2i &goalPos, unsigned short flags, int *distance = NULL);
342 extern CUnit *AttackUnitsInDistance(const CUnit &unit, int range, CUnitFilter pred);
343 extern CUnit *AttackUnitsInDistance(const CUnit &unit, int range);
345 extern CUnit *AttackUnitsInRange(const CUnit &unit, CUnitFilter pred);
346 extern CUnit *AttackUnitsInRange(const CUnit &unit);
348 extern CUnit *AttackUnitsInReactRange(const CUnit &unit, CUnitFilter pred);
349 extern CUnit *AttackUnitsInReactRange(const CUnit &unit);
350 
351 
352 
354 
355 #endif // !__UNIT_FIND_H__
CPlayer
Diplomacy states for CommandDiplomacy.
Definition: player.h:83
IsEnemyWith::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:101
CUnitCache::end
const_iterator end() const
Definition: unit_cache.h:65
FindUnitsByType
void FindUnitsByType(const CUnitType &type, std::vector< CUnit * > &units, bool everybody=false)
Definition: unit_find.cpp:516
OutOfMinRange::OutOfMinRange
OutOfMinRange(const int range, const Vec2i pos)
Definition: unit_find.h:150
UnitFinder
Definition: unit_find.h:204
unit.h
HasSamePlayerAndTypeAs::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:116
AttackUnitsInDistance
CUnit * AttackUnitsInDistance(const CUnit &unit, int range, CUnitFilter pred)
Find best enemy in numeric range to attack.
Definition: unit_find.cpp:1147
IsBuildingType::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:138
MakeNotPredicate
NotPredicate< Pred > MakeNotPredicate(Pred pred)
Definition: unit_find.h:169
CUnitCache
Definition: unit_cache.h:50
SelectFixed
void SelectFixed(const Vec2i &ltPos, const Vec2i &rbPos, std::vector< CUnit * > &units)
Definition: unit_find.cpp:62
CUnitType::BoolFlag
std::vector< BoolFlags > BoolFlag
Definition: unittype.h:646
CUnit::CacheLock
unsigned CacheLock
Unit is on board a transporter.
Definition: unit.h:380
VANISHES_INDEX
@ VANISHES_INDEX
Can attack from transporter.
Definition: unittype.h:155
IsNotTheSameUnitAs
Definition: unit_find.h:126
IsAggresiveUnit::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:144
NoFilter
Definition: unit_find.h:55
IsEnemyWith::IsEnemyWith
IsEnemyWith(const CPlayer &_player)
Definition: unit_find.h:100
IsAggresiveUnit
Definition: unit_find.h:141
CUnitTypeFinder::CUnitTypeFinder
CUnitTypeFinder(const UnitTypeType t)
Definition: unit_find.h:190
Vec2T::y
T y
Definition: vec2i.h:43
IsNotTheSameUnitAs::IsNotTheSameUnitAs
IsNotTheSameUnitAs(const CUnit &unit)
Definition: unit_find.h:129
OutOfMinRange
Definition: unit_find.h:147
IsEnemyWith
Definition: unit_find.h:97
CheckObstaclesBetweenTiles
bool CheckObstaclesBetweenTiles(const Vec2i &unitPos, const Vec2i &goalPos, unsigned short flags, int *distance=NULL)
Check map for obstacles in a line between 2 tiles.
Definition: unit_find.cpp:1103
VisitResult
VisitResult
Definition: pathfinder.h:127
HasSameTypeAs::HasSameTypeAs
HasSameTypeAs(const CUnitType &_type)
Definition: unit_find.h:64
FindUnit_IfFixed
CUnit * FindUnit_IfFixed(const Vec2i &ltPos, const Vec2i &rbPos, Pred pred)
Definition: unit_find.h:283
CUnitType
Definition: unittype.h:508
UnitOnMapTile
CUnit * UnitOnMapTile(const Vec2i &pos, unsigned int type)
Return any unit on that map tile.
Definition: unit_find.cpp:588
UnitFindResource
CUnit * UnitFindResource(const CUnit &unit, const CUnit &startUnit, int range, int resource, bool check_usage=false, const CUnit *deposit=NULL)
Find resource.
Definition: unit_find.cpp:423
AndPredicate::AndPredicate
AndPredicate(Pred1 _pred1, Pred2 _pred2)
Definition: unit_find.h:175
CUnit::IsAllied
bool IsAllied(const CPlayer &player) const
Definition: unit.cpp:3401
CUnitFilter
Definition: unit_find.h:49
Vec2T< short int >
CUnitTypeFinder::operator()
bool operator()(const CUnit *const unit) const
Definition: unit_find.h:191
NotPredicate::NotPredicate
NotPredicate(Pred _pred)
Definition: unit_find.h:162
HasSamePlayerAs
Definition: unit_find.h:70
CUnit::tilePos
Vec2i tilePos
Resource still.
Definition: unit.h:341
UnitFinder::UnitFinder
UnitFinder(const CPlayer &player, const std::vector< CUnit * > &units, int maxDist, int movemask, CUnit **unitP)
Definition: unit_find.h:207
UnitTypeType
UnitTypeType
Definition: unittype.h:362
pathfinder.h
CMap::Field
CMapField * Field(unsigned int index) const
Definition: map.h:171
HasSamePlayerAndTypeAs::HasSamePlayerAndTypeAs
HasSamePlayerAndTypeAs(const CUnit &unit)
Definition: unit_find.h:109
CUnit::IsEnemy
bool IsEnemy(const CPlayer &player) const
Definition: unit.cpp:3381
FindIdleWorker
CUnit * FindIdleWorker(const CPlayer &player, const CUnit *last)
Find the next idle worker.
Definition: unit_find.cpp:481
HasSamePlayerAs::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:74
NoFilter::operator()
bool operator()(const CUnit *) const
Definition: unit_find.h:58
FindDeposit
CUnit * FindDeposit(const CUnit &unit, int range, int resource)
Find nearest deposit.
Definition: unit_find.cpp:456
IsNotTheSameUnitAs::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:130
IsBuildingType
Definition: unit_find.h:135
Select
void Select(const Vec2i &ltPos, const Vec2i &rbPos, std::vector< CUnit * > &units)
Definition: unit_find.cpp:57
IsAlliedWith
Definition: unit_find.h:88
CUnitCache::const_iterator
std::vector< CUnit * >::const_iterator const_iterator
Definition: unit_cache.h:54
CMapField::UnitCache
CUnitCache UnitCache
HP for walls/Wood Regeneration, value of stored resource for forest or harvestable terrain.
Definition: tile.h:253
HasSameTypeAs
Definition: unit_find.h:61
TerrainTraversal
Definition: pathfinder.h:134
CUnit::IsAgressive
bool IsAgressive() const
Definition: unit.h:187
CUnitType::Building
unsigned Building
Death explosion animated.
Definition: unittype.h:631
CUnit::Player
CPlayer * Player
Pointer to unit-type (peon,...)
Definition: unit.h:346
map.h
TargetOnMap
CUnit * TargetOnMap(const CUnit &unit, const Vec2i &pos1, const Vec2i &pos2)
Return possible attack target on that map area.
Definition: unit_find.cpp:602
CUnitCache::size
size_t size() const
Definition: unit_cache.h:59
HasSamePlayerAndTypeAs
Definition: unit_find.h:106
FindPlayerUnitsByType
void FindPlayerUnitsByType(const CPlayer &player, const CUnitType &type, std::vector< CUnit * > &units, bool ai_active=false)
Find all units of this type of the player.
Definition: unit_find.cpp:534
CUnitType::TileHeight
int TileHeight
Tile size on map width.
Definition: unittype.h:585
SelectAroundUnit
void SelectAroundUnit(const CUnit &unit, int range, std::vector< CUnit * > &around)
Definition: unit_find.cpp:67
IsAlliedWith::IsAlliedWith
IsAlliedWith(const CPlayer &_player)
Definition: unit_find.h:91
CUnit::MapDistanceTo
int MapDistanceTo(const CUnit &dst) const
Definition: unit.h:286
HasNotSamePlayerAs
Definition: unit_find.h:79
HasSamePlayerAs::HasSamePlayerAs
HasSamePlayerAs(const CPlayer &_player)
Definition: unit_find.h:73
NotPredicate
Definition: unit_find.h:159
IsAlliedWith::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:92
UnitFinder::Visit
VisitResult Visit(TerrainTraversal &terrainTraversal, const Vec2i &pos, const Vec2i &from)
Definition: unit_find.cpp:86
MakeAndPredicate
AndPredicate< Pred1, Pred2 > MakeAndPredicate(Pred1 pred1, Pred2 pred2)
Definition: unit_find.h:183
CUnit::Type
const CUnitType * Type
Map position as flat index offset (x + y * w)
Definition: unit.h:345
HasNotSamePlayerAs::HasNotSamePlayerAs
HasNotSamePlayerAs(const CPlayer &_player)
Definition: unit_find.h:82
OutOfMinRange::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:151
CUnitTypeFinder
Definition: unit_find.h:187
Assert
#define Assert(cond)
Definition: stratagus.h:142
CMap::Info
CMapInfo Info
Definition: map.h:276
CMapInfo::IsPointOnMap
bool IsPointOnMap(int x, int y) const
Definition: map.h:125
HasNotSamePlayerAs::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:83
AndPredicate
Definition: unit_find.h:172
FindTerrainType
bool FindTerrainType(int movemask, int resmask, int range, const CPlayer &player, const Vec2i &startPos, Vec2i *pos)
Find the neareast piece of terrain with specific flags.
Definition: unit_find.cpp:162
Vec2T::x
T x
Definition: vec2i.h:42
HasSamePlayerAndTypeAs::HasSamePlayerAndTypeAs
HasSamePlayerAndTypeAs(const CPlayer &_player, const CUnitType &_type)
Definition: unit_find.h:112
ResourceDepositOnMap
CUnit * ResourceDepositOnMap(const Vec2i &pos, int resource)
Return resource deposit, if on map tile.
Definition: unit_find.cpp:664
CUnitType::UnitType
UnitTypeType UnitType
originally only visual effect, we do more with this!
Definition: unittype.h:609
ResourceOnMap
CUnit * ResourceOnMap(const Vec2i &pos, int resource, bool mine_on_top=true)
Return resource, if on map tile.
Definition: unit_find.cpp:639
FindUnit_If
CUnit * FindUnit_If(const Vec2i &ltPos, const Vec2i &rbPos, Pred pred)
Definition: unit_find.h:303
NotPredicate::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:163
CMap::FixSelectionArea
void FixSelectionArea(Vec2i &minpos, Vec2i &maxpos)
Definition: map.h:244
AttackUnitsInReactRange
CUnit * AttackUnitsInReactRange(const CUnit &unit, CUnitFilter pred)
Find best enemy in reaction range to attack.
Definition: unit_find.cpp:1217
CUnitFilter::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:52
CUnitType::TileWidth
int TileWidth
How much it costs to repair.
Definition: unittype.h:584
CMapField
Describes a field of the map.
Definition: tile.h:186
unittype.h
HasSameTypeAs::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:65
Map
CMap Map
Definition: map.cpp:55
CUnit
The big unit structure.
Definition: unit.h:135
AndPredicate::operator()
bool operator()(const CUnit *unit) const
Definition: unit_find.h:176
AttackUnitsInRange
CUnit * AttackUnitsInRange(const CUnit &unit, CUnitFilter pred)
Find best enemy in attack range to attack.
Definition: unit_find.cpp:1199
CUnitCache::begin
const_iterator begin() const
Definition: unit_cache.h:63
(C) Copyright 1998-2012 by The Stratagus Project under the GNU General Public License.
All trademarks and copyrights on this page are owned by their respective owners.