/**
** Change invalid target for new target in range.
**
** @param unit Unit to check if goal is in range
**
** @return true if order(action) have changed, false else (if goal change return false).
*/
bool COrder_Attack::CheckForTargetInRange(CUnit &unit)
{
// Target is dead?
if (CheckForDeadGoal(unit)) {
return true;
}
// No goal: if meeting enemy attack it.
if (!this->HasGoal()
&& this->Action != UnitActionAttackGround
&& !Map.WallOnMap(this->goalPos)) {
CUnit *goal = AttackUnitsInReactRange(unit);
if (goal) {
COrder *savedOrder = COrder::NewActionAttack(unit, this->goalPos);
if (unit.CanStoreOrder(savedOrder) == false) {
delete savedOrder;
savedOrder = NULL;
} else {
unit.SavedOrder = savedOrder;
}
this->SetGoal(goal);
this->MinRange = unit.Type->MinAttackRange;
this->Range = unit.Stats->Variables[ATTACKRANGE_INDEX].Max;
this->goalPos = goal->tilePos;
this->State |= WEAK_TARGET; // weak target
}
// Have a weak target, try a better target.
} else if (this->HasGoal() && (this->State & WEAK_TARGET || unit.Player->AiEnabled)) {
CUnit *goal = this->GetGoal();
CUnit *newTarget = AttackUnitsInReactRange(unit);
if (newTarget && ThreatCalculate(unit, *newTarget) < ThreatCalculate(unit, *goal)) {
COrder *savedOrder = NULL;
if (unit.CanStoreOrder(this)) {
savedOrder = this->Clone();
}
if (savedOrder != NULL) {
unit.SavedOrder = savedOrder;
}
this->SetGoal(newTarget);
this->goalPos = newTarget->tilePos;
}
}
Assert(!unit.Type->Vanishes && !unit.Destroyed && !unit.Removed);
return false;
}
/* virtual */ void COrder_SpellCast::Execute(CUnit &unit)
{
COrder_SpellCast &order = *this;
if (unit.Wait) {
unit.Wait--;
return ;
}
const SpellType &spell = order.GetSpell();
switch (this->State) {
case 0:
// Check if we can cast the spell.
if (!CanCastSpell(unit, spell, order.GetGoal(), order.goalPos)) {
// Notify player about this problem
if (unit.Variable[MANA_INDEX].Value < spell.ManaCost) {
unit.Player->Notify(NotifyYellow, unit.tilePos,
_("%s: not enough mana for spell: %s"),
unit.Type->Name.c_str(), spell.Name.c_str());
} else {
unit.Player->Notify(NotifyYellow, unit.tilePos,
_("%s: can't cast spell: %s"),
unit.Type->Name.c_str(), spell.Name.c_str());
}
if (unit.Player->AiEnabled) {
DebugPrint("FIXME: do we need an AI callback?\n");
}
this->Finished = true;
return ;
}
if (CheckForDeadGoal(unit)) {
return;
}
// FIXME FIXME FIXME: Check if already in range and skip straight to 2(casting)
unit.ReCast = 0; // repeat spell on next pass? (defaults to `no')
this->State = 1;
// FALL THROUGH
case 1: // Move to the target.
if (spell.Range && spell.Range != INFINITE_RANGE) {
if (SpellMoveToTarget(unit) == true) {
this->Finished = true;
return ;
}
return ;
} else {
this->State = 2;
}
// FALL THROUGH
case 2: // Cast spell on the target.
if (!spell.IsCasterOnly()) {
AnimateActionSpellCast(unit, *this);
if (unit.Anim.Unbreakable) {
return ;
}
} else {
// FIXME: what todo, if unit/goal is removed?
CUnit *goal = order.GetGoal();
if (goal && goal != &unit && !goal->IsVisibleAsGoal(*unit.Player)) {
unit.ReCast = 0;
} else {
unit.ReCast = SpellCast(unit, spell, goal, order.goalPos);
}
}
// Target is dead ? Change order ?
if (CheckForDeadGoal(unit)) {
return;
}
// Check, if goal has moved (for ReCast)
if (unit.ReCast && order.GetGoal() && unit.MapDistanceTo(*order.GetGoal()) > this->Range) {
this->State = 0;
return;
}
if (!unit.ReCast && unit.CurrentAction() != UnitActionDie) {
this->Finished = true;
return ;
}
break;
default:
this->State = 0; // Reset path, than move to target
break;
}
}
/**
** Handle attacking the target.
**
** @param unit Unit, for that the attack is handled.
*/
void COrder_Attack::AttackTarget(CUnit &unit)
{
Assert(this->HasGoal() || Map.Info.IsPointOnMap(this->goalPos));
AnimateActionAttack(unit, *this);
if (unit.Anim.Unbreakable) {
return;
}
if (!this->HasGoal() && (this->Action == UnitActionAttackGround || Map.WallOnMap(this->goalPos))) {
return;
}
// Target is dead ? Change order ?
if (CheckForDeadGoal(unit)) {
return;
}
CUnit *goal = this->GetGoal();
bool dead = !goal || goal->IsAlive() == false;
// No target choose one.
if (!goal) {
goal = AttackUnitsInReactRange(unit);
// No new goal, continue way to destination.
if (!goal) {
// Return to old task ?
if (unit.RestoreOrder()) {
return;
}
this->State = MOVE_TO_TARGET;
return;
}
// Save current command to come back.
COrder *savedOrder = COrder::NewActionAttack(unit, this->goalPos);
if (unit.CanStoreOrder(savedOrder) == false) {
delete savedOrder;
savedOrder = NULL;
} else {
unit.SavedOrder = savedOrder;
}
this->SetGoal(goal);
this->goalPos = goal->tilePos;
this->MinRange = unit.Type->MinAttackRange;
this->Range = unit.Stats->Variables[ATTACKRANGE_INDEX].Max;
this->State |= WEAK_TARGET;
// Have a weak target, try a better target.
// FIXME: if out of range also try another target quick
} else {
if ((this->State & WEAK_TARGET)) {
CUnit *newTarget = AttackUnitsInReactRange(unit);
if (newTarget && ThreatCalculate(unit, *newTarget) < ThreatCalculate(unit, *goal)) {
if (unit.CanStoreOrder(this)) {
unit.SavedOrder = this->Clone();
}
goal = newTarget;
this->SetGoal(newTarget);
this->goalPos = newTarget->tilePos;
this->MinRange = unit.Type->MinAttackRange;
this->State = MOVE_TO_TARGET;
}
}
}
// Still near to target, if not goto target.
const int dist = unit.MapDistanceTo(*goal);
if (dist > unit.Stats->Variables[ATTACKRANGE_INDEX].Max) {
// towers don't chase after goal
if (unit.CanMove()) {
if (unit.CanStoreOrder(this)) {
if (dead) {
unit.SavedOrder = COrder::NewActionAttack(unit, this->goalPos);
} else {
unit.SavedOrder = this->Clone();
}
}
}
unit.Frame = 0;
this->State &= WEAK_TARGET;
this->State |= MOVE_TO_TARGET;
}
if (dist < unit.Type->MinAttackRange) {
this->State = MOVE_TO_TARGET;
}
// Turn always to target
if (goal) {
const Vec2i dir = goal->tilePos + goal->Type->GetHalfTileSize() - unit.tilePos;
UnitHeadingFromDeltaXY(unit, dir);
}
}
