Skip to content
Snippets Groups Projects
ConvoyUnit.xml 24.47 KiB
<?xml version="1.0" encoding="utf-8" standalone="no"?>
<HTNNode AllowMsg="true" Name="ConvoyUnit" Type="DEFAULT">
  <Parent>null</Parent>
  <Code IsFile="false" />
  <Import />
  <HTNNode AllowMsg="true" Name="initInfo" Type="DEFAULT">
    <Parent>BasicTree</Parent>
    <Code IsFile="false">if _gt_activeNode.getVar("isInited") == None:
	_gt_activeNode.putVar("isInited", 1)
	_htn_precon_ret=1
</Code>
    <Import />
    <HTNNode AllowMsg="true" Name="createData" Type="DEFAULT">
      <Parent>start</Parent>
      <Code IsFile="false"># create data
borg.redNumSetups = dict()

</Code>
      <Import />
    </HTNNode>
    <HTNNode AllowMsg="true" Name="start" Type="DEFAULT">
      <Parent>addReplanTriggers</Parent>
      <Code IsFile="false">
#from HTNBehaviors import SendEntityEventDelay
#
#printMessage("Convoy started", True)
#
#SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_MoveToPoint", ["ASSEMBLE", "ASSEMBLY_LOCATION"], 5.0)
#borg.delay=1.0
#
#borg.redUnitStatus[state.getCurrentUnitName()] = 0
#

# log data 
if state.isCommander():
    from HTNBehaviors import SendEntityEventDelay
    from HTNBehaviors import ConvertToJavaList
    SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "CONVOY_CREATED" "" ])], 0)

</Code>
      <Import />
    </HTNNode>
    <HTNNode AllowMsg="true" Name="addReplanTriggers" Type="INTERRUPT">
      <Parent>initInfo</Parent>
      <Code IsFile="false"># model events
#goalContainer.getCurrentExecutingStack().addReplanTrigger("ModelEvent")
#goalContainer.getCurrentExecutingStack().addReplanTrigger("AtAControlMeasure")

# goal tracker events
#goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_Event")
goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_MoveToPoint")
goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_Assemble")
goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_MoveCompleted")
goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_ConvoySetup")
goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_ConvoySetupComplete")
goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_ConvoyReturn")
goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_ReturnCompleted")
goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_ConvoyPackUp")
goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_ConvoyPackUpComplete")
goalContainer.getCurrentExecutingStack().addReplanTrigger("GoalTracker_ConvoyWaitAtBaseComplete")
</Code>
      <Import />
    </HTNNode>
  </HTNNode>
  <HTNNode AllowMsg="true" Name="events" Type="DEFAULT">
    <Parent>BasicTree</Parent>
    <Code IsFile="false" />
    <Import />
    <HTNNode AllowMsg="true" Name="isGoalTrackerEvent" Type="DEFAULT">
      <Parent>events</Parent>
      <Code IsFile="false">if state.getLastTrigger().startswith("doGoalTracker_"):
	_htn_precon_ret=1
</Code>
      <Import />
      <HTNNode AllowMsg="true" Name="isAssemble" Type="DEFAULT">
        <Parent>isGoalTracker_MoveToPoint</Parent>
        <Code IsFile="false">if state.getLastTrigger() == "doGoalTracker_Assemble":
	_htn_precon_ret=1
</Code>
        <Import />
        <HTNNode AllowMsg="true" Name="assemble" Type="INTERRUPT">
          <Parent>New Node</Parent>
          <Code IsFile="false">from HTNBehaviors import SendEntityEventDelay

# start the assembly movement
printMessage("Assembling...", True)

randSpd = state.getLastTriggerParams()[0].get(0)
SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_MoveToPoint", ["ASSEMBLE", randSpd, "ASSEMBLY_LOCATION"], 5.0)
borg.delay=1.0

borg.redUnitStatus[state.getCurrentUnitName()] = 0

</Code>
          <Import />
        </HTNNode>
      </HTNNode>
      <HTNNode AllowMsg="true" Name="isGoalTracker_MoveToPoint" Type="DEFAULT">
        <Parent>printGoalTrackerEvent</Parent>
        <Code IsFile="false">if state.getLastTrigger() == "doGoalTracker_MoveToPoint":
	_htn_precon_ret=1
</Code>
        <Import />
        <HTNNode AllowMsg="true" Name="moveToPoint" Type="INTERRUPT">
          <Parent>printGoalTrackerEvent</Parent>
          <Code IsFile="false">from HTNBehaviors import CreateNetworkMove
from HTNBehaviors import SetRedUnitActivity


# whenever the unit moves this node is what makes it move
params = state.getLastTriggerParams()[0]


wps = []
for i in range(params.size()):
    if i&gt;1:
        wps.append(params.get(i))

_gt_activeNode.putVar("moveReason", params.get(0))
_gt_activeNode.putVar("moveDestination", wps[0])
randSpd = params.get(1)

# check if the point we're moving to is an attack position
attackFlag = "ATTACK" in params.get(2)
if attackFlag:
    SendEntityEventDelay("RFC", "GoalTracker_StartAttackMove", [state.getCurrentUnitName()], 1.0)


borg.redConvoysWaiting[state.getCurrentUnit().getName()].append(info.getMyAssignedName())

# use the network move tree so the meta terrain functionality is used
CreateNetworkMove(
    state.getCurrentLocation(), 
    wps, 
    randSpd, 
    None, 
    info.getMyAssignedName(), 
    info.getMyAssignedName(), 
    "GoalTracker_MoveCompleted", 
    "MOVE",
    borg.delay)
borg.delay+=5.0
printMessage("Starting move("+str(attackFlag)+"): "+str(wps)+" Spd: "+str(randSpd), True)

#####################################################
# set activity to log
if _gt_activeNode.getVar("moveReason") == "CONVOY":
    #    borg.redUnitActivity[state.getCurrentUnitName()]="MOVE_TO_DEPLOYMENT_SITE"
    SetRedUnitActivity(state.getCurrentUnitName(), "MOVE_TO_DEPLOYMENT_SITE")

# log data 
if state.isCommander():
    from HTNBehaviors import SendEntityEventDelay
    from HTNBehaviors import ConvertToJavaList
    SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "MOVE_TO_POINT", str(wps) ])], 0)

</Code>
          <Import />
        </HTNNode>
      </HTNNode>
      <HTNNode AllowMsg="true" Name="isGoalTracker_MoveCompleted" Type="DEFAULT">
        <Parent>printGoalTrackerEvent</Parent>
        <Code IsFile="false">if state.getLastTrigger() == "doGoalTracker_MoveCompleted":
	_htn_precon_ret=1
</Code>
        <Import />
        <HTNNode AllowMsg="true" Name="moveCompleted" Type="INTERRUPT">
          <Parent>printGoalTrackerEvent</Parent>
          <Code IsFile="false">from HTNBehaviors import SendUnitEventDelay
from HTNBehaviors import SendEntityEvent
import cxxi.model.behavior.PythonUtilities as PythonUtilities
from HTNBehaviors import SendEntityEventDelay
from HTNBehaviors import ConvertToJavaList

# used whenver the unit finishes moving (any move)
borg.redConvoysWaiting[state.getCurrentUnit().getName()].remove(info.getMyAssignedName())

if len(borg.redConvoysWaiting[state.getCurrentUnit().getName()])==0:
    moveReason = _gt_activeNode.getVar("moveReason")
    moveDestination = _gt_activeNode.getVar("moveDestination")
    printMessage("MOVE WAS COMPLETED "+moveReason+" "+moveDestination, True)

    

    if moveReason == "ASSEMBLE":
        # let the unit know TODO: THis should probably come from the RFC

#        randSpd = PythonUtilities._py_getRandomNumber("UNIFORM", [0.0, 1.0])
#        randSpd = 10.0 + (40.0 * randSpd)

        # get a random speed
        if borg.params_randSpdOverride &gt; 0:
            randSpd = borg.params_randSpdOverride
        else:
            randVal = PythonUtilities._py_getRandomNumber("UNIFORM", [0.0, 1.0])
            randSpd = borg.params_randSpdMin + (borg.params_randSpdVar * randVal)

        destName = borg.redConvoyDest[state.getCurrentUnit().getName()][0]
        del borg.redConvoyDest[state.getCurrentUnit().getName()][0]

        SendUnitEventDelay(state.getCurrentUnit().getName(), "GoalTracker_MoveToPoint", ["CONVOY", randSpd, destName], borg.delay)
        borg.delay=1.0
        # log data 
        SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "CONVOY_ARRIVED_AT_ASSEMBLY" "" ])], 0)

    elif moveReason == "CONVOY":
        # setup off road
        destName = "EMPTY"
        if len(borg.redConvoyDest[state.getCurrentUnit().getName()])&gt;0:
            destName = borg.redConvoyDest[state.getCurrentUnit().getName()][0]
#        printMessage("LOC:"+str(destName), True)

        SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "CONVOY_ARRIVED" "" ])], 0.001)

        # note this assumes an ASSEMBLY_LOCATION has been inserted between each location
        # also the head of the list is one location ahead hence we check the next location
        # is an assembly location if we need to do setups here
        if destName == "ASSEMBLY_LOCATION" or destName == "EMPTY":
            cmdName=""
            if state.isCommander():
                cmdName = info.getMyAssignedName()
            else:
                cmdName = state.getCurrentCommander().getAssignedName()

            # calculate how long on station they should be
            borg.redNumSetups[state.getCurrentUnitName()]=borg.params_redNumSetups

            SendEntityEvent(cmdName, "GoalTracker_ConvoySetup", [])

        else:
            # we're at an assembly location, just wait
            cmdName=""
            if state.isCommander():
                cmdName = info.getMyAssignedName()
            else:
                cmdName = state.getCurrentCommander().getAssignedName()

            # calculate how long we should wait
            randVal = PythonUtilities._py_getRandomNumber("UNIFORM", [0.0, 1.0])
            waitTime = borg.params_redWaitAtBaseForMin + (borg.params_redWaitAtBaseForVar * randVal)

            SendEntityEventDelay(cmdName, "GoalTracker_ConvoyWaitAtBaseComplete", [], waitTime)
            # log data 
            SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "WAIT_AT_BASE" "" ])], 0.001)

</Code>
          <Import />
        </HTNNode>
      </HTNNode>
      <HTNNode AllowMsg="true" Name="isGoalTracker_ConvoySetup" Type="DEFAULT">
        <Parent>printGoalTrackerEvent</Parent>
        <Code IsFile="false">if state.getLastTrigger() == "doGoalTracker_ConvoySetup":
	_htn_precon_ret=1
</Code>
        <Import />
        <HTNNode AllowMsg="true" Name="convoySetup" Type="INTERRUPT">
          <Parent>printGoalTrackerEvent</Parent>
          <Code IsFile="false">import mtry.cxxi.model.HierarchicalTaskNetwork.PythonUtilities.PythonTerrain as PythonTerrain
from java.util import ArrayList
from HTNBehaviors import CreateBasicMove
from HTNBehaviors import ConvertToJavaList
from HTNBehaviors import SetRedUnitActivity

# start the convoy setup
printMessage("Starting convoy setup", True)

nlocs = state.getCurrentUnit().getMembers().size()
formName = borg.redFormsByUnit[state.getCurrentUnit().getName()]

setupLocs = PythonTerrain._py_createFormation(info.getMySelf(), borg.formationsByName[formName])

if setupLocs.size()&lt;nlocs:
    nlocs = setupLocs.size()

borg.delay=5
for i in range(nlocs):
    member = state.getCurrentUnit().getMembers().get(i)
    loc = setupLocs.get(i)
    orientation = borg.formationsByName[formName][i*4+2]
    CreateBasicMove([loc], 3.0, None, True, orientation, member.getAssignedName(), info.getMyAssignedName(), "GoalTracker_ConvoySetupComplete", "MOVE", borg.delay)
    borg.delay+=5.0

_gt_activeNode.putVar("setupNum", nlocs)

printMessage("Convoy setup for "+str(borg.formationsByName[formName].size()/2)+" vehicles", True)

#####################################################
# set activity to log
#borg.redUnitActivity[state.getCurrentUnitName()]="DEPLOY_AT_SITE"
SetRedUnitActivity(state.getCurrentUnitName(), "DEPLOY_AT_SITE")

# log data 
if state.isCommander():
    from HTNBehaviors import SendEntityEventDelay
    from HTNBehaviors import ConvertToJavaList
    SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "SETUP_STARTED" "" ])], 0)

</Code>
          <Import />
        </HTNNode>
      </HTNNode>
      <HTNNode AllowMsg="true" Name="isGoalTracker_ConvoySetupComplete" Type="DEFAULT">
        <Parent>printGoalTrackerEvent</Parent>
        <Code IsFile="false">if state.getLastTrigger() == "doGoalTracker_ConvoySetupComplete":
	_htn_precon_ret=1
</Code>
        <Import />
        <HTNNode AllowMsg="true" Name="convoySetupComplete" Type="INTERRUPT">
          <Parent>printGoalTrackerEvent</Parent>
          <Code IsFile="false">import cxxi.model.behavior.PythonUtilities as PythonUtilities
from HTNBehaviors import SendEntityEventDelay
from HTNBehaviors import SetRedUnitActivity

# end the setup process and schedule when to pack up
borg.redUnitStatus[state.getCurrentUnitName()] = borg.redUnitStatus[state.getCurrentUnitName()] + 1
setupNum = _gt_activeNode.getVar("setupNum")

printMessage("Setup completed rus: "+str(borg.redUnitStatus[state.getCurrentUnitName()])+" setupNum: "+str(setupNum), True)
if borg.redUnitStatus[state.getCurrentUnitName()]==setupNum:
    rn = PythonUtilities._py_getRandomNumber("UNIFORM", [0.0, 1.0])
    rn = borg.params_redSetupTimeMin + rn * borg.params_redSetupTimeVar
    
    # commander name
    cmdName=""
    if state.isCommander():
        cmdName = info.getMyAssignedName()
    else:
        cmdName = state.getCurrentCommander().getAssignedName()

    # only pack up if it's not an attack run or we still have destinations left to move to
    if not borg.isAttackRun or len(borg.redConvoyDest[state.getCurrentUnit().getName()]) &gt; 0:
        SendEntityEventDelay(cmdName, "GoalTracker_ConvoyPackUp", [], rn)

    for member in state.getCurrentUnit().getMembers():
        if "RADAR" in member.getProfile().getName():
            SendEntityEventDelay(member.getAssignedName(), "GoalTracker_RadarStart", [rn], 0)

    #####################################################
    # set activity to log
    #borg.redUnitActivity[state.getCurrentUnitName()]="OPERATE_AT_SITE"
    SetRedUnitActivity(state.getCurrentUnitName(), "OPERATE_AT_SITE")

    # log data 
    if state.isCommander():
        from HTNBehaviors import SendEntityEventDelay
        from HTNBehaviors import ConvertToJavaList
        SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "SETUP_COMPLETE" "" ])], 0)

</Code>
          <Import />
        </HTNNode>
      </HTNNode>
      <HTNNode AllowMsg="true" Name="isGoalTracker_ConvoyPackUp" Type="DEFAULT">
        <Parent>isGoalTracker_ConvoyReturn</Parent>
        <Code IsFile="false">if state.getLastTrigger() == "doGoalTracker_ConvoyPackUp":
	_htn_precon_ret=1
</Code>
        <Import />
        <HTNNode AllowMsg="true" Name="packUp" Type="INTERRUPT">
          <Parent>isGoalTracker_ConvoyPackUp</Parent>
          <Code IsFile="false">import cxxi.model.behavior.PythonUtilities as PythonUtilities
from HTNBehaviors import SendEntityEventDelay
from HTNBehaviors import SetRedUnitActivity

# start the pack up process

# commander name
cmdName=""
if state.isCommander():
    cmdName = info.getMyAssignedName()
else:
    cmdName = state.getCurrentCommander().getAssignedName()

SendEntityEventDelay(cmdName, "GoalTracker_ConvoyPackUpComplete", [], 300.0)
printMessage("Convoy packing up: "+str(state.getCurrentUnitName()), True)
borg.delay=0

#####################################################
# set activity to log
#borg.redUnitActivity[state.getCurrentUnitName()]="PACK_UP_AT_SITE"
SetRedUnitActivity(state.getCurrentUnitName(), "PACK_UP_AT_SITE")

# log data 
if state.isCommander():
    from HTNBehaviors import SendEntityEventDelay
    from HTNBehaviors import ConvertToJavaList
    SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "PACK_UP_STARTED" "" ])], 0)


</Code>
          <Import />
        </HTNNode>
      </HTNNode>
      <HTNNode AllowMsg="true" Name="isGoalTracker_ConvoyPackUpComplete" Type="DEFAULT">
        <Parent>isGoalTracker_ConvoyReturn</Parent>
        <Code IsFile="false">if state.getLastTrigger() == "doGoalTracker_ConvoyPackUpComplete":
	_htn_precon_ret=1
</Code>
        <Import />
        <HTNNode AllowMsg="true" Name="packUpComplete" Type="INTERRUPT">
          <Parent>isGoalTracker_ConvoyPackUp</Parent>
          <Code IsFile="false">import cxxi.model.behavior.PythonUtilities as PythonUtilities
from HTNBehaviors import SendEntityEventDelay

# complete the packup process

# reset the setup count
borg.redUnitStatus[state.getCurrentUnitName()] = 0

if borg.redNumSetups[state.getCurrentUnitName()] &gt; 1: # check against 1 because at least one setup always occurs
    # time on station hasn't elapsed, keep practicing setup
    cmdName=""
    if state.isCommander():
        cmdName = info.getMyAssignedName()
    else:
        cmdName = state.getCurrentCommander().getAssignedName()

    SendEntityEvent(cmdName, "GoalTracker_ConvoySetup", [])
    printMessage("Setting up again: "+str(cmdName), True)
    borg.redNumSetups[state.getCurrentUnitName()]=borg.redNumSetups[state.getCurrentUnitName()]-1

    # reset the setup count
    borg.redUnitStatus[state.getCurrentUnitName()] = 0

elif len(borg.redConvoyDest[state.getCurrentUnit().getName()])==0:
    # no more destinations go home if it's not an attack run
    printMessage("Convoy pack up complete: "+str(state.getCurrentUnitName()), True)
    if not borg.isAttackRun:
        SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_ConvoyReturn", [], rn)
        borg.delay=0

else:
    # go to next destination
#    randSpd = PythonUtilities._py_getRandomNumber("UNIFORM", [0.0, 1.0])
#    randSpd = 10.0 + (40.0 * randSpd)

    # get a random speed
    if borg.params_randSpdOverride &gt; 0:
        randSpd = borg.params_randSpdOverride
    else:
        randVal = PythonUtilities._py_getRandomNumber("UNIFORM", [0.0, 1.0])
        randSpd = borg.params_randSpdMin + (borg.params_randSpdVar * randVal)

    destName = borg.redConvoyDest[state.getCurrentUnit().getName()][0]
    del borg.redConvoyDest[state.getCurrentUnit().getName()][0]

#    # reset the setup count
#    borg.redUnitStatus[state.getCurrentUnitName()] = 0
#
    SendUnitEventDelay(state.getCurrentUnit().getName(), "GoalTracker_MoveToPoint", ["CONVOY", randSpd, destName], borg.delay)
    borg.delay=1.0

# log data 
if state.isCommander():
    from HTNBehaviors import SendEntityEventDelay
    from HTNBehaviors import ConvertToJavaList
    SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "PACKUP_COMPLETE" "" ])], 0)
</Code>
          <Import />
        </HTNNode>
      </HTNNode>
      <HTNNode AllowMsg="true" Name="isGoalTracker_ConvoyWaitAtBaseComplete" Type="DEFAULT">
        <Parent>isGoalTracker_ConvoyReturn</Parent>
        <Code IsFile="false">if state.getLastTrigger() == "doGoalTracker_ConvoyWaitAtBaseComplete":
	_htn_precon_ret=1
</Code>
        <Import />
        <HTNNode AllowMsg="true" Name="waitComplete" Type="INTERRUPT">
          <Parent>isGoalTracker_ConvoyPackUp</Parent>
          <Code IsFile="false">import cxxi.model.behavior.PythonUtilities as PythonUtilities
from HTNBehaviors import SendEntityEventDelay
from HTNBehaviors import ConvertToJavaList

# complete the wait process

# reset the setup count
borg.redUnitStatus[state.getCurrentUnitName()] = 0

# go to next destination

# get a random speed
if borg.params_randSpdOverride &gt; 0:
    randSpd = borg.params_randSpdOverride
else:
    randVal = PythonUtilities._py_getRandomNumber("UNIFORM", [0.0, 1.0])
    randSpd = borg.params_randSpdMin + (borg.params_randSpdVar * randVal)

destName = borg.redConvoyDest[state.getCurrentUnit().getName()][0]
del borg.redConvoyDest[state.getCurrentUnit().getName()][0]
SendUnitEventDelay(state.getCurrentUnit().getName(), "GoalTracker_MoveToPoint", ["CONVOY", randSpd, destName], borg.delay)
borg.delay=1.0

# log data 
if state.isCommander():
    SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "WAIT_AT_BASE_COMPLETE" "" ])], 0)
</Code>
          <Import />
        </HTNNode>
      </HTNNode>
      <HTNNode AllowMsg="true" Name="isGoalTracker_ConvoyReturn" Type="DEFAULT">
        <Parent>printGoalTrackerEvent</Parent>
        <Code IsFile="false">if state.getLastTrigger() == "doGoalTracker_ConvoyReturn":
	_htn_precon_ret=1
</Code>
        <Import />
        <HTNNode AllowMsg="true" Name="convoyReturn" Type="INTERRUPT">
          <Parent>isGoalTracker_ConvoyReturn</Parent>
          <Code IsFile="false">from HTNBehaviors import SetRedUnitActivity

printMessage("Need to return", True)

# return to base

borg.redUnitStatus[state.getCurrentUnitName()]=0


#randSpd = PythonUtilities._py_getRandomNumber("UNIFORM", [0.0, 1.0])
#randSpd = 10.0 + (40.0 * randSpd)

# get a random speed
if borg.params_randSpdOverride &gt; 0:
    randSpd = borg.params_randSpdOverride
else:
    randVal = PythonUtilities._py_getRandomNumber("UNIFORM", [0.0, 1.0])
    randSpd = borg.params_randSpdMin + (borg.params_randSpdVar * randVal)

for m in state.getCurrentUnit().getMembers():
    CreateNetworkMove(
        m.getPhysicalState().getGroundTruthLocation(), 
        ["ASSEMBLY_LOCATION"], 
        randSpd, 
        None, 
        m.getAssignedName(), 
        info.getMyAssignedName(), 
        "GoalTracker_ReturnCompleted", 
        "MOVE",
        borg.delay)
    borg.delay+=5.0

printMessage("Returning", True)

#####################################################
# set activity to log
#borg.redUnitActivity[state.getCurrentUnitName()]="RETURN_TO_GARRISON"
SetRedUnitActivity(state.getCurrentUnitName(), "RETURN_TO_GARRISON")

# log data 
if state.isCommander():
    from HTNBehaviors import SendEntityEventDelay
    from HTNBehaviors import ConvertToJavaList
    SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "RETURNING_TO_BASE" "" ])], 0)

</Code>
          <Import />
        </HTNNode>
      </HTNNode>
      <HTNNode AllowMsg="true" Name="isReturnCompleted" Type="DEFAULT">
        <Parent>printGoalTrackerEvent</Parent>
        <Code IsFile="false">if state.getLastTrigger() == "doGoalTracker_ReturnCompleted":
	_htn_precon_ret=1
</Code>
        <Import />
        <HTNNode AllowMsg="true" Name="returnCompleted" Type="INTERRUPT">
          <Parent>New Node</Parent>
          <Code IsFile="false">import cxxi.model.behavior.PythonUtilities as PythonUtilities
from HTNBehaviors import SendEntityEventDelay
from HTNBehaviors import SetRedUnitActivity

# tell the RFC we've returned to base and we can be 'reclaimed' (ie, disband the unit and put them back in
# the available entity list)
borg.redUnitStatus[state.getCurrentUnitName()] = borg.redUnitStatus[state.getCurrentUnitName()] + 1
#setupNum = _gt_activeNode.getVar("setupNum")

#printMessage("Setup completed", True)
if borg.redUnitStatus[state.getCurrentUnitName()]==state.getCurrentUnit().getMembers().size():
    printMessage("Convoy return", True)
    SendEntityEventDelay("RFC", "GoalTracker_ReclaimConvoy", [state.getCurrentUnitName()], 1.0)
    
    #####################################################
    # set activity to log
    #borg.redUnitActivity[state.getCurrentUnitName()] = None
    SetRedUnitActivity(state.getCurrentUnitName(), None)

    # log data 
    if state.isCommander():
        from HTNBehaviors import SendEntityEventDelay
        from HTNBehaviors import ConvertToJavaList
        SendEntityEventDelay(info.getMyAssignedName(), "GoalTracker_LogMsg", ["UnitLogger", "UNIT_NAME\tACTION\tDATA", ConvertToJavaList([ state.getCurrentUnitName(), "ARRIVED_AT_BASE" "" ])], 0)

</Code>
          <Import />
        </HTNNode>
      </HTNNode>
      <HTNNode AllowMsg="true" Name="printGoalTrackerEvent" Type="INTERRUPT">
        <Parent>isGoalTrackerEvent</Parent>
        <Code IsFile="false">printMessage("GOAL TRACKER EVENT"+state.getLastTrigger(), True)
</Code>
        <Import />
      </HTNNode>
    </HTNNode>
    <HTNNode AllowMsg="true" Name="modelEvents" Type="DEFAULT">
      <Parent>events</Parent>
      <Code IsFile="false" />
      <Import />
      <HTNNode AllowMsg="true" Name="printEvent" Type="INTERRUPT">
        <Parent>modelEvents</Parent>
        <Code IsFile="false">printMessage("EVENT"+state.getLastTrigger(), True)</Code>
        <Import />
      </HTNNode>
    </HTNNode>
  </HTNNode>
</HTNNode>