//
    // 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));
    }

  //
  // TagCondition::TagTest
  //
  Bool TagCondition::TagTest(Team *team)
  {
    ASSERT(tag)
    U32 count = 0;

    // Test the Objects in Tag to see if there is enough of them on this team
    if (tag->tag.Alive())
    {
      // Purge dead objects out of the list
      tag->tag->list.PurgeDead();

      for (MapObjList::Iterator o(&tag->tag->list); *o; o++)
      {
        MapObj *obj = **o;
        UnitObj *unitObj = Promote::Object<UnitObjType, UnitObj>(obj);
        UnitObj *parentObj = obj->GetParent() ? Promote::Object<UnitObjType, UnitObj>(obj->GetParent()) : NULL;

        if (
          unitObj && (unitObj->GetActiveTeam() == team) || 
          parentObj && (parentObj->GetActiveTeam() == team))
        {
          count++;
        }
      }
    }

    return (tag->oper(count, tag->GetAmount()));
  }

  //
  // TagInTransport::Test
  //
  Bool TagInTransport::Test(class Team *)
  {
    // Check to see if all of the tag members are inside transports
    if (tag->tag.Alive())
    {
      // Purge dead objects out of the list
      tag->tag->list.PurgeDead();

      // Count the number of tag members who are in transports
      U32 count = 0;

      if (tag->tag->list.GetCount())
      {
        for (MapObjList::Iterator o(&tag->tag->list); *o; o++)
        {
          MapObj *obj = **o;
          UnitObj *unitObj = Promote::Object<UnitObjType, UnitObj>(obj);

          if (unitObj && unitObj->GetFlag(UnitObj::FLAG_CARGO))
          {
            count++;
          }
        }
      }
      return (tag->oper(count, tag->GetAmount()));
    }
    return (FALSE);
  }

//
// Apply
//
void ExplosionObjType::Apply(const Vector &location, UnitObj *unit, Team *team)
{
  MapObjIter::All i(NULL, MapObjIter::FilterData(location, areaOuter));
  MapObj *obj;

  while ((obj = i.Next()) != NULL)
  {
    // Is the object within the full damage area
    F32 dist2 = i.GetProximity2() - areaInner2;
    S32 deltaHp;

    //Vector dir = obj->WorldMatrix().posit - location;
    //dir.Normalize();

    if (dist2 <= 0.0f)
    {
      // Apply the full damage to this object
      deltaHp = -damage.GetAmount(obj->MapType()->GetArmourClass());
      obj->ModifyHitPoints(deltaHp, unit, team/*, &dir*/);
    }
    else
    {
      F32 mod = 1.0f - (dist2 * areaDiff2Inv);
      ASSERT(mod >= 0 && mod <= 1.0f)

      // Apply a proportional damage to this object
      //Vector v = dir * mod;
      deltaHp = -(S32) (((F32) damage.GetAmount(obj->MapType()->GetArmourClass())) * mod);
      obj->ModifyHitPoints(deltaHp, unit, team/*, &v*/);
    }

    // Apply hit modifiers
    if (ArmourClass::Lookup(damage.GetDamageId(), obj->MapType()->GetArmourClass()))
    {
      damage.GetModifiers().Apply(obj);

      // Set blind target time
      if (blindTargetTime)
      {
        UnitObj *unitObj = Promote::Object<UnitObjType, UnitObj>(obj);

        if (unitObj)
        {
          unitObj->FlushTasks();
          unitObj->StartBlindTarget(blindTargetTime);
        }
      }

      // Apply the generic effect
      StartGenericFX(obj, 0x32FBA304); // "ExplosionObj::ApplyTarget"
    }

    // Is there an action to execute
    if (action && team)
    {
      Action::Execute(team, action);
    }
  }
}

  //
  // Assign constructors to this base
  //
  void Base::AssignConstructors(const char *tagName)
  {
    processTokens = TRUE;

    // Was a tag specified ?
    if (tagName)
    {
      // Resolve the tag
      TagObj *tag = TagObj::FindTag(tagName);

      if (tag)
      {
        // Iterate the units in the tag
        for (MapObjList::Iterator i(&tag->list); *i; i++)
        {
          // Is it alive
          if (!(*i)->Alive())
          {
            continue;
          }

          // Is this a unit ?
          UnitObj *unit = Promote::Object<UnitObjType, UnitObj>(**i);
          if (!unit)
          {
            continue;
          }

          // Is it on our team ?
          if (unit->GetTeam() != GetObject().GetTeam())
          {
            continue;
          }

          // Is it a constructor ?
          if (!unit->HasProperty(0xDCDE71CD)) // "Ability::Construction"
          {
            continue;
          }

//          LOG_AI(("Assigning constructor [%d] '%s' to base '%s'", unit->Id(), unit->UnitType()->GetName(), GetName()))

          // Add this constructor to the list of idle constructors
          constructorsIdle.Append(unit);
        }
      }
      else
      {
        ERR_CONFIG(("Could not find tag '%s' when assign constructors to base '%s'", tagName, GetName()))
      }
    }
    else
    {
      // Iterate all of the units on this team
      for (NList<UnitObj>::Iterator u(&GetObject().GetTeam()->GetUnitObjects()); *u; u++)

    //
    // Data constructor
    //
    Objects::Data::Data(MapObj *o) : object(o)
    {
      type = object->MapType();
      matrix = object->WorldMatrix();
      zipped = object->GetFootInstance() ? TRUE : FALSE;

      UnitObj *unit = Promote::Object<UnitObjType, UnitObj>(object);

      if (unit)
      {
        team = unit->GetTeam();
      }
    }

    //
    // Apply
    //
    void Tag::Apply()
    {
      MapObjList list;

      list.AppendList((const MapObjList &) script.GetSquad()->GetList());

      if (clear)
      {
        // Go through all of the tags and remove any units which are in the squad
        for (NBinTree<TagObj>::Iterator t(&TagObj::allTags); *t; t++)
        {
          // Iterate the objects in this tag
          MapObjList::Iterator m(&(*t)->list);
          
          while (MapObjListNode *node = m++)
          {
            UnitObj *unit;

            // Is this a unit
            if 
            (
              node->Alive() &&
              (unit = Promote::Object<UnitObjType, UnitObj>(*node)) != NULL
            )
            {
              // If this unit is in our squad, remove it
              if (unit->GetSquad() == script.GetSquad())
              {
                (*t)->list.Unlink(node);
              }
            }
          }
        }
      }

      if (append)
      {
        // Is there an existing tag with this name ?
        TagObj *tag = TagObj::FindTag(tagName.GetStr());

        if (tag)
        {
          // Append the units in the tag to the list
          list.AppendList(tag->list);
        }
      }

      TagObj::CreateTag(tagName.GetStr(), list);

      list.Clear();
    }

    //
    // Execute
    //
    U32 SelfDestruct::Execute(const U8 *, Player &player)
    {
      // Tell each object to SelfDestruct
      for (UnitObjList::Iterator i(&player.GetSelectedList()); *i; i++)
      {
        // Get the unit
        UnitObj *unit = **i;

        // Ensure it can self destruct
        if (unit->HasProperty(0x54D4152A) && !unit->UnderConstruction()) // "Ability::SelfDestruct"
        {
          unit->SelfDestruct(TRUE, unit->GetTeam());
        }
      }

      return (sizeof (Data));
    }

  //
  // Submit asset requests directly to the manager
  //
  Bool Asset::Request::TypeBase::DirectEvaluation(Manager &manager)
  {
    // Iterate the units in the base an evaluate them
    if (base.Alive())
    {
      for (UnitObjList::Iterator u(&base->GetUnits()); *u; u++)
      {
        if ((*u)->Alive())
        {
          UnitObj *unit = **u;
          manager.Evaluation(*this, *unit, config->GetAmounts().Find(unit->GameType()->Id()) ? 1.0f : 0.0f);
        }
      }
    }

    return (TRUE);
  }

  //
  // Offer
  //
  // The given asset is being offered, do we want it ?
  //
  Bool Asset::Request::TypeBase::Offer(Asset &asset)
  {
    // Get the unit out of the asset
    UnitObj *unit = asset.GetUnit();
    ASSERT(unit)

    // Do we have enough of this type ?
    U32 type = unit->GameType()->Id();

    // We should only be offered this type if we asked for it
    ASSERT(config->GetAmount(type))

    // How many of this type do we currently have ?
    U32 *amount = amounts.Find(type);

    // Is this less that what we need ?
    return ((!amount || *amount < config->GetAmount(type)) ? TRUE : FALSE);
  }

    //
    // Execute
    //
    U32 Store::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;

        // Is this a collector ?
        if (Tasks::UnitCollect *task = TaskCtrl::PromoteIdle<Tasks::UnitCollect>(unit))
        {
          // Should we search for a place to store the resource
          if (d->search)
          {
            task->Store();
          }
          else
          {
            // Convert ID into a pointer
            if (UnitObj *storeObj = Resolver::Object<UnitObj, UnitObjType>(d->object))
            {
              // If not updating the position, flush tasks incase moving or something
              if (!d->update && unit->GetActiveTask())
              {
                unit->FlushTasks();
              }

              // Tell this task about the new storage point
              task->SetStorageObject(storeObj, d->update);
            }
          }
        }
      }

      return (sizeof (Data));
    }

  //
  // Initial state
  //
  void MapDeath::StateInit()
  {
    // Stop the objects driver
    UnitObj *unitObj = Promote::Object<UnitObjType, UnitObj>(subject);

    if (unitObj)
    {
      if (unitObj->GetWeapon())
      {
        unitObj->GetWeapon()->HaltFire();
      }

      if (unitObj->CanEverMove())
      {
        unitObj->GetDriver()->Stop(Movement::Driver::STOP_DYING);
      }
    }

    // Play the death animation
    subject->SetAnimation(0xF40D135F); // "Death"

    NextState(0x382D3C63); // "Dead"
  }

    //
    // RenderSpecialized
    //
    // Display specialized unit information
    //
    static void RenderSpecialized()
    {
      // Is there a unit under the cursor
      UnitObj *over = data.cInfo.gameWnd.Alive() ? data.cInfo.o.unit.GetPointer() : NULL;

      // Can we see this units special info
      if (over && Team::TestDisplayRelation(over, Relation::ALLY))
      {
        over->RenderSpecialized();
      }

      // Now display for all selected units
      for (UnitObjList::Iterator i(&data.sList); *i; ++i)
      {
        if (UnitObj *u = (*i)->GetPointer())
        {
          if (u != over)
          {
            u->RenderSpecialized();
          }
        }
      }
    }

//
// 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));
}

  //
  // StateInit
  //
  void SquadBoard::StateInit()
  {
    // Get each of the units in the squad to board transports
    SquadObj::UnitList::Iterator u(&subject->GetList());

    // We could enhance this to use units which are closest to transports etc.

    // Clear the squad's completed flags
    for (!u; *u; u++)
    {
      (*u)->completed = FALSE;
      (*u)->task = 0;
    }

    // Reset squad iterator
    !u;

    for (TransportObjList::Iterator t(&transports); *t; t++)
    {
      if ((*t)->Alive())
      {
        TransportObj *transport = **t;
        U32 slots = transport->TransportType()->GetSpaces();
        U32 added = 0;

        while (slots--)
        {
          UnitObjPtr *unitPtr = *u;

          if (unitPtr)
          {
            ASSERT(unitPtr->Alive())
            UnitObj *unit = *unitPtr;

            if (unit->CanEverMove())
            {
              // Tell the unit to board
              unit->FlushTasks(Tasks::UnitBoard::GetConfigBlockingPriority());

              Task *task;

              // Is this a telepad
              if (TaskCtrl::PromoteIdle<Tasks::TransportPad>(transport))
              {
                unit->PrependTask(task = new Tasks::UnitMove(unit, transport), GetFlags());
              }
              else
              {
                unit->PrependTask(task = new Tasks::UnitBoard(unit, transport), GetFlags());
              }

              (*u)->task = task->GetTaskId();

              added++;
            }
            else
            {
              // This unit can't move so complete it
              (*u)->completed = TRUE;
            }
          }
          else
          {
            break;
          }

          // Increment iterator
          u++;
        }

        if (!added)
        {
          // No units were added
          break;
        }
      }
    }

    // Complete those units which missed out
    for (; *u; u++)
    {
      (*u)->completed = TRUE;
    }

    NextState(0x09E5F977); // "Boarding"
  }

    //
    // RenderRallyPoint
    //
    // Display a rally point
    //
    static void RenderRallyPoint()
    {
      Point<S32> srcPoint(0, 0);
      Point<U32> dstPoint(0, 0);
      Matrix src, dst;

      // Get the single selected unit
      UnitObj *unit = data.cInfo.oneUnit.GetPointer();

      // Is there a rally point
      if (unit && unit->GetFootInstance() && unit->GetRallyPoint(dstPoint))
      {
        // Setup destination
        dst.ClearData();
        dst.posit.x = WorldCtrl::CellToMetresX(dstPoint.x);
        dst.posit.z = WorldCtrl::CellToMetresZ(dstPoint.z);
        dst.posit.y = TerrainData::FindFloorWithWater(dst.posit.x, dst.posit.z);

        // Find the source
        srcPoint.Set(S32(dstPoint.x), S32(dstPoint.z));
        unit->GetFootInstance()->ClampToFringe(srcPoint);
        src.ClearData();
        src.posit.x = WorldCtrl::CellToMetresX(srcPoint.x);
        src.posit.z = WorldCtrl::CellToMetresZ(srcPoint.z);
        src.posit.y = TerrainData::FindFloorWithWater(src.posit.x, src.posit.z);
      }
      else
      {
        // Act as if not selected
        unit = NULL;
      }

      if 
      (
        // Rally unit has been deselected
        (!unit && rallyUnitId) 
        
        || 
        
        (
          // Have a rally point unit
          unit 
          
          && 
          
          (
            // Different to last one
            (unit->Id() != rallyUnitId) 
            
            || 
            
            // Rally point location has changed
            (rallyUnitId && (dstPoint != rallyPoint))
          )
        )
      )
      {
        // Dispose of any current particle
        if (rallyParticle.Alive())
        {
          delete rallyParticle;
        }

        // Is there a unit selected
        if (unit)
        {
          // Never display a trail when same point
          if ((srcPoint.x != S32(dstPoint.x)) || (srcPoint.z != S32(dstPoint.z)))
          {
            // Create the runner particle
            if (ParticleClass *p = ParticleSystem::FindType(0x94E362BD)) // "Client::Rally"
            {
              Matrix m(src);
              m.posit.y += 3.0F;
			        Vector v(0.0f, 0.0f, 0.0f);
              rallyParticle = ParticleSystem::New(p, m, v, v, dst.posit - src.posit, 0.0F);
            }
          }

          // Remember this unit's info
          rallyUnitId = unit->Id();
          rallyPoint = dstPoint;
        }
        else
        {
          rallyUnitId = 0;
        }
      }

      // Render the start and end points
      if (unit)
      {     
        Common::Display::Mesh(0x693D5359, src, Color(0.0F, 0.8F, 0.0F, 0.7F)); // "Location"
        Common::Display::Mesh(0x693D5359, dst, Color(0.0F, 1.0F, 0.0F, 0.7F)); // "Location"
      }
//.........这里部分代码省略.........

  //
  // Initial state
  //
  void SquadMoveTogether::StateInit()
  {
    LOG_DIAG(("SquadMoveTogether: Init"))

    // Find the slowest unit in the squad and use their traction type
    U8 traction = 0;
    F32 bottomSpeed = F32_MAX;

    // Work out the centre position of the squad
    Vector location(0.0f, 0.0f, 0.0f);
    U32 count = 0;
    SquadObj::UnitList::Iterator i(&subject->GetList());
    for (!i; *i; i++)
    {
      if ((*i)->Alive())
      {
        // Take this oportunity to reset the units node
        (*i)->completed = TRUE;
        (*i)->data = 0;

        if ((**i)->CanEverMove())
        {
          // Grab the unit so we don't need to continually pound the iterator
          UnitObj *unit = **i;

          // Flush its tasks
          unit->FlushTasks(Tasks::UnitMove::GetConfigBlockingPriority());

          // Add its position to the total
          location.x += unit->WorldMatrix().posit.x;
          location.z += unit->WorldMatrix().posit.z;
          count++;

          // Is this the slowest unit in the squad
          F32 speed = unit->GetMaxSpeed();
          if (speed < bottomSpeed)
          {
            bottomSpeed = speed;
            traction = unit->MapType()->GetTractionIndex(unit->MapType()->GetDefaultLayer());
          }
        }
      }
    }

    if (!count)
    {
      Quit();
      return;
    }

    // Work out the averate location
    location.x /= count;
    location.z /= count;
    location.y = TerrainData::FindFloor(location.x, location.z);

    // What is the direction from the source (location) to the dest (destination)
    VectorDir dir;
    Vector(destination - location).Convert(dir);
    direction = dir.u;

    // Build a formation from the units using the direction to the destination
    Formation::Create(location, direction, subject, 16.0f);

    // Get the source and destination in terms of cells
    Point<F32> avg(location.x, location.z);

    Point<U32> srcCell;
    WorldCtrl::MetresToCellPoint(avg, srcCell);

    Point<U32> destCell;
    WorldCtrl::MetresToCellPoint(Point<F32>(destination.x, destination.z), destCell);

    switch (subject->GetPathFinder().RequestPath(srcCell.x, srcCell.z, destCell.x, destCell.z, traction))
    {
      case PathSearch::Finder::RR_SUBMITTED:
        NextState(0xFDE9D5E3); // "Pathing"
        break;

      case PathSearch::Finder::RR_SAMECELL:
      case PathSearch::Finder::RR_OFFMAP:
        Quit();
        return;

      default:
        ERR_FATAL(("Unknown path request result"))
    }
  }

  //
  // Recycle
  //
  // Check timer and refund resources once recycled
  //
  void UnitRecycle::StateRecycle()
  {
    // Apply progress
    progressTotal -= progressMax;

    // Has recycling finished
    if (progressTotal <= 0.0F)
    {
      // Refund the resources
      if (subject->GetTeam() && refund > 0)
      {
        // Calculate the total refund
        U32 totalRefund = U32(subject->UnitType()->GetRecyclePercentage() * refund);

        // Add to the team
        subject->GetTeam()->AddResourceStore(totalRefund);

        // Report the resource type
        subject->GetTeam()->ReportResource(totalRefund, "resource.recycled");

        // Generate a message
        if (Team::GetDisplayTeam() == subject->GetTeam())
        {
          CON_MSG((TRANSLATE(("#game.messages.recyclerefund", 2, subject->GetUpgradedUnit().GetDesc(), totalRefund))));
        }
      }

      // Trigger finish FX
      subject->StartGenericFX(0x2062BAAD, NULL, TRUE); // "Recycle::Finish"

      // Did this building consume its constructor
      if 
      (
        subject->UnitType()->GetConstructorType() && 
        !subject->UnitType()->GetConstructorType()->GetIsFacility() &&
        subject->UnitType()->GetConstructorConsume()
      )
      {
        // Ensure the constructors resources are initialized
        subject->UnitType()->GetConstructorType()->InitializeResources();

        // Create a fresh new constructor
        UnitObj *unit = subject->UnitType()->GetConstructorType()->SpawnClosest
        (
          subject->Position(), subject->GetTeam()
        );

        // If this team is controlled by AI then assign the 
        // constructor to the primary base (if there is one)
        if (unit && unit->GetTeam() && unit->GetTeam()->IsAI())
        {
          Strategic::Object *object = unit->GetTeam()->GetStrategicObject();
          if (object)
          {
            Strategic::Base *base = object->GetBaseManager().GetPrimaryBase();

            if (base)
            {
              base->AddUnit(unit);
              base->AddConstructor(unit);
            }
          }
        }
      }

      // Remove the object
      subject->MarkForDeletion();

      // Remove boarded object
      if (subject->UnitType()->CanBoard() && subject->GetBoardManager()->InUse())
      {
        subject->GetBoardManager()->GetUnitObj()->SelfDestruct();
      }

      // Recycle completed
      Quit();
    }
  }

    //
    // Undo
    //
    // Undo operation
    //
    void Objects::Undo()
    {
      // Process each object
      for (NList<Data>::Iterator i(&dataList); *i; i++)
      {
        Data *d = *i;

        switch (op)
        {
          // Delete objects that were created
          case OP_CREATE:
            if (d->object.Alive())
            {
              GameObjCtrl::MarkForDeletion(d->object);
            }
            break;

          // Create objects that were deleted
          case OP_DELETE:
          {
            MapObj *m = MapObjCtrl::ObjectNewOnMap(d->type, d->matrix, 0, d->zipped);

            // Restore zipping
            if (d->zipped)
            {
              m->ToggleFootPrint(TRUE);
            }
  
            // Is this a unit
            UnitObj *u = Promote::Object<UnitObjType, UnitObj>(m);

            // Restore correct team
            if (u && d->team)
            {
              u->SetTeam(d->team);
            }

            // Save the old id
            U32 oldId = d->object.DirectId();

            // Now replace all references to the old object with the new object
            for (NList<Base>::Iterator items(&GetHistoryList()); *items; items++)
            {
              Objects *item = Promote<Objects>(*items);

              if (item)
              {
                for (NList<Data>::Iterator data(&item->dataList); *data; data++)
                {
                  if ((*data)->object.DirectId() == oldId)
                  {
                    (*data)->object = m;
                  }
                }
              }
            }

            break;
          }

          // Move objects back to original location
          case OP_MOVE:
            if (d->object.Alive())
            {
              d->object->SetSimCurrent(d->matrix);

              // Toggle claiming if necessary
              UnitObj *unitObj = Promote::Object<UnitObjType, UnitObj>(d->object);

              if (unitObj && unitObj->CanEverMove())
              {
                unitObj->GetDriver()->RemoveFromMapHook();
                unitObj->GetDriver()->AddToMapHook();
              }
            }
            break;

          // Restore zipped state
          case OP_ZIP:
            if (d->object.Alive())
            {
              d->object->ToggleFootPrint(d->zipped);
            }
            break;
        }
      }
    }

  //
  // GoToNextPoint
  //
  void SquadMoveTogether::GoToNextPoint(SquadObj::ListNode *node)
  {
    // We are attempting to go to the next point
    NPoint *p = points[node->data];
    node->data++;
    node->completed = TRUE;

    point = Max(point, node->data);

    ASSERT(node->Alive())
    UnitObj *unit = node->GetData();

    if (p)
    {
      // Mark the time a unit attempts to move to this point
      if (p->timestamp)
      {
        // The squad will need to wait for me to catch up
        if (GameTime::SimCycle() - p->timestamp > timeDiffMax)
        {
//          LOG_DIAG(("Detected that we're [%d] way behind at this point, changing to waiting state", node->Id()))
          NextState(0xCC45C48B); // "Waiting"
        }
      }
      else
      {
        p->timestamp = GameTime::SimCycle();

        // Since we're the first unit to this point we 
        // should check to make sure that no units are 
        // more than two points behind.  If there are,
        // then we'll have to wait here for them

        SquadObj::UnitList::Iterator i(&subject->GetList());
        for (!i; *i; i++)
        {
          if 
          (
            (*i)->Alive() && 
            ((*i)->data + pointDiffMax < point)
          )
          {
//            LOG_DIAG(("We're [%d] first to this point [%d] and detected that [%d] is way behind", node->Id(), node->data, (*i)->Id()))
            NextState(0xCC45C48B); // "Waiting"
            return;
          }
        }
      }

      // Find the closest point to that point that we can go to
      U32 x, z;

      // Use the formation slot offset for this unit
      Vector location(WorldCtrl::CellToMetresX(p->x), 0.0f, WorldCtrl::CellToMetresZ(p->z));

      F32 dir = p->direction + node->slot.direction;
      VectorDir::FixU(dir);

      F32 orient = p->direction + node->slot.orientation;
      VectorDir::FixU(orient);

      Vector offset;
      offset.x = (F32) cos(dir);
      offset.y = 0.0f;
      offset.z = (F32) sin(dir);
      offset *= node->slot.distance;
      offset += location;

      // Make sure the point is on the map
      WorldCtrl::ClampMetreMap(offset.x, offset.z);

      x = WorldCtrl::MetresToCellX(offset.x);
      z = WorldCtrl::MetresToCellZ(offset.z);

      if (PathSearch::FindClosestCell(unit->MapType()->GetTractionIndex(unit->MapType()->GetDefaultLayer()), x, z, x, z, meetingRange))
      {
        node->completed = FALSE;
        unit->PrependTask(new Tasks::UnitMove(unit, offset));
      }
      else
      {
        // Cound not find a cell, go to the next point
        GoToNextPoint(node);
      }
    }
  }