/**
** Unit repairs
**
** @param unit Unit, for that the attack is handled.
*/
void HandleActionRepair(CUnit *unit)
{
CUnit *goal;
int err;
switch (unit->SubAction) {
case 0:
NewResetPath(unit);
unit->SubAction = 1;
// FALL THROUGH
//
// Move near to target.
//
case 1:
// FIXME: RESET FIRST!! Why? We move first and than check if
// something is in sight.
err = DoActionMove(unit);
if (!unit->Anim.Unbreakable) {
//
// No goal: if meeting damaged building repair it.
//
goal = unit->Orders[0]->Goal;
//
// Target is dead, choose new one.
//
// Check if goal is correct unit.
if (goal) {
if (!goal->IsVisibleAsGoal(unit->Player)) {
DebugPrint("repair target gone.\n");
unit->Orders[0]->X = goal->X;
unit->Orders[0]->Y = goal->Y;
goal->RefsDecrease();
// FIXME: should I clear this here?
unit->Orders[0]->Goal = goal = NULL;
NewResetPath(unit);
}
} else if (unit->Player->AiEnabled) {
// Ai players workers should stop if target is killed
err = -1;
}
//
// Have reached target? FIXME: could use return value
//
if (goal && MapDistanceBetweenUnits(unit, goal) <= unit->Type->RepairRange &&
goal->Variable[HP_INDEX].Value < goal->Variable[HP_INDEX].Max) {
unit->State = 0;
unit->SubAction = 2;
unit->Data.Repair.Cycles = 0;
UnitHeadingFromDeltaXY(unit,
goal->X + (goal->Type->TileWidth - 1) / 2 - unit->X,
goal->Y + (goal->Type->TileHeight - 1) / 2 - unit->Y);
} else if (err < 0) {
if (goal) { // release reference
goal->RefsDecrease();
unit->Orders[0]->Goal = NoUnitP;
}
unit->Orders[0]->Action = UnitActionStill;
unit->State = unit->SubAction = 0;
if (unit->Selected) { // update display for new action
SelectedUnitChanged();
}
return;
}
// FIXME: Should be it already?
Assert(unit->Orders[0]->Action == UnitActionRepair);
}
break;
//
// Repair the target.
//
case 2:
AnimateActionRepair(unit);
unit->Data.Repair.Cycles++;
if (!unit->Anim.Unbreakable) {
goal = unit->Orders[0]->Goal;
//
// Target is dead, choose new one.
//
// Check if goal is correct unit.
// FIXME: should I do a function for this?
if (goal) {
if (!goal->IsVisibleAsGoal(unit->Player)) {
DebugPrint("repair goal is gone\n");
unit->Orders[0]->X = goal->X;
unit->Orders[0]->Y = goal->Y;
goal->RefsDecrease();
// FIXME: should I clear this here?
unit->Orders[0]->Goal = goal = NULL;
NewResetPath(unit);
}
}
if (goal && MapDistanceBetweenUnits(unit, goal) <= unit->Type->RepairRange) {
RepairUnit(unit, goal);
goal = unit->Orders[0]->Goal;
} else if (goal && MapDistanceBetweenUnits(unit, goal) > unit->Type->RepairRange) {
// If goal has move, chase after it
unit->State = 0;
unit->SubAction = 0;
}
//
// Target is fine, choose new one.
//
if (!goal || goal->Variable[HP_INDEX].Value >= goal->Variable[HP_INDEX].Max) {
if (goal) { // release reference
goal->RefsDecrease();
unit->Orders[0]->Goal = NULL;
}
unit->Orders[0]->Action = UnitActionStill;
unit->SubAction = unit->State = 0;
if (unit->Selected) { // update display for new action
SelectedUnitChanged();
}
return;
}
// FIXME: automatic repair
}
break;
}
}
/**
** Unit repairs
**
** @param unit Unit, for that the attack is handled.
*/
void HandleActionRepair(CUnit &unit)
{
CUnit *goal;
int err;
switch (unit.SubAction) {
case 0:
NewResetPath(unit);
unit.SubAction = 1;
// FALL THROUGH
//
// Move near to target.
//
case 1:
// FIXME: RESET FIRST!! Why? We move first and than check if
// something is in sight.
err = DoActionMove(unit);
if (!unit.Anim.Unbreakable) {
//
// No goal: if meeting damaged building repair it.
//
goal = unit.CurrentOrder()->GetGoal();
//
// Target is dead, choose new one.
//
// Check if goal is correct unit.
if (goal) {
if (!goal->IsVisibleAsGoal(unit.Player)) {
DebugPrint("repair target gone.\n");
unit.CurrentOrder()->goalPos = goal->tilePos;
// FIXME: should I clear this here?
unit.CurrentOrder()->ClearGoal();
goal = NULL;
NewResetPath(unit);
}
} else if (unit.Player->AiEnabled) {
// Ai players workers should stop if target is killed
err = -1;
}
//
// Have reached target? FIXME: could use return value
//
if (goal && unit.MapDistanceTo(*goal) <= unit.Type->RepairRange &&
goal->Variable[HP_INDEX].Value < goal->Variable[HP_INDEX].Max) {
unit.State = 0;
unit.SubAction = 2;
unit.Data.Repair.Cycles = 0;
const Vec2i dir = goal->tilePos + goal->Type->GetHalfTileSize() - unit.tilePos;
UnitHeadingFromDeltaXY(unit, dir);
} else if (err < 0) {
unit.CurrentOrder()->ClearGoal();
if (!unit.RestoreOrder()) {
unit.ClearAction();
unit.State = 0;
}
return;
}
// FIXME: Should be it already?
Assert(unit.CurrentAction() == UnitActionRepair);
}
break;
//
// Repair the target.
//
case 2:
AnimateActionRepair(unit);
unit.Data.Repair.Cycles++;
if (!unit.Anim.Unbreakable) {
goal = unit.CurrentOrder()->GetGoal();
//
// Target is dead, choose new one.
//
// Check if goal is correct unit.
// FIXME: should I do a function for this?
if (goal) {
if (!goal->IsVisibleAsGoal(unit.Player)) {
DebugPrint("repair goal is gone\n");
unit.CurrentOrder()->goalPos = goal->tilePos;
// FIXME: should I clear this here?
unit.CurrentOrder()->ClearGoal();
goal = NULL;
NewResetPath(unit);
} else {
int dist = unit.MapDistanceTo(*goal);
if (dist <= unit.Type->RepairRange) {
RepairUnit(unit, *goal);
goal = unit.CurrentOrder()->GetGoal();
} else if (dist > unit.Type->RepairRange) {
// If goal has move, chase after it
unit.State = 0;
unit.SubAction = 0;
}
}
}
//
// Target is fine, choose new one.
//
if (!goal || goal->Variable[HP_INDEX].Value >=
goal->Variable[HP_INDEX].Max) {
unit.CurrentOrder()->ClearGoal();
if (!unit.RestoreOrder()) {
unit.ClearAction();
unit.State = 0;
}
return;
}
// FIXME: automatic repair
}
break;
}
}
/* virtual */ void COrder_Repair::Execute(CUnit &unit)
{
Assert(this->ReparableTarget == this->GetGoal());
switch (this->State) {
case 0:
this->State = 1;
// FALL THROUGH
case 1: { // Move near to target.
// FIXME: RESET FIRST!! Why? We move first and than check if
// something is in sight.
int err = DoActionMove(unit);
if (!unit.Anim.Unbreakable) {
// No goal: if meeting damaged building repair it.
CUnit *goal = this->GetGoal();
if (goal) {
if (!goal->IsVisibleAsGoal(*unit.Player)) {
DebugPrint("repair target gone.\n");
this->goalPos = goal->tilePos + goal->Type->GetHalfTileSize();
ReparableTarget = NULL;
this->ClearGoal();
goal = NULL;
}
} else if (unit.Player->AiEnabled) {
// Ai players workers should stop if target is killed
err = -1;
}
// Have reached target? FIXME: could use return value
if (goal && unit.MapDistanceTo(*goal) <= unit.Type->RepairRange
&& goal->Variable[HP_INDEX].Value < goal->Variable[HP_INDEX].Max) {
this->State = 2;
this->RepairCycle = 0;
const Vec2i dir = goal->tilePos + goal->Type->GetHalfTileSize() - unit.tilePos;
UnitHeadingFromDeltaXY(unit, dir);
} else if (err < 0) {
this->Finished = true;
return ;
}
}
break;
}
case 2: {// Repair the target.
AnimateActionRepair(unit);
this->RepairCycle++;
if (unit.Anim.Unbreakable) {
return ;
}
CUnit *goal = this->GetGoal();
if (goal) {
if (!goal->IsVisibleAsGoal(*unit.Player)) {
DebugPrint("repair goal is gone\n");
this->goalPos = goal->tilePos + goal->Type->GetHalfTileSize();
// FIXME: should I clear this here?
this->ClearGoal();
ReparableTarget = NULL;
goal = NULL;
} else {
const int dist = unit.MapDistanceTo(*goal);
if (dist <= unit.Type->RepairRange) {
if (RepairUnit(unit, *goal)) {
this->Finished = true;
return ;
}
} else if (dist > unit.Type->RepairRange) {
// If goal has move, chase after it
this->State = 0;
}
}
}
// Target is fine, choose new one.
if (!goal || goal->Variable[HP_INDEX].Value >= goal->Variable[HP_INDEX].Max) {
this->Finished = true;
return ;
}
// FIXME: automatic repair
}
break;
}
}
