/**
** Check if the unit's container has an adjacent unit owned by another non-neutral player
**
** @return true if the unit is now sheltered (or if exited a shelter), false otherwise
*/
static bool LeaveShelter(CUnit &unit)
{
if (
!unit.Container
|| (unit.Container->Type->BoolFlag[ATTACKFROMTRANSPORTER_INDEX].value && unit.Type->BoolFlag[ATTACKFROMTRANSPORTER_INDEX].value)
|| (!unit.Player->AiEnabled && !(unit.Type->BoolFlag[FAUNA_INDEX].value && unit.Player->Type == PlayerNeutral))
|| unit.Container->CanMove() //is a transporter, not a shelter
|| !unit.Container->Type->CanTransport() //is not a garrisonable building
|| (unit.Container->Type->BoolFlag[RECRUITHEROES_INDEX].value && unit.Character && unit.Player->Type == PlayerNeutral) //if is a hireable hero in a hero recruitment building, don't leave it
) {
return false;
}
std::vector<CUnit *> table;
if (unit.Type->BoolFlag[FAUNA_INDEX].value) {
SelectAroundUnit(*unit.Container, 1, table, HasNotSamePlayerAs(*unit.Player));
} else {
SelectAroundUnit(*unit.Container, unit.CurrentSightRange, table, MakeAndPredicate(IsEnemyWith(*unit.Player), HasNotSamePlayerAs(Players[PlayerNumNeutral])));
}
if (table.size() > 0) {
CommandUnload(*unit.Container, unit.Container->tilePos, &unit, FlushCommands, unit.Container->MapLayer->ID);
return true;
}
return false;
}
/**
** Get a player's units in rectangle box specified with 2 coordinates
**
** @param l Lua state.
**
** @return Array of units.
*/
static int CclGetUnitsAroundUnit(lua_State *l)
{
const int nargs = lua_gettop(l);
if (nargs != 2 && nargs != 3) {
LuaError(l, "incorrect argument\n");
}
const int slot = LuaToNumber(l, 1);
const CUnit &unit = UnitManager.GetSlotUnit(slot);
const int range = LuaToNumber(l, 2);
bool allUnits = false;
if (nargs == 3) {
allUnits = LuaToBoolean(l, 3);
}
lua_newtable(l);
std::vector<CUnit *> table;
if (allUnits) {
SelectAroundUnit(unit, range, table, HasNotSamePlayerAs(Players[PlayerNumNeutral]));
} else {
SelectAroundUnit(unit, range, table, HasSamePlayerAs(*unit.Player));
}
size_t n = 0;
for (size_t i = 0; i < table.size(); ++i) {
if (table[i]->IsAliveOnMap()) {
lua_pushnumber(l, UnitNumber(*table[i]));
lua_rawseti(l, -2, ++n);
}
}
return 1;
}
/**
** Attack units in distance.
**
** If the unit can attack must be handled by caller.
** Choose the best target, that can be attacked.
**
** @param unit Find in distance for this unit.
** @param range Distance range to look.
** @param onlyBuildings Search only buildings (useful when attacking with AI force)
**
** @return Unit to be attacked.
*/
CUnit *AttackUnitsInDistance(const CUnit &unit, int range, CUnitFilter pred)
{
// if necessary, take possible damage on allied units into account...
if (unit.Type->Missile.Missile->Range > 1
&& (range + unit.Type->Missile.Missile->Range < 15)) {
// If catapult, count units near the target...
// FIXME : make it configurable
int missile_range = unit.Type->Missile.Missile->Range + range - 1;
Assert(2 * missile_range + 1 < 32);
// If unit is removed, use containers x and y
const CUnit *firstContainer = unit.Container ? unit.Container : &unit;
std::vector<CUnit *> table;
SelectAroundUnit(*firstContainer, missile_range, table,
MakeAndPredicate(HasNotSamePlayerAs(Players[PlayerNumNeutral]), pred));
if (table.empty() == false) {
return BestRangeTargetFinder(unit, range).Find(table);
}
return NULL;
} else {
// If unit is removed, use containers x and y
const CUnit *firstContainer = unit.Container ? unit.Container : &unit;
std::vector<CUnit *> table;
SelectAroundUnit(*firstContainer, range, table,
MakeAndPredicate(HasNotSamePlayerAs(Players[PlayerNumNeutral]), pred));
const int n = static_cast<int>(table.size());
if (range > 25 && table.size() > 9) {
std::sort(table.begin(), table.begin() + n, CompareUnitDistance(unit));
}
// Find the best unit to attack
return BestTargetFinder(unit).Find(table);
}
}
/**
** Move in a random direction
**
** @return true if the unit moves, false otherwise
*/
static bool MoveRandomly(CUnit &unit)
{
if (!unit.Type->RandomMovementProbability || SyncRand(100) > unit.Type->RandomMovementProbability) {
return false;
}
// pick random location
Vec2i pos = unit.tilePos;
pos.x += SyncRand(unit.Type->RandomMovementDistance * 2 + 1) - unit.Type->RandomMovementDistance;
pos.y += SyncRand(unit.Type->RandomMovementDistance * 2 + 1) - unit.Type->RandomMovementDistance;
// restrict to map
Map.Clamp(pos, unit.MapLayer->ID);
// move if possible
if (pos != unit.tilePos) {
UnmarkUnitFieldFlags(unit);
if (UnitCanBeAt(unit, pos, unit.MapLayer->ID)) {
MarkUnitFieldFlags(unit);
//Wyrmgus start
//prefer terrains which this unit's species is native to; only go to other ones if is already in a non-native terrain type
if (unit.Type->Species && std::find(unit.Type->Species->Terrains.begin(), unit.Type->Species->Terrains.end(), Map.GetTileTopTerrain(unit.tilePos, false, unit.MapLayer->ID)) != unit.Type->Species->Terrains.end()) {
if (std::find(unit.Type->Species->Terrains.begin(), unit.Type->Species->Terrains.end(), Map.GetTileTopTerrain(pos, false, unit.MapLayer->ID)) == unit.Type->Species->Terrains.end()) {
return false;
}
}
if (unit.Type->BoolFlag[PEOPLEAVERSION_INDEX].value) {
std::vector<CUnit *> table;
SelectAroundUnit(unit, std::max(6, unit.Type->RandomMovementDistance), table, HasNotSamePlayerAs(*unit.Player));
if (!table.size()) { //only avoid going near a settled area if isn't already surrounded by civilizations' units
//don't go near settled areas
Vec2i minpos = pos;
Vec2i maxpos = pos;
minpos.x = pos.x - std::max(6, unit.Type->RandomMovementDistance);
minpos.y = pos.y - std::max(6, unit.Type->RandomMovementDistance);
maxpos.x = pos.x + std::max(6, unit.Type->RandomMovementDistance);
maxpos.y = pos.y + std::max(6, unit.Type->RandomMovementDistance);
std::vector<CUnit *> second_table;
Select(minpos, maxpos, second_table, unit.MapLayer->ID, HasNotSamePlayerAs(*unit.Player));
if (second_table.size() > 0) {
return false;
}
} else { //even if is already in a settled area, don't go to places adjacent to units owned by players other than the neutral player
Vec2i minpos = pos;
Vec2i maxpos = pos;
minpos.x = pos.x - 1;
minpos.y = pos.y - 1;
maxpos.x = pos.x + 1;
maxpos.y = pos.y + 1;
std::vector<CUnit *> second_table;
Select(minpos, maxpos, second_table, unit.MapLayer->ID, HasNotSamePlayerAs(*unit.Player));
if (second_table.size() > 0) {
return false;
}
}
}
CommandMove(unit, pos, FlushCommands, unit.MapLayer->ID);
return true;
}
MarkUnitFieldFlags(unit);
}
return false;
}
