//
// Execute
//
U32 Attack::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
// Resolve the squad
if (SquadObj * squadObj = Resolver::Object<SquadObj, SquadObjType>(d->squad))
{
switch (d->type)
{
case Target::OBJECT:
{
// Convert ID into a pointer
MapObj *mapObj = Resolver::Object<MapObj, MapObjType>(d->object);
if (mapObj)
{
IssueTask(d->mod, squadObj, new Tasks::SquadAttack(squadObj, Target(mapObj)), player, d->move ? 0 : Task::TF_FLAG2);
}
break;
}
case Target::LOCATION:
{
IssueTask(d->mod, squadObj, new Tasks::SquadAttack(squadObj, Target(d->location)), player, d->move ? 0 : Task::TF_FLAG2);
break;
}
default:
ERR_FATAL(("Unknown Target type %d", d->type))
}
}
return (sizeof (Data));
}
//
// Execute
//
U32 Board::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
// Convert ID into a pointer
if (TransportObj *target = Resolver::Object<TransportObj, TransportObjType>(d->target))
{
// Check each selected object
for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++)
{
UnitObj *subject = **i;
// Can this unit type board this transport
if (target != subject && target->CheckType(subject))
{
if (target->UnitType()->CanBoard())
{
// Board using entry points
IssueTask(d->mod, subject, new Tasks::UnitMove(subject, target), player);
}
else
{
// Board using warping
IssueTask(d->mod, subject, new Tasks::UnitBoard(subject, target), player);
}
}
}
}
return (sizeof (Data));
}
//
// Execute
//
U32 Turn::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
// Send the move order to all of the selected objects
for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++)
{
UnitObj *unit = **i;
// Calculate desired front vector
Vector v(d->x - unit->Position().x, 0, d->z - unit->Position().z);
v.Normalize();
// Can the unit move
if (unit->CanEverMove())
{
if (!unit->GetDriver()->IsBoarded())
{
// Convert the given task Id into a move type
Tasks::UnitMove *task = new Tasks::UnitMove(unit);
task->SetDir(v);
IssueTask(d->mod, unit, task, player);
}
}
}
return (sizeof (Data));
}
//
// Execute
//
U32 Board::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
// Resolve the squad
if (SquadObj * squadObj = Resolver::Object<SquadObj, SquadObjType>(d->squad))
{
// Get the selected units and pass them to the board task
TransportObjList transports;
for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++)
{
if (TransportObj *transport = Promote::Object<TransportObjType, TransportObj>(**i))
{
transports.Append(transport);
}
}
// Issue the task for the squad to board the transports
IssueTask(d->mod, squadObj, new Tasks::SquadBoard(squadObj, transports), player, d->attack ? Task::TF_FLAG1 : 0);
// Clear out the temp list
transports.Clear();
}
return (sizeof (Data));
}
//
// Execute
//
U32 Guard::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
// Create an iterator
for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++)
{
// Get the unit
UnitObj *unit = **i;
// Can it ever guard
if (Tasks::UnitGuard::CanGuard(unit))
{
switch (d->type)
{
case Target::OBJECT:
{
// Convert ID into a pointer
if (MapObj *mapObj = Resolver::Object<MapObj, MapObjType>(d->object))
{
IssueTask(d->mod, unit, new Tasks::UnitGuard(unit, Target(mapObj)), player);
}
break;
}
case Target::LOCATION:
{
Vector v;
v.Set(d->location.x, d->location.y, d->location.z);
IssueTask(d->mod, unit, new Tasks::UnitGuard(unit, Target(v)), player);
break;
}
}
}
}
return (sizeof (Data));
}
//
// Execute
//
U32 Trail::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
// Resolve the squad
if (SquadObj * squadObj = Resolver::Object<SquadObj, SquadObjType>(d->squad))
{
if (TrailObj *trail = Resolver::Object<TrailObj, TrailObjType>(d->trail))
{
IssueTask(d->mod, squadObj, new Tasks::SquadMove(squadObj, trail, d->index), player, d->attack ? Task::TF_FLAG1 : 0);
}
}
return (sizeof (Data));
}
//
// Execute
//
U32 Trail::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
switch (d->op)
{
case OP_CREATE:
{
player.SetLastTrail
(
TrailObj::Create(player.GetTeam(), NULL, TrailObj::Mode(d->mode))
);
break;
}
case OP_DELETE:
{
TrailObj *trail = Resolver::Object<TrailObj, TrailObjType>(d->trail);
if (trail)
{
trail->MarkForDeletion();
}
break;
}
case OP_APPLY:
{
TrailObj *trail = Resolver::Object<TrailObj, TrailObjType>(d->trail);
if (trail)
{
for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++)
{
UnitObj *subject = **i;
if ((**i)->CanEverMove())
{
IssueTask(d->mod, subject, new Tasks::UnitMove(subject, trail, d->index), player, d->attack ? Task::TF_FLAG1 : 0);
}
}
}
break;
}
}
return (sizeof (Data));
}
//
// Execute
//
U32 Return::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
// Send the move order to all of the selected objects
for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++)
{
if ((**i)->CanEverMove())
{
// To return, move to where you are
IssueTask(d->mod, **i, new Tasks::UnitMove(**i, (**i)->WorldMatrix().Position()), player);
}
}
return (sizeof (Data));
}
//
// Execute
//
U32 RestoreMobile::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
// Convert ID into a pointer
if (UnitObj *target = Resolver::Object<UnitObj, UnitObjType>(d->target))
{
// Check each selected object
for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++)
{
// Promote to a restore object
RestoreObj *subject = Promote::Object<RestoreObjType, RestoreObj>(**i);
// Can the subject restore the target
if (subject && subject->RestoreRequired(target))
{
IssueTask(d->mod, subject, new Tasks::RestoreMobile(subject, target), player);
}
}
}
return (sizeof (Data));
}
//
// Execute
//
U32 PowerDown::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
// Are we powering down or up
if (d->down)
{
// Check each selected object
for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++)
{
UnitObj *subject = **i;
// Can this unit power down ?
if (subject->UnitType()->GetPower().GetRequired())
{
IssueTask(FLUSH, subject, new Tasks::UnitPowerDown(subject), player);
}
}
}
else
{
// Check each selected object
for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++)
{
UnitObj *subject = **i;
// Is this unit powered down ?
if (Tasks::UnitPowerDown *task = TaskCtrl::Promote<Tasks::UnitPowerDown>(subject))
{
task->ProcessEvent(Task::Event(0x57BE223A)); // "PowerUp"
}
}
}
return (sizeof (Data));
}
//
// Execute
//
U32 Build::Execute(const U8 *data, Player &player)
{
const Data *d = (Data *) data;
// Should never be more than one unit in the selected list
if (UnitObj *unitObj = player.GetSelectedList().GetFirst())
{
// Ensure unit can move (sync filter)
if (unitObj->CanEverMove())
{
// Get the type to build
if (UnitObjType *build = GameObjCtrl::FindType<UnitObjType>(d->build))
{
// Setup the destination
Vector dest(d->dest.x, TerrainData::FindFloorWithWater(d->dest.x, d->dest.z), d->dest.z);
// Send the task
IssueTask(d->mod, unitObj, new Tasks::UnitBuild(unitObj, build, dest, d->dir), player);
}
}
}
return (sizeof (Data));
}
