BVB Source Codes

CRYENGINE Show ScriptBind_AI.cpp Source code

Return Download CRYENGINE: download ScriptBind_AI.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /********************************************************************
  4.    -------------------------------------------------------------------------
  5.    File name:   ScriptBind_AI.h
  6.    Version:     v1.00
  7.    Description: Core scriptbinds for the AI system
  8.    Notes:       Many methods in this file use a series of early-out tests
  9.              Hence CCCPOINT often placed at the end, where work is done
  10.    -------------------------------------------------------------------------
  11.    History:
  12.    - 3:11:2004   - Created by Kirill Bulatsev
  13.    -13:02:2008   - Moved into AI system by Matthew
  14.  
  15.  *********************************************************************/
  16.  
  17. #include "StdAfx.h"
  18. #include "ScriptBind_AI.h"
  19. #include <CrySystem/ISystem.h>
  20. #include <CryAISystem/IAISystem.h>
  21. #include <CryAISystem/IAgent.h>
  22. #include <CryAISystem/IAIGroup.h>
  23. #include <CryGame/IGame.h>
  24. #include "GoalPipe.h"
  25. #include "GoalOp.h"
  26. #include "GoalOpFactory.h"
  27. #include "Puppet.h"
  28. #include "AIVehicle.h"
  29. #include "CodeCoverageTracker.h"
  30. #include <CryString/StringUtils.h>
  31.  
  32. #include "GameSpecific/GoalOp_Crysis2.h"
  33.  
  34. #include "AIActions.h"
  35.  
  36. #include <CryEntitySystem/IEntityComponent.h>
  37. #include <CryFlowGraph/IFlowSystem.h>
  38. #include <CryAISystem/IInterestSystem.h>
  39. #include "TacticalPointSystem/TacticalPointSystem.h"
  40. #include "Communication/CommunicationManager.h"
  41. #include "SelectionTree/SelectionTreeManager.h"
  42. #include "Group/GroupManager.h"
  43. #include "TargetSelection/TargetTrackManager.h"
  44. #include "AIBubblesSystem/AIBubblesSystem.h"
  45. #include "Sequence/SequenceManager.h"
  46. #include <CryAISystem/IBlackBoard.h>
  47. #include <CryAISystem/IFactionMap.h>
  48. #include <ctype.h>
  49. #include "PipeUser.h"
  50.  
  51. #include <list>
  52. #include <functional>
  53.  
  54. #if CRY_PLATFORM_LINUX || CRY_PLATFORM_ANDROID
  55.         #include <float.h> // for FLT_MAX
  56. #endif
  57. #include <CryMath/Cry_GeoDistance.h>
  58.  
  59. #include "GoalPipeXMLReader.h"
  60. #include <CryAISystem/IMovementSystem.h>
  61. #include <CryAISystem/MovementRequest.h>
  62.  
  63. #include "BehaviorTree/BehaviorTreeManager.h"
  64.  
  65. //#pragma optimize("", off)
  66. //#pragma inline_depth(0)
  67.  
  68. // AI Object filters: define them as one-bit binary masks (1,2,4,8 etc..)
  69. #define AIOBJECTFILTER_SAMEFACTION     1 // AI objects of the same species of the querying object.
  70. #define AIOBJECTFILTER_SAMEGROUP       2 // AI objects of the same group of the querying object or with no group.
  71. #define AIOBJECTFILTER_NOGROUP         4 // AI objects with Group ID ==AI_NOGROUP.
  72. #define AIOBJECTFILTER_INCLUDEINACTIVE 8 // AI objects and Inactive AI Objects.
  73.  
  74. #define AI_NOGROUP                     -1 // group id == AI_NOGROUP -> the entity has no group
  75.  
  76. // AI Object search methods.
  77. //-------------------- for anchors -----------------------------
  78. #define AIANCHOR_NEAREST                   0
  79. #define AIANCHOR_NEAREST_IN_FRONT          1
  80. #define AIANCHOR_RANDOM_IN_RANGE           2
  81. #define AIANCHOR_RANDOM_IN_RANGE_FACING_AT 3
  82. #define AIANCHOR_NEAREST_FACING_AT         4
  83. #define AIANCHOR_NEAREST_TO_REFPOINT       5
  84. #define AIANCHOR_FARTHEST                  6
  85. #define AIANCHOR_BEHIND_IN_RANGE           7
  86. #define AIANCHOR_LEFT_TO_REFPOINT          8
  87. #define AIANCHOR_RIGHT_TO_REFPOINT         9
  88. #define AIANCHOR_HIDE_FROM_REFPOINT        10
  89. //-------------------- bit flags -------------------------------
  90. #define AIANCHOR_SEES_TARGET               (1 << 6)
  91. #define AIANCHOR_BEHIND                    (1 << 7)
  92.  
  93. enum EAIForcedEventTypes
  94. {
  95.         SOUND_INTERESTING = 0,
  96.         SOUND_THREATENING = 1,
  97. };
  98.  
  99. enum EAIUseCoverAction
  100. {
  101.         COVER_HIDE   = 0,
  102.         COVER_UNHIDE = 1,
  103. };
  104.  
  105. enum EAIAdjustAimAction
  106. {
  107.         ADJUSTAIM_AIM  = 0,
  108.         ADJUSTAIM_HIDE = 1,
  109. };
  110.  
  111. enum EAIProximityFlags
  112. {
  113.         AIPROX_SIGNAL_ON_OBJ_DISABLE = 0x1,
  114.         AIPROX_VISIBLE_TARGET_ONLY   = 0x2,
  115. };
  116.  
  117. enum EAIParamNames
  118. {
  119.         AIPARAM_SIGHTRANGE = 1,
  120.         AIPARAM_ATTACKRANGE,
  121.         AIPARAM_ACCURACY,
  122.         AIPARAM_GROUPID,
  123.         AIPARAM_FOVPRIMARY,
  124.         AIPARAM_FOVSECONDARY,
  125.         AIPARAM_COMMRANGE,
  126.         AIPARAM_FWDSPEED,
  127.         AIPARAM_FACTION,
  128.         AIPARAM_FACTIONHOSTILITY,
  129.         AIPARAM_STRAFINGPITCH,
  130.         AIPARAM_COMBATCLASS,
  131.         AIPARAM_INVISIBLE,
  132.         AIPARAM_PERCEPTIONSCALE_VISUAL,
  133.         AIPARAM_PERCEPTIONSCALE_AUDIO,
  134.         AIPARAM_CLOAK_SCALE,
  135.         AIPARAM_FORGETTIME_TARGET,
  136.         AIPARAM_FORGETTIME_SEEK,
  137.         AIPARAM_FORGETTIME_MEMORY,
  138.         AIPARAM_LOOKIDLE_TURNSPEED,
  139.         AIPARAM_LOOKCOMBAT_TURNSPEED,
  140.         AIPARAM_AIM_TURNSPEED,
  141.         AIPARAM_FIRE_TURNSPEED,
  142.         AIPARAM_MELEE_DISTANCE,
  143.         AIPARAM_MELEE_SHORT_DISTANCE,
  144.         AIPARAM_MIN_ALARM_LEVEL,
  145.         AIPARAM_PROJECTILE_LAUNCHDIST,
  146.         AIPARAM_SIGHTDELAY,
  147.         AIPARAM_SIGHTNEARRANGE,
  148.         AIPARAM_CLOAKED,
  149.  
  150.         // Warface perception extra data
  151.         AIPARAM_PERCEPTIONAUDIORANGE_AGGRESSIVE,
  152.         AIPARAM_PERCEPTIONAUDIORANGE_THREATENING,
  153.         AIPARAM_PERCEPTIONAUDIORANGE_INTERESTING,
  154.         AIPARAM_PERCEPTIONVISUALTIME_NEARREACT,
  155.         AIPARAM_PERCEPTIONVISUALTIME_AGGRESSIVE,
  156.         AIPARAM_PERCEPTIONVISUALTIME_THREATENING,
  157.         AIPARAM_PERCEPTIONVISUALTIME_INTERESTING,
  158.         AIPARAM_PERCEPTIONVISUAL_TARGETSTATIONARYTIME,
  159.         AIPARAM_PERCEPTIONVISUAL_TARGETLONGMEMORYTIME,
  160.         AIPARAM_PERCEPTIONVISUAL_CANFORGET,
  161. };
  162.  
  163. enum EAIMoveAbilityNames
  164. {
  165.         AIMOVEABILITY_OPTIMALFLIGHTHEIGHT = 1,
  166.         AIMOVEABILITY_MINFLIGHTHEIGHT,
  167.         AIMOVEABILITY_MAXFLIGHTHEIGHT,
  168.         AIMOVEABILITY_TELEPORTENABLE,
  169.         AIMOVEABILITY_USEPREDICTIVEFOLLOWING
  170. };
  171.  
  172. enum EStickFlags
  173. {
  174.         STICK_BREAK       = 0x01,
  175.         STICK_SHORTCUTNAV = 0x02,
  176. };
  177.  
  178. enum EDirection
  179. {
  180.         DIR_NORTH = 0,
  181.         DIR_SOUTH,
  182.         DIR_EAST,
  183.         DIR_WEST
  184. };
  185.  
  186. enum FindObjectOfTypeFlags
  187. {
  188.         AIFO_FACING_TARGET              = 0x0001,
  189.         AIFO_NONOCCUPIED                = 0x0002,
  190.         AIFO_CHOOSE_RANDOM              = 0x0004,
  191.         AIFO_NONOCCUPIED_REFPOINT       = 0x0008,
  192.         AIFO_USE_BEACON_AS_FALLBACK_TGT = 0x0010,
  193.         AIFO_NO_DEVALUE                 = 0x0020,
  194. };
  195.  
  196. #undef GET_ENTITY
  197. #define GET_ENTITY(i)                              \
  198.   ScriptHandle hdl;                                \
  199.   pH->GetParam(i, hdl);                            \
  200.   EntityId nID     = static_cast<EntityId>(hdl.n); \
  201.   IEntity* pEntity = gEnv->pEntitySystem->GetEntity(nID);
  202.  
  203. bool GetSoundPerceptionDescriptorHelper(IPuppet* pPuppet, int iSoundType, SSoundPerceptionDescriptor& sDescriptor)
  204. {
  205.         if (pPuppet)
  206.         {
  207.                 CPuppet* pCPuppet = static_cast<CPuppet*>(pPuppet);
  208.                 return pCPuppet->GetSoundPerceptionDescriptor(static_cast<EAISoundStimType>(iSoundType), sDescriptor);
  209.         }
  210.  
  211.         return false;
  212. }
  213.  
  214. int ParsePostureInfo(CPuppet* pPuppet, const SmartScriptTable& posture, const PostureManager::PostureInfo& base, int parentID, IScriptSystem* pSS)
  215. {
  216.         PostureManager::PostureInfo postureInfo = base;
  217.         postureInfo.parentID = parentID;
  218.         postureInfo.enabled = true;
  219.  
  220.         int type = postureInfo.type;
  221.         if (!posture->GetValue("type", type) && (parentID == -1))
  222.         {
  223.                 pSS->RaiseError("<CScriptBind_AI> "
  224.                                 "SetPostures: Missing or invalid posture type!");
  225.  
  226.                 return -1;
  227.         }
  228.  
  229.         postureInfo.type = (PostureManager::PostureType)type;
  230.  
  231.         const char* name = "UnnamedPosture";
  232.         if (posture->GetValue("name", name))
  233.                 postureInfo.name = name;
  234.  
  235.         posture->GetValue("lean", postureInfo.lean);
  236.         posture->GetValue("peekOver", postureInfo.peekOver);
  237.  
  238.         const char* agInput = "";
  239.         if (posture->GetValue("agInput", agInput))
  240.                 postureInfo.agInput = agInput;
  241.  
  242.         int stance = postureInfo.stance;
  243.         posture->GetValue("stance", stance);
  244.         postureInfo.stance = (EStance)stance;
  245.  
  246.         posture->GetValue("priority", postureInfo.priority);
  247.  
  248.         bool templateOnly = false;  // Intentionally not inherited
  249.         posture->GetValue("templateOnly", templateOnly);
  250.         postureInfo.enabled = !templateOnly;  // Intentionally not inherited
  251.  
  252.         int id = pPuppet->GetPostureManager().AddPosture(postureInfo);
  253.  
  254.         // Parse children
  255.         int i = 0;
  256.         SmartScriptTable child;
  257.         while (posture->GetAt(++i, child))
  258.                 ParsePostureInfo(pPuppet, child, postureInfo, id, pSS);
  259.  
  260.         return id;
  261. }
  262.  
  263. //====================================================================
  264. // OverlapSphere
  265. //====================================================================
  266. /*static bool OverlapSphere(const Vec3& pos, float radius, IPhysicalEntity **entities, unsigned nEntities, Vec3& hitDir)
  267.    {
  268.    primitives::sphere spherePrim;
  269.    spherePrim.center = pos;
  270.    spherePrim.r = radius;
  271.  
  272.    unsigned hitCount = 0;
  273.    ray_hit hit;
  274.    IPhysicalWorld* pPhysics = gEnv->pPhysicalWorld;
  275.    for (unsigned iEntity = 0 ; iEntity < nEntities ; ++iEntity)
  276.    {
  277.     IPhysicalEntity *pEntity = entities[iEntity];
  278.     if (pPhysics->CollideEntityWithPrimitive(pEntity, spherePrim.type, &spherePrim, Vec3(ZERO), &hit))
  279.     {
  280.       hitDir += hit.n;
  281.       hitCount++;
  282.     }
  283.    }
  284.    hitDir.NormalizeSafe();
  285.    return hitCount != 0;
  286.    }
  287.  */
  288.  
  289. //====================================================================
  290. // OverlapSweptSphere
  291. //====================================================================
  292. static bool OverlapSweptSphere(const Vec3& pos, const Vec3& dir, float radius, IPhysicalEntity** entities, unsigned nEntities, Vec3& hitDir)
  293. {
  294.         primitives::sphere spherePrim;
  295.         spherePrim.center = pos;
  296.         spherePrim.r = radius;
  297.  
  298.         unsigned hitCount = 0;
  299.         ray_hit hit;
  300.         IPhysicalWorld* pPhysics = gEnv->pPhysicalWorld;
  301.         for (unsigned iEntity = 0; iEntity < nEntities; ++iEntity)
  302.         {
  303.                 IPhysicalEntity* pEntity = entities[iEntity];
  304.                 if (pPhysics->CollideEntityWithPrimitive(pEntity, spherePrim.type, &spherePrim, dir, &hit))
  305.                 {
  306.                         hitDir += hit.n;
  307.                         hitCount++;
  308.                 }
  309.         }
  310.         hitDir.NormalizeSafe();
  311.  
  312.         return hitCount != 0;
  313. }
  314.  
  315. //====================================================================
  316. // HasPointInRange
  317. //====================================================================
  318. /*
  319.    static bool  HasPointInRange(const Vec3& pos, float range, const std::list<Vec3>& points)
  320.    {
  321.    const float rangeSqr = sqr(range);
  322.    for(std::list<Vec3>::const_iterator ptIt = points.begin(); ptIt != points.end(); ++ ptIt)
  323.    {
  324.     if(Distance::Point_PointSq((*ptIt), pos) < rangeSqr)
  325.       return true;
  326.    }
  327.    return false;
  328.    }
  329.  */
  330.  
  331. //====================================================================
  332. // RunStartupScript
  333. //load the perception look-up table
  334. //====================================================================
  335. void InitLookUp()
  336. {
  337.         std::vector<float> theTable;
  338.         string sName = PathUtil::Make("Scripts/AI", "lookup.xml");
  339.         XmlNodeRef root = GetISystem()->LoadXmlFromFile(sName);
  340.         if (!root)
  341.                 return;
  342.  
  343.         XmlNodeRef nodeWorksheet = root->findChild("Worksheet");
  344.         if (!nodeWorksheet)
  345.                 return;
  346.  
  347.         XmlNodeRef nodeTable = nodeWorksheet->findChild("Table");
  348.         if (!nodeTable)
  349.                 return;
  350.  
  351.         for (int childN = 0; childN < nodeTable->getChildCount(); ++childN)
  352.         {
  353.                 XmlNodeRef nodeRow = nodeTable->getChild(childN);
  354.                 if (!nodeRow->isTag("Row"))
  355.                         continue;
  356.                 for (int childrenCntr(0), cellIndex(1); childrenCntr < nodeRow->getChildCount(); ++childrenCntr, ++cellIndex)
  357.                 {
  358.                         XmlNodeRef nodeCell = nodeRow->getChild(childrenCntr);
  359.                         if (!nodeCell->isTag("Cell"))
  360.                                 continue;
  361.  
  362.                         if (nodeCell->haveAttr("ss:Index"))
  363.                         {
  364.                                 const char* pStrIdx = nodeCell->getAttr("ss:Index");
  365.                                 PREFAST_SUPPRESS_WARNING(6031) sscanf(pStrIdx, "%d", &cellIndex);
  366.                         }
  367.                         XmlNodeRef nodeCellData = nodeCell->findChild("Data");
  368.                         if (!nodeCellData)
  369.                                 continue;
  370.  
  371.                         if (cellIndex == 1)
  372.                         {
  373.                                 const char* item(nodeCellData->getContent());
  374.                                 if (item)
  375.                                 {
  376.                                         float theValue(.0f);
  377.                                         PREFAST_SUPPRESS_WARNING(6031) sscanf(item, "%f", &theValue);
  378.  
  379.                                         theTable.push_back(theValue);
  380.                                 }
  381.                                 break;
  382.                         }
  383.                 }
  384.         }
  385.         int tableSize(theTable.size());
  386.         float* pTemBuffer(new float[tableSize]);
  387.         for (int i(0); i < tableSize; ++i)
  388.                 pTemBuffer[i] = theTable[i];
  389.         gEnv->pAISystem->SetPerceptionDistLookUp(pTemBuffer, tableSize);
  390.         delete[] pTemBuffer;
  391. }
  392.  
  393. //====================================================================
  394. // ReloadLookUpXML
  395. //====================================================================
  396. void ReloadLookUpXML(IConsoleCmdArgs* /* pArgs */)
  397. {
  398.         InitLookUp();
  399. }
  400.  
  401. //====================================================================
  402. // CScriptBind_AI
  403. //====================================================================
  404. CScriptBind_AI::CScriptBind_AI() :
  405.         m_pCurrentGoalPipe(0),
  406.         m_IsGroupOpen(false)
  407. {
  408.         Init(gEnv->pSystem->GetIScriptSystem(), gEnv->pSystem);
  409.  
  410.         SetGlobalName("AI");
  411.  
  412. #undef SCRIPT_REG_CLASSNAME
  413. #define SCRIPT_REG_CLASSNAME &CScriptBind_AI::
  414.  
  415.         SCRIPT_REG_FUNC(Warning);
  416.         SCRIPT_REG_FUNC(Error);
  417.         SCRIPT_REG_FUNC(LogProgress);
  418.         SCRIPT_REG_FUNC(LogEvent);
  419.         SCRIPT_REG_FUNC(LogComment);
  420.         SCRIPT_REG_FUNC(RecComment);
  421.  
  422.         SCRIPT_REG_FUNC(ResetParameters);
  423.         SCRIPT_REG_FUNC(ChangeParameter);
  424.         SCRIPT_REG_FUNC(GetParameter);
  425.         SCRIPT_REG_FUNC(IsEnabled);
  426.         //      SCRIPT_REG_FUNC(AddSmartObjectCondition);
  427.         SCRIPT_REG_FUNC(ChangeMovementAbility);
  428.         SCRIPT_REG_FUNC(ExecuteAction);
  429.         SCRIPT_REG_FUNC(AbortAction);
  430.         SCRIPT_REG_FUNC(SetSmartObjectState);
  431.         SCRIPT_REG_FUNC(ModifySmartObjectStates);
  432.         SCRIPT_REG_FUNC(SmartObjectEvent);
  433.         SCRIPT_REG_FUNC(GetLastUsedSmartObject);
  434.         SCRIPT_REG_FUNC(CreateGoalPipe);
  435.         SCRIPT_REG_FUNC(BeginGoalPipe);
  436.         SCRIPT_REG_FUNC(EndGoalPipe);
  437.         SCRIPT_REG_FUNC(BeginGroup);
  438.         SCRIPT_REG_FUNC(EndGroup);
  439.         SCRIPT_REG_FUNC(PushGoal);
  440.         SCRIPT_REG_FUNC(PushLabel);
  441.         SCRIPT_REG_FUNC(IsGoalPipe);
  442.         SCRIPT_REG_FUNC(Signal);
  443.         SCRIPT_REG_TEMPLFUNC(NotifyGroup, "groupID, senderID, notification");
  444.         SCRIPT_REG_FUNC(FreeSignal);
  445.         SCRIPT_REG_FUNC(SetIgnorant);
  446.         SCRIPT_REG_TEMPLFUNC(BreakEvent, "entityID, pos, radius");
  447.         SCRIPT_REG_TEMPLFUNC(AddCoverEntity, "entityID");
  448.         SCRIPT_REG_TEMPLFUNC(RemoveCoverEntity, "entityID");
  449.         SCRIPT_REG_FUNC(SetAssesmentMultiplier);
  450.         SCRIPT_REG_FUNC(SetFactionThreatMultiplier);
  451.         SCRIPT_REG_FUNC(GetGroupCount);
  452.         SCRIPT_REG_FUNC(GetGroupMember);
  453.         SCRIPT_REG_FUNC(GetGroupOf);
  454.         SCRIPT_REG_FUNC(GetGroupAveragePosition);
  455.         SCRIPT_REG_FUNC(Hostile);
  456.         SCRIPT_REG_FUNC(FindObjectOfType);
  457.         SCRIPT_REG_FUNC(SoundEvent);
  458.         SCRIPT_REG_FUNC(VisualEvent);
  459.         SCRIPT_REG_FUNC(GetSoundPerceptionDescriptor);
  460.         SCRIPT_REG_FUNC(SetSoundPerceptionDescriptor);
  461.         SCRIPT_REG_FUNC(GetAnchor);
  462.  
  463.         SCRIPT_REG_TEMPLFUNC(GetFactionOf, "entityID");
  464.         SCRIPT_REG_TEMPLFUNC(SetFactionOf, "entityID, factionName");
  465.  
  466.         SCRIPT_REG_FUNC(GetReactionOf);
  467.         SCRIPT_REG_TEMPLFUNC(SetReactionOf, "factionOne, factionTwo, reaction");
  468.  
  469.         SCRIPT_REG_FUNC(GetTypeOf);
  470.         SCRIPT_REG_FUNC(GetSubTypeOf);
  471.         SCRIPT_REG_FUNC(GetAttentionTargetAIType);
  472.         SCRIPT_REG_FUNC(GetAttentionTargetOf);
  473.         SCRIPT_REG_FUNC(GetAttentionTargetPosition);
  474.         SCRIPT_REG_FUNC(GetAttentionTargetDirection);
  475.         SCRIPT_REG_FUNC(GetAttentionTargetViewDirection);
  476.         SCRIPT_REG_FUNC(GetAttentionTargetDistance);
  477.         SCRIPT_REG_TEMPLFUNC(GetAttentionTargetEntity, "entityID");
  478.         SCRIPT_REG_FUNC(GetAttentionTargetType);
  479.         SCRIPT_REG_TEMPLFUNC(GetAttentionTargetThreat, "entityID");
  480.         SCRIPT_REG_FUNC(GetTargetType);
  481.         SCRIPT_REG_FUNC(GetTargetSubType);
  482.         SCRIPT_REG_FUNC(GetAIObjectPosition);
  483.         SCRIPT_REG_FUNC(GetBeaconPosition);
  484.         SCRIPT_REG_FUNC(SetBeaconPosition);
  485.         SCRIPT_REG_FUNC(GetTotalLengthOfPath);
  486.         SCRIPT_REG_FUNC(GetNearestEntitiesOfType);
  487.         SCRIPT_REG_FUNC(SetRefPointPosition);
  488.         SCRIPT_REG_FUNC(SetRefPointDirection);
  489.         SCRIPT_REG_FUNC(GetRefPointPosition);
  490.         SCRIPT_REG_FUNC(GetRefPointDirection);
  491.         SCRIPT_REG_FUNC(SetRefPointRadius);
  492.         SCRIPT_REG_FUNC(SetRefShapeName);
  493.         SCRIPT_REG_FUNC(GetRefShapeName);
  494.         SCRIPT_REG_FUNC(SetVehicleStickTarget);
  495.         SCRIPT_REG_FUNC(SetTerritoryShapeName);
  496.         SCRIPT_REG_FUNC(CreateTempGenericShapeBox);
  497.         SCRIPT_REG_FUNC(GetForwardDir);
  498. #ifdef USE_DEPRECATED_AI_CHARACTER_SYSTEM
  499.         SCRIPT_REG_FUNC(SetCharacter);
  500. #endif
  501.         SCRIPT_REG_FUNC(GetDirectAnchorPos);
  502.         SCRIPT_REG_FUNC(GetNearestHidespot);
  503.         SCRIPT_REG_FUNC(GetEnclosingGenericShapeOfType);
  504.         SCRIPT_REG_FUNC(IsPointInsideGenericShape);
  505.         SCRIPT_REG_FUNC(DistanceToGenericShape);
  506.         SCRIPT_REG_FUNC(ConstrainPointInsideGenericShape);
  507.         SCRIPT_REG_FUNC(InvalidateHidespot);
  508.         SCRIPT_REG_FUNC(EvalHidespot);
  509.         SCRIPT_REG_FUNC(EvalPeek);
  510.         SCRIPT_REG_TEMPLFUNC(AddPersonallyHostile, "entityID, hostileID");
  511.         SCRIPT_REG_TEMPLFUNC(RemovePersonallyHostile, "entityID, hostileID");
  512.         SCRIPT_REG_TEMPLFUNC(ResetPersonallyHostiles, "entityID, hostileID");
  513.         SCRIPT_REG_TEMPLFUNC(IsPersonallyHostile, "entityID, hostileID");
  514.         SCRIPT_REG_FUNC(NotifyReinfDone);
  515.         SCRIPT_REG_FUNC(BehaviorEvent);
  516.         SCRIPT_REG_FUNC(IntersectsForbidden);
  517.         SCRIPT_REG_FUNC(IsPointInFlightRegion);
  518.         SCRIPT_REG_FUNC(IsPointInWaterRegion);
  519.         SCRIPT_REG_FUNC(GetEnclosingSpace);
  520.         SCRIPT_REG_FUNC(Event);
  521.         SCRIPT_REG_FUNC(CreateFormation);
  522.         SCRIPT_REG_FUNC(AddFormationPoint);
  523.         SCRIPT_REG_FUNC(AddFormationPointFixed);
  524.         SCRIPT_REG_FUNC(GetFormationPointClass);
  525.         SCRIPT_REG_FUNC(GetFormationPointPosition);
  526.         SCRIPT_REG_FUNC(ChangeFormation);
  527.         SCRIPT_REG_FUNC(ScaleFormation);
  528.         SCRIPT_REG_FUNC(SetFormationUpdate);
  529.         SCRIPT_REG_FUNC(SetFormationUpdateSight);
  530.         SCRIPT_REG_FUNC(GetLeader);
  531.         SCRIPT_REG_FUNC(SetLeader);
  532.         SCRIPT_REG_FUNC(UpTargetPriority);
  533.         SCRIPT_REG_FUNC(DropTarget);
  534.         SCRIPT_REG_FUNC(ClearPotentialTargets);
  535.         SCRIPT_REG_FUNC(SetTempTargetPriority);
  536.         SCRIPT_REG_FUNC(AddAggressiveTarget);
  537.         SCRIPT_REG_FUNC(UpdateTempTarget);
  538.         SCRIPT_REG_FUNC(ClearTempTarget);
  539.         SCRIPT_REG_FUNC(SetExtraPriority);
  540.         SCRIPT_REG_FUNC(GetExtraPriority);
  541.         SCRIPT_REG_FUNC(RegisterTargetTrack);
  542.         SCRIPT_REG_FUNC(UnregisterTargetTrack);
  543.         SCRIPT_REG_FUNC(SetTargetTrackClassThreat);
  544.         SCRIPT_REG_TEMPLFUNC(TriggerCurrentTargetTrackPulse, "entityID, stimulusName, pulseName");
  545.         SCRIPT_REG_TEMPLFUNC(CreateStimulusEvent, "ownerId, targetID, stimulusName, pData");
  546.         SCRIPT_REG_TEMPLFUNC(CreateStimulusEventInRange, "targetID, stimulusName, dataScriptTable");
  547.         SCRIPT_REG_FUNC(GetStance);
  548.         SCRIPT_REG_FUNC(SetStance);
  549.         SCRIPT_REG_FUNC(SetUnitProperties);
  550.         SCRIPT_REG_FUNC(GetUnitCount);
  551.         SCRIPT_REG_FUNC(SetForcedNavigation);
  552.         SCRIPT_REG_FUNC(SetAdjustPath);
  553.         SCRIPT_REG_FUNC(GetHeliAdvancePoint);
  554.         SCRIPT_REG_FUNC(CheckVehicleColision);
  555.         SCRIPT_REG_FUNC(GetFlyingVehicleFlockingPos);
  556.         SCRIPT_REG_FUNC(SetPFBlockerRadius);
  557.         SCRIPT_REG_FUNC(AssignPFPropertiesToPathType);
  558.         SCRIPT_REG_FUNC(AssignPathTypeToSOUser);
  559.         SCRIPT_REG_FUNC(SetPFProperties);
  560.         SCRIPT_REG_FUNC(GetGroupTarget);
  561.         SCRIPT_REG_TEMPLFUNC(GetGroupTargetType, "groupID");
  562.         SCRIPT_REG_TEMPLFUNC(GetGroupTargetThreat, "groupID");
  563.         SCRIPT_REG_TEMPLFUNC(GetGroupTargetEntity, "groupID");
  564.         SCRIPT_REG_TEMPLFUNC(GetGroupScriptTable, "groupID");
  565.         SCRIPT_REG_FUNC(GetGroupTargetCount);
  566.         SCRIPT_REG_FUNC(GetNavigationType);
  567.         SCRIPT_REG_FUNC(SetPathToFollow);
  568.         SCRIPT_REG_FUNC(SetPathAttributeToFollow);
  569.         SCRIPT_REG_FUNC(GetPredictedPosAlongPath);
  570.         SCRIPT_REG_FUNC(SetPointListToFollow);
  571.         SCRIPT_REG_FUNC(GetNearestPointOnPath);
  572.         SCRIPT_REG_FUNC(GetPathSegNoOnPath);
  573.         SCRIPT_REG_FUNC(GetPointOnPathBySegNo);
  574.         SCRIPT_REG_FUNC(GetPathLoop);
  575.         SCRIPT_REG_FUNC(GetNearestPathOfTypeInRange);
  576.         SCRIPT_REG_FUNC(GetAlertness);
  577.         SCRIPT_REG_FUNC(GetGroupAlertness);
  578.         SCRIPT_REG_FUNC(GetDistanceAlongPath);
  579.         SCRIPT_REG_FUNC(SetFireMode);
  580.         SCRIPT_REG_FUNC(SetMemoryFireType);
  581.         SCRIPT_REG_FUNC(GetMemoryFireType);
  582.         SCRIPT_REG_FUNC(ThrowGrenade);
  583.         SCRIPT_REG_FUNC(EnableCoverFire);
  584.         SCRIPT_REG_FUNC(EnableFire);
  585.         SCRIPT_REG_FUNC(IsFireEnabled);
  586.         SCRIPT_REG_FUNC(CanFireInStance);
  587.         SCRIPT_REG_FUNC(SetUseSecondaryVehicleWeapon);
  588.         SCRIPT_REG_FUNC(SetRefPointToGrenadeAvoidTarget);
  589.         SCRIPT_REG_FUNC(IsAgentInTargetFOV);
  590.         SCRIPT_REG_FUNC(AgentLookAtPos);
  591.         SCRIPT_REG_FUNC(ResetAgentLookAtPos);
  592.         SCRIPT_REG_FUNC(IsAgentInAgentFOV);
  593.         SCRIPT_REG_FUNC(CreateGroupFormation);
  594.         SCRIPT_REG_FUNC(SetFormationPosition);
  595.         SCRIPT_REG_FUNC(SetFormationLookingPoint);
  596.         SCRIPT_REG_FUNC(GetFormationPosition);
  597.         SCRIPT_REG_FUNC(GetFormationLookingPoint);
  598.         SCRIPT_REG_FUNC(SetFormationAngleThreshold);
  599.  
  600.         SCRIPT_REG_TEMPLFUNC(SetMovementContext, "entityId, context");
  601.         SCRIPT_REG_TEMPLFUNC(ClearMovementContext, "entityId, context");
  602.  
  603.         SCRIPT_REG_TEMPLFUNC(SetPostures, "entityId, postures");
  604.         SCRIPT_REG_TEMPLFUNC(SetPosturePriority, "entityId, postureName, priority");
  605.         SCRIPT_REG_TEMPLFUNC(GetPosturePriority, "entityId, postureName");
  606.  
  607.         SCRIPT_REG_FUNC(AddCombatClass);
  608.         SCRIPT_REG_FUNC(SetRefPointAtDefensePos);
  609.         SCRIPT_REG_FUNC(RegisterDamageRegion);
  610.         SCRIPT_REG_FUNC(IgnoreCurrentHideObject);
  611.         SCRIPT_REG_FUNC(GetCurrentHideAnchor);
  612.         SCRIPT_REG_FUNC(GetBiasedDirection);
  613.         SCRIPT_REG_FUNC(FindStandbySpotInShape);
  614.         SCRIPT_REG_FUNC(FindStandbySpotInSphere);
  615.         SCRIPT_REG_FUNC(GetObjectRadius);
  616.         SCRIPT_REG_FUNC(GetProbableTargetPosition);
  617.         SCRIPT_REG_FUNC(NotifySurpriseEntityAction);
  618.         SCRIPT_REG_FUNC(Animation);
  619.         SCRIPT_REG_TEMPLFUNC(SetAnimationTag, "entityID, tagName");
  620.         SCRIPT_REG_TEMPLFUNC(ClearAnimationTag, "entityID, tagName");
  621.  
  622.         SCRIPT_REG_FUNC(SetRefpointToAnchor);
  623.         SCRIPT_REG_FUNC(SetRefpointToPunchableObject);
  624.         SCRIPT_REG_FUNC(MeleePunchableObject);
  625.         SCRIPT_REG_FUNC(IsPunchableObjectValid);
  626.  
  627.         SCRIPT_REG_FUNC(ProcessBalancedDamage);
  628.         SCRIPT_REG_FUNC(CanMoveStraightToPoint);
  629.  
  630.         SCRIPT_REG_FUNC(CanMelee);
  631.         SCRIPT_REG_FUNC(CheckMeleeDamage);
  632.         SCRIPT_REG_FUNC(IsMoving);
  633.  
  634.         SCRIPT_REG_FUNC(GetDirLabelToPoint);
  635.  
  636.         SCRIPT_REG_FUNC(SetAttentiontarget);
  637.         SCRIPT_REG_FUNC(DebugReportHitDamage);
  638.  
  639.         SCRIPT_REG_TEMPLFUNC(RegisterInterestingEntity, "entityId, radius, baseInterest, category, aiAction");
  640.         SCRIPT_REG_TEMPLFUNC(UnregisterInterestingEntity, "entityId");
  641.         SCRIPT_REG_TEMPLFUNC(RegisterInterestedActor, "entityId, fInterestFilter, fAngleInDegrees");
  642.         SCRIPT_REG_TEMPLFUNC(UnregisterInterestedActor, "entityId");
  643.  
  644.         SCRIPT_REG_FUNC(RegisterTacticalPointQuery);
  645.         SCRIPT_REG_FUNC(GetTacticalPoints);
  646.         SCRIPT_REG_FUNC(DestroyAllTPSQueries);
  647.  
  648.         SCRIPT_REG_FUNC(GetObjectBlackBoard);
  649.         SCRIPT_REG_FUNC(GetBehaviorBlackBoard);
  650.  
  651.         SCRIPT_REG_FUNC(IsCoverCompromised);
  652.         SCRIPT_REG_FUNC(SetCoverCompromised);
  653.         SCRIPT_REG_FUNC(IsTakingCover);
  654.         SCRIPT_REG_FUNC(IsMovingToCover);
  655.         SCRIPT_REG_FUNC(IsMovingInCover);
  656.         SCRIPT_REG_FUNC(IsInCover);
  657.         SCRIPT_REG_FUNC(SetInCover);
  658.  
  659.         SCRIPT_REG_FUNC(IsOutOfAmmo);
  660.         SCRIPT_REG_FUNC(IsLowOnAmmo);
  661.         SCRIPT_REG_TEMPLFUNC(ResetAgentState, "entityId, stateLabel");
  662.         SCRIPT_REG_TEMPLFUNC(PlayCommunication, "entityId, commName, channelName, contextExpiry, [skipSound], [skipAnimation], [targetId], [target]");
  663.         SCRIPT_REG_TEMPLFUNC(StopCommunication, "playID");
  664.  
  665.         SCRIPT_REG_TEMPLFUNC(SetBehaviorVariable, "entityId, variableName, value");
  666.         SCRIPT_REG_TEMPLFUNC(GetBehaviorVariable, "entityId, variableName");
  667.  
  668.         SCRIPT_REG_FUNC(SetAlarmed);
  669.  
  670.         SCRIPT_REG_TEMPLFUNC(LoadBehaviors, "folderName, extensions");
  671. #ifdef USE_DEPRECATED_AI_CHARACTER_SYSTEM
  672.         SCRIPT_REG_TEMPLFUNC(LoadCharacters, "folderName, table");
  673. #endif
  674.         SCRIPT_REG_TEMPLFUNC(IsLowHealthPauseActive, "entityID");
  675.  
  676.         SCRIPT_REG_TEMPLFUNC(GetPreviousBehaviorName, "entityID");
  677.         SCRIPT_REG_TEMPLFUNC(SetContinuousMotion, "entityID, continuousMotion");
  678.  
  679.         SCRIPT_REG_TEMPLFUNC(GetPeakThreatLevel, "entityID");
  680.         SCRIPT_REG_TEMPLFUNC(GetPeakThreatType, "entityID");
  681.  
  682.         SCRIPT_REG_TEMPLFUNC(GetPreviousPeakThreatLevel, "entityID");
  683.         SCRIPT_REG_TEMPLFUNC(GetPreviousPeakThreatType, "entityID");
  684.  
  685.         SCRIPT_REG_TEMPLFUNC(CheckForFriendlyAgentsAroundPoint, "entityID, point, radius");
  686.  
  687.         SCRIPT_REG_TEMPLFUNC(EnableUpdateLookTarget, "entityID, bEnable");
  688.         SCRIPT_REG_TEMPLFUNC(SetBehaviorTreeEvaluationEnabled, "entityID, enabled");
  689.  
  690.         SCRIPT_REG_TEMPLFUNC(UpdateGlobalPerceptionScale, "visualScale, audioScale, [filterType], [faction]");
  691.         SCRIPT_REG_TEMPLFUNC(QueueBubbleMessage, "entityID, message");
  692.  
  693.         SCRIPT_REG_TEMPLFUNC(SequenceBehaviorReady, "entityID");
  694.         SCRIPT_REG_TEMPLFUNC(SequenceInterruptibleBehaviorLeft, "entityID");
  695.         SCRIPT_REG_TEMPLFUNC(SequenceNonInterruptibleBehaviorLeft, "entityID");
  696.  
  697.         SCRIPT_REG_TEMPLFUNC(SetCollisionAvoidanceRadiusIncrement, "entityID, radius");
  698.         SCRIPT_REG_TEMPLFUNC(RequestToStopMovement, "entityID");
  699.         SCRIPT_REG_TEMPLFUNC(GetDistanceToClosestGroupMember, "entityID");
  700.         SCRIPT_REG_TEMPLFUNC(IsAimReady, "entityID");
  701.  
  702.         SCRIPT_REG_TEMPLFUNC(AllowLowerBodyToTurn, "entityID, allowLowerBodyToTurn");
  703.  
  704.         SCRIPT_REG_TEMPLFUNC(GetGroupScopeUserCount, "entityIdHandle, groupScopeName");
  705.         SCRIPT_REG_TEMPLFUNC(StartModularBehaviorTree, "entityIdHandle, treeName");
  706.         SCRIPT_REG_TEMPLFUNC(StopModularBehaviorTree, "entityIdHandle");
  707.  
  708.         SCRIPT_REG_FUNC(LoadGoalPipes);
  709.  
  710.         SCRIPT_REG_FUNC(AutoDisable);
  711.  
  712.         SCRIPT_REG_TEMPLFUNC(GetPotentialTargetCountFromFaction, "entityID, factionName");
  713.         SCRIPT_REG_TEMPLFUNC(GetPotentialTargetCount, "entityID");
  714.  
  715.         gEnv->pScriptSystem->SetGlobalValue("BEHAVIOR_STARTED", BehaviorStarted);
  716.         gEnv->pScriptSystem->SetGlobalValue("BEHAVIOR_FINISHED", BehaviorFinished);
  717.         gEnv->pScriptSystem->SetGlobalValue("BEHAVIOR_INTERRUPTED", BehaviorInterrupted);
  718.         gEnv->pScriptSystem->SetGlobalValue("BEHAVIOR_FAILED", BehaviorFailed);
  719.  
  720.         gEnv->pScriptSystem->SetGlobalValue("Hostile", IFactionMap::Hostile);
  721.         gEnv->pScriptSystem->SetGlobalValue("Neutral", IFactionMap::Neutral);
  722.         gEnv->pScriptSystem->SetGlobalValue("Friendly", IFactionMap::Friendly);
  723.  
  724.         gEnv->pScriptSystem->SetGlobalValue("POSTURE_NULL", PostureManager::InvalidPosture);
  725.         gEnv->pScriptSystem->SetGlobalValue("POSTURE_PEEK", PostureManager::PeekPosture);
  726.         gEnv->pScriptSystem->SetGlobalValue("POSTURE_AIM", PostureManager::AimPosture);
  727.         gEnv->pScriptSystem->SetGlobalValue("POSTURE_HIDE", PostureManager::HidePosture);
  728.  
  729.         SCRIPT_REG_GLOBAL(AIWEPA_LASER);
  730.         SCRIPT_REG_GLOBAL(AIWEPA_COMBAT_LIGHT);
  731.         SCRIPT_REG_GLOBAL(AIWEPA_PATROL_LIGHT);
  732.         SCRIPT_REG_FUNC(EnableWeaponAccessory);
  733.  
  734.         SCRIPT_REG_GLOBAL(AIFO_FACING_TARGET);
  735.         SCRIPT_REG_GLOBAL(AIFO_NONOCCUPIED);
  736.         SCRIPT_REG_GLOBAL(AIFO_CHOOSE_RANDOM);
  737.         SCRIPT_REG_GLOBAL(AIFO_NONOCCUPIED_REFPOINT);
  738.         SCRIPT_REG_GLOBAL(AIFO_USE_BEACON_AS_FALLBACK_TGT);
  739.         SCRIPT_REG_GLOBAL(AIFO_NO_DEVALUE);
  740.  
  741.         SCRIPT_REG_GLOBAL(AIPARAM_SIGHTRANGE);
  742.         SCRIPT_REG_GLOBAL(AIPARAM_ATTACKRANGE);
  743.         SCRIPT_REG_GLOBAL(AIPARAM_ACCURACY);
  744.         SCRIPT_REG_GLOBAL(AIPARAM_GROUPID);
  745.         SCRIPT_REG_GLOBAL(AIPARAM_FOVPRIMARY);
  746.         SCRIPT_REG_GLOBAL(AIPARAM_FOVSECONDARY);
  747.         SCRIPT_REG_GLOBAL(AIPARAM_COMMRANGE);
  748.         SCRIPT_REG_GLOBAL(AIPARAM_FWDSPEED);
  749.         SCRIPT_REG_GLOBAL(AIPARAM_FACTION);
  750.         SCRIPT_REG_GLOBAL(AIPARAM_FACTIONHOSTILITY);
  751.         SCRIPT_REG_GLOBAL(AIPARAM_STRAFINGPITCH);
  752.         SCRIPT_REG_GLOBAL(AIPARAM_COMBATCLASS);
  753.         SCRIPT_REG_GLOBAL(AIPARAM_INVISIBLE);
  754.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONSCALE_VISUAL);
  755.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONSCALE_AUDIO);
  756.         SCRIPT_REG_GLOBAL(AIPARAM_CLOAK_SCALE);
  757.         SCRIPT_REG_GLOBAL(AIPARAM_FORGETTIME_TARGET);
  758.         SCRIPT_REG_GLOBAL(AIPARAM_FORGETTIME_MEMORY);
  759.         SCRIPT_REG_GLOBAL(AIPARAM_FORGETTIME_SEEK);
  760.         SCRIPT_REG_GLOBAL(AIPARAM_LOOKIDLE_TURNSPEED);
  761.         SCRIPT_REG_GLOBAL(AIPARAM_LOOKCOMBAT_TURNSPEED);
  762.         SCRIPT_REG_GLOBAL(AIPARAM_AIM_TURNSPEED);
  763.         SCRIPT_REG_GLOBAL(AIPARAM_FIRE_TURNSPEED);
  764.         SCRIPT_REG_GLOBAL(AIPARAM_MELEE_DISTANCE);
  765.         SCRIPT_REG_GLOBAL(AIPARAM_MIN_ALARM_LEVEL);
  766.         SCRIPT_REG_GLOBAL(AIPARAM_PROJECTILE_LAUNCHDIST);
  767.         SCRIPT_REG_GLOBAL(AIPARAM_SIGHTDELAY);
  768.         SCRIPT_REG_GLOBAL(AIPARAM_SIGHTNEARRANGE);
  769.         SCRIPT_REG_GLOBAL(AIPARAM_CLOAKED);
  770.  
  771.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONAUDIORANGE_AGGRESSIVE);
  772.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONAUDIORANGE_THREATENING);
  773.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONAUDIORANGE_INTERESTING);
  774.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONVISUALTIME_NEARREACT);
  775.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONVISUALTIME_AGGRESSIVE);
  776.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONVISUALTIME_THREATENING);
  777.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONVISUALTIME_INTERESTING);
  778.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONVISUAL_TARGETSTATIONARYTIME);
  779.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONVISUAL_TARGETLONGMEMORYTIME);
  780.         SCRIPT_REG_GLOBAL(AIPARAM_PERCEPTIONVISUAL_CANFORGET);
  781.  
  782.         SCRIPT_REG_GLOBAL(AIMOVEABILITY_OPTIMALFLIGHTHEIGHT);
  783.         SCRIPT_REG_GLOBAL(AIMOVEABILITY_MINFLIGHTHEIGHT);
  784.         SCRIPT_REG_GLOBAL(AIMOVEABILITY_MAXFLIGHTHEIGHT);
  785.         SCRIPT_REG_GLOBAL(AIMOVEABILITY_TELEPORTENABLE);
  786.         SCRIPT_REG_GLOBAL(AIMOVEABILITY_USEPREDICTIVEFOLLOWING);
  787.  
  788.         SCRIPT_REG_GLOBAL(AILOOKMOTIVATION_LOOK);
  789.         SCRIPT_REG_GLOBAL(AILOOKMOTIVATION_GLANCE);
  790.         SCRIPT_REG_GLOBAL(AILOOKMOTIVATION_STARTLE);
  791.         SCRIPT_REG_GLOBAL(AILOOKMOTIVATION_DOUBLETAKE);
  792.  
  793.         SCRIPT_REG_GLOBAL(AIOBJECT_ACTOR);
  794.         SCRIPT_REG_GLOBAL(AIOBJECT_VEHICLE);
  795.         SCRIPT_REG_GLOBAL(AIOBJECT_CAR);
  796.         SCRIPT_REG_GLOBAL(AIOBJECT_BOAT);
  797.         SCRIPT_REG_GLOBAL(AIOBJECT_HELICOPTER);
  798.         SCRIPT_REG_GLOBAL(AIOBJECT_HELICOPTERCRYSIS2);
  799.         SCRIPT_REG_GLOBAL(AIOBJECT_TARGET);
  800.         SCRIPT_REG_GLOBAL(AIOBJECT_GUNFIRE);
  801.  
  802.         SCRIPT_REG_GLOBAL(AISIGNAL_INCLUDE_DISABLED);
  803.         SCRIPT_REG_GLOBAL(AISIGNAL_DEFAULT);
  804.         SCRIPT_REG_GLOBAL(AISIGNAL_PROCESS_NEXT_UPDATE);
  805.         SCRIPT_REG_GLOBAL(AISIGNAL_NOTIFY_ONLY);
  806.         SCRIPT_REG_GLOBAL(AISIGNAL_ALLOW_DUPLICATES);
  807.  
  808.         SCRIPT_REG_GLOBAL(AIOBJECT_2D_FLY);
  809.  
  810.         SCRIPT_REG_GLOBAL(AIOBJECT_ATTRIBUTE);
  811.         SCRIPT_REG_GLOBAL(AIOBJECT_WAYPOINT);
  812.         SCRIPT_REG_GLOBAL(AIOBJECT_SNDSUPRESSOR);
  813.         SCRIPT_REG_GLOBAL(AIOBJECT_NAV_SEED);
  814.         SCRIPT_REG_GLOBAL(AIOBJECT_MOUNTEDWEAPON);
  815.         SCRIPT_REG_GLOBAL(AIOBJECT_GLOBALALERTNESS);
  816.         SCRIPT_REG_GLOBAL(AIOBJECT_PLAYER);
  817.         SCRIPT_REG_GLOBAL(AIOBJECT_DUMMY);
  818.         SCRIPT_REG_GLOBAL(AIOBJECT_NONE);
  819.         SCRIPT_REG_GLOBAL(AIOBJECT_ORDER);
  820.         SCRIPT_REG_GLOBAL(AIOBJECT_GRENADE);
  821.         SCRIPT_REG_GLOBAL(AIOBJECT_RPG);
  822.         SCRIPT_REG_GLOBAL(AIOBJECT_INFECTED);
  823.         SCRIPT_REG_GLOBAL(AIOBJECT_ALIENTICK);
  824.  
  825.         SCRIPT_REG_GLOBAL(AI_USE_HIDESPOTS);
  826.  
  827.         SCRIPT_REG_GLOBAL(STICK_BREAK);
  828.         SCRIPT_REG_GLOBAL(STICK_SHORTCUTNAV);
  829.  
  830.         SCRIPT_REG_GLOBAL(GE_GROUP_STATE);
  831.         SCRIPT_REG_GLOBAL(GE_UNIT_STATE);
  832.         SCRIPT_REG_GLOBAL(GE_ADVANCE_POS);
  833.         SCRIPT_REG_GLOBAL(GE_SEEK_POS);
  834.         SCRIPT_REG_GLOBAL(GE_DEFEND_POS);
  835.         SCRIPT_REG_GLOBAL(GE_LEADER_COUNT);
  836.         SCRIPT_REG_GLOBAL(GE_MOST_LOST_UNIT);
  837.         SCRIPT_REG_GLOBAL(GE_MOVEMENT_SIGNAL);
  838.         SCRIPT_REG_GLOBAL(GE_NEAREST_SEEK);
  839.  
  840.         SCRIPT_REG_GLOBAL(GN_INIT);
  841.         SCRIPT_REG_GLOBAL(GN_MARK_DEFEND_POS);
  842.         SCRIPT_REG_GLOBAL(GN_CLEAR_DEFEND_POS);
  843.         SCRIPT_REG_GLOBAL(GN_AVOID_CURRENT_POS);
  844.         SCRIPT_REG_GLOBAL(GN_PREFER_ATTACK);
  845.         SCRIPT_REG_GLOBAL(GN_PREFER_FLEE);
  846.         SCRIPT_REG_GLOBAL(GN_NOTIFY_ADVANCING);
  847.         SCRIPT_REG_GLOBAL(GN_NOTIFY_COVERING);
  848.         SCRIPT_REG_GLOBAL(GN_NOTIFY_WEAK_COVERING);
  849.         SCRIPT_REG_GLOBAL(GN_NOTIFY_HIDING);
  850.         SCRIPT_REG_GLOBAL(GN_NOTIFY_SEEKING);
  851.         SCRIPT_REG_GLOBAL(GN_NOTIFY_ALERTED);
  852.         SCRIPT_REG_GLOBAL(GN_NOTIFY_UNAVAIL);
  853.         SCRIPT_REG_GLOBAL(GN_NOTIFY_IDLE);
  854.         SCRIPT_REG_GLOBAL(GN_NOTIFY_SEARCHING);
  855.         SCRIPT_REG_GLOBAL(GN_NOTIFY_REINFORCE);
  856.  
  857.         SCRIPT_REG_GLOBAL(GS_IDLE);
  858.         SCRIPT_REG_GLOBAL(GS_COVER);
  859.         SCRIPT_REG_GLOBAL(GS_ADVANCE);
  860.         SCRIPT_REG_GLOBAL(GS_SEEK);
  861.         SCRIPT_REG_GLOBAL(GS_SEARCH);
  862.  
  863.         SCRIPT_REG_GLOBAL(GU_HUMAN_CAMPER);
  864.         SCRIPT_REG_GLOBAL(GU_HUMAN_COVER);
  865.         SCRIPT_REG_GLOBAL(GU_HUMAN_SNEAKER);
  866.         SCRIPT_REG_GLOBAL(GU_HUMAN_LEADER);
  867.         SCRIPT_REG_GLOBAL(GU_HUMAN_SNEAKER_SPECOP);
  868.         SCRIPT_REG_GLOBAL(GU_ALIEN_MELEE);
  869.         SCRIPT_REG_GLOBAL(GU_ALIEN_ASSAULT);
  870.         SCRIPT_REG_GLOBAL(GU_ALIEN_MELEE_DEFEND);
  871.         SCRIPT_REG_GLOBAL(GU_ALIEN_ASSAULT_DEFEND);
  872.         SCRIPT_REG_GLOBAL(GU_ALIEN_EVADE);
  873.  
  874.         SCRIPT_REG_GLOBAL(AIEVENT_ONVISUALSTIMULUS);
  875.         SCRIPT_REG_GLOBAL(AIEVENT_AGENTDIED);
  876.         SCRIPT_REG_GLOBAL(AIEVENT_SLEEP);
  877.         SCRIPT_REG_GLOBAL(AIEVENT_WAKEUP);
  878.         SCRIPT_REG_GLOBAL(AIEVENT_ENABLE);
  879.         SCRIPT_REG_GLOBAL(AIEVENT_DISABLE);
  880.         SCRIPT_REG_GLOBAL(AIEVENT_PATHFINDON);
  881.         SCRIPT_REG_GLOBAL(AIEVENT_PATHFINDOFF);
  882.         SCRIPT_REG_GLOBAL(AIEVENT_CLEAR);
  883.         SCRIPT_REG_GLOBAL(AIEVENT_DROPBEACON);
  884.         SCRIPT_REG_GLOBAL(AIEVENT_USE);
  885.         SCRIPT_REG_GLOBAL(AIEVENT_CLEARACTIVEGOALS);
  886.         SCRIPT_REG_GLOBAL(AIEVENT_DRIVER_IN);
  887.         SCRIPT_REG_GLOBAL(AIEVENT_DRIVER_OUT);
  888.         SCRIPT_REG_GLOBAL(AIEVENT_FORCEDNAVIGATION);
  889.  
  890.         SCRIPT_REG_GLOBAL(AISOUND_GENERIC);
  891.         SCRIPT_REG_GLOBAL(AISOUND_COLLISION);
  892.         SCRIPT_REG_GLOBAL(AISOUND_COLLISION_LOUD);
  893.         SCRIPT_REG_GLOBAL(AISOUND_MOVEMENT);
  894.         SCRIPT_REG_GLOBAL(AISOUND_MOVEMENT_LOUD);
  895.         SCRIPT_REG_GLOBAL(AISOUND_WEAPON);
  896.         SCRIPT_REG_GLOBAL(AISOUND_EXPLOSION);
  897.  
  898.         SCRIPT_REG_GLOBAL(AI_LOOKAT_CONTINUOUS);
  899.         SCRIPT_REG_GLOBAL(AI_LOOKAT_USE_BODYDIR);
  900.  
  901.         SCRIPT_REG_GLOBAL(AISYSEVENT_DISABLEMODIFIER);
  902.  
  903.         SCRIPT_REG_GLOBAL(AILASTOPRES_LOOKAT);
  904.         SCRIPT_REG_GLOBAL(AILASTOPRES_USE);
  905.         SCRIPT_REG_GLOBAL(AI_LOOK_FORWARD);
  906.         SCRIPT_REG_GLOBAL(AI_MOVE_RIGHT);
  907.         SCRIPT_REG_GLOBAL(AI_MOVE_LEFT);
  908.         SCRIPT_REG_GLOBAL(AI_MOVE_FORWARD);
  909.         SCRIPT_REG_GLOBAL(AI_MOVE_BACKWARD);
  910.         SCRIPT_REG_GLOBAL(AI_MOVE_BACKLEFT);
  911.         SCRIPT_REG_GLOBAL(AI_MOVE_BACKRIGHT);
  912.         SCRIPT_REG_GLOBAL(AI_MOVE_TOWARDS_GROUP);
  913.         SCRIPT_REG_GLOBAL(AI_USE_TARGET_MOVEMENT);
  914.         SCRIPT_REG_GLOBAL(AI_CHECK_SLOPE_DISTANCE);
  915.  
  916.         SCRIPT_REG_GLOBAL(AI_REQUEST_PARTIAL_PATH);
  917.         SCRIPT_REG_GLOBAL(AI_BACKOFF_FROM_TARGET);
  918.         SCRIPT_REG_GLOBAL(AI_BREAK_ON_LIVE_TARGET);
  919.         SCRIPT_REG_GLOBAL(AI_RANDOM_ORDER);
  920.         SCRIPT_REG_GLOBAL(AI_USE_TIME);
  921.         SCRIPT_REG_GLOBAL(AI_STOP_ON_ANIMATION_START);
  922.         SCRIPT_REG_GLOBAL(AI_CONSTANT_SPEED);
  923.         SCRIPT_REG_GLOBAL(AI_ADJUST_SPEED);
  924.  
  925.         SCRIPT_REG_GLOBAL(FIREMODE_OFF);
  926.         SCRIPT_REG_GLOBAL(FIREMODE_BURST);
  927.         SCRIPT_REG_GLOBAL(FIREMODE_CONTINUOUS);
  928.         SCRIPT_REG_GLOBAL(FIREMODE_FORCED);
  929.         SCRIPT_REG_GLOBAL(FIREMODE_AIM);
  930.         SCRIPT_REG_GLOBAL(FIREMODE_SECONDARY);
  931.         SCRIPT_REG_GLOBAL(FIREMODE_SECONDARY_SMOKE);
  932.         SCRIPT_REG_GLOBAL(FIREMODE_MELEE);
  933.         SCRIPT_REG_GLOBAL(FIREMODE_MELEE_FORCED);
  934.         SCRIPT_REG_GLOBAL(FIREMODE_KILL);
  935.         SCRIPT_REG_GLOBAL(FIREMODE_BURST_WHILE_MOVING);
  936.         SCRIPT_REG_GLOBAL(FIREMODE_PANIC_SPREAD);
  937.         SCRIPT_REG_GLOBAL(FIREMODE_BURST_DRAWFIRE);
  938.         SCRIPT_REG_GLOBAL(FIREMODE_BURST_ONCE);
  939.         SCRIPT_REG_GLOBAL(FIREMODE_BURST_SNIPE);
  940.         SCRIPT_REG_GLOBAL(FIREMODE_AIM_SWEEP);
  941.  
  942.         SCRIPT_REG_GLOBAL(AITHREAT_NONE);
  943.         SCRIPT_REG_GLOBAL(AITHREAT_SUSPECT);
  944.         SCRIPT_REG_GLOBAL(AITHREAT_INTERESTING);
  945.         SCRIPT_REG_GLOBAL(AITHREAT_THREATENING);
  946.         SCRIPT_REG_GLOBAL(AITHREAT_AGGRESSIVE);
  947.  
  948.         SCRIPT_REG_GLOBAL(CHECKTYPE_MIN_DISTANCE);
  949.         SCRIPT_REG_GLOBAL(CHECKTYPE_MIN_ROOMSIZE);
  950.  
  951.         SCRIPT_REG_GLOBAL(AITSR_NONE);
  952.         SCRIPT_REG_GLOBAL(AITSR_SEE_STUNT_ACTION);
  953.         SCRIPT_REG_GLOBAL(AITSR_SEE_CLOAKED);
  954.  
  955.         SCRIPT_REG_GLOBAL(AIGOALPIPE_NOTDUPLICATE);
  956.         SCRIPT_REG_GLOBAL(AIGOALPIPE_LOOP);
  957.         SCRIPT_REG_GLOBAL(AIGOALPIPE_RUN_ONCE);
  958.         SCRIPT_REG_GLOBAL(AIGOALPIPE_HIGHPRIORITY);
  959.         SCRIPT_REG_GLOBAL(AIGOALPIPE_SAMEPRIORITY);
  960.         SCRIPT_REG_GLOBAL(AIGOALPIPE_DONT_RESET_AG);
  961.         SCRIPT_REG_GLOBAL(AIGOALPIPE_KEEP_LAST_SUBPIPE);
  962.         SCRIPT_REG_GLOBAL(AIGOALPIPE_KEEP_ON_TOP);
  963.  
  964.         gEnv->pScriptSystem->SetGlobalValue("ORDERED", SCommunicationRequest::Ordered);
  965.         gEnv->pScriptSystem->SetGlobalValue("UNORDERED", SCommunicationRequest::Unordered);
  966.  
  967.         SCRIPT_REG_GLOBAL(AI_REG_NONE);
  968.         SCRIPT_REG_GLOBAL(AI_REG_REFPOINT);
  969.         SCRIPT_REG_GLOBAL(AI_REG_LASTOP);
  970.         SCRIPT_REG_GLOBAL(AI_REG_ATTENTIONTARGET);
  971.         SCRIPT_REG_GLOBAL(AI_REG_COVER);
  972.         SCRIPT_REG_GLOBAL(AI_REG_PATH);
  973.  
  974.         gEnv->pScriptSystem->SetGlobalValue("AI_RGT_ANY", eRGT_ANY);
  975.         gEnv->pScriptSystem->SetGlobalValue("AI_RGT_SMOKE_GRENADE", eRGT_SMOKE_GRENADE);
  976.         gEnv->pScriptSystem->SetGlobalValue("AI_RGT_FLASHBANG_GRENADE", eRGT_FLASHBANG_GRENADE);
  977.         gEnv->pScriptSystem->SetGlobalValue("AI_RGT_FRAG_GRENADE", eRGT_FRAG_GRENADE);
  978.         gEnv->pScriptSystem->SetGlobalValue("AI_RGT_EMP_GRENADE", eRGT_EMP_GRENADE);
  979.         gEnv->pScriptSystem->SetGlobalValue("AI_RGT_GRUNT_GRENADE", eRGT_GRUNT_GRENADE);
  980.  
  981.         gEnv->pScriptSystem->SetGlobalValue("TTP_Last", eTTP_Last);
  982.         gEnv->pScriptSystem->SetGlobalValue("TTP_OverSounds", eTTP_OverSounds);
  983.         gEnv->pScriptSystem->SetGlobalValue("TTP_Always", eTTP_Always);
  984.  
  985.         gEnv->pScriptSystem->SetGlobalValue("NAV_TRIANGULAR", IAISystem::NAV_TRIANGULAR);
  986.         gEnv->pScriptSystem->SetGlobalValue("NAV_ROAD", IAISystem::NAV_ROAD);
  987.         gEnv->pScriptSystem->SetGlobalValue("NAV_WAYPOINT_HUMAN", IAISystem::NAV_WAYPOINT_HUMAN);
  988.         gEnv->pScriptSystem->SetGlobalValue("NAV_VOLUME", IAISystem::NAV_VOLUME);
  989.         gEnv->pScriptSystem->SetGlobalValue("NAV_UNSET", IAISystem::NAV_UNSET);
  990.         gEnv->pScriptSystem->SetGlobalValue("NAV_FLIGHT", IAISystem::NAV_FLIGHT);
  991.         gEnv->pScriptSystem->SetGlobalValue("NAV_WAYPOINT_3DSURFACE", IAISystem::NAV_WAYPOINT_3DSURFACE);
  992.         gEnv->pScriptSystem->SetGlobalValue("NAV_SMARTOBJECT", IAISystem::NAV_SMARTOBJECT);
  993.         gEnv->pScriptSystem->SetGlobalValue("NAV_FREE_2D", IAISystem::NAV_FREE_2D);
  994.         gEnv->pScriptSystem->SetGlobalValue("NAVMASK_SURFACE", IAISystem::NAVMASK_SURFACE);
  995.  
  996.         gEnv->pScriptSystem->SetGlobalValue("GROUP_ALL", IAISystem::GROUP_ALL);
  997.         gEnv->pScriptSystem->SetGlobalValue("GROUP_ENABLED", IAISystem::GROUP_ENABLED);
  998.         gEnv->pScriptSystem->SetGlobalValue("GROUP_MAX", IAISystem::GROUP_MAX);
  999.  
  1000.         SCRIPT_REG_GLOBAL(LA_NONE);
  1001.         SCRIPT_REG_GLOBAL(LA_HIDE);
  1002.         SCRIPT_REG_GLOBAL(LA_HOLD);
  1003.         SCRIPT_REG_GLOBAL(LA_ATTACK);
  1004.         SCRIPT_REG_GLOBAL(LA_SEARCH);
  1005.         SCRIPT_REG_GLOBAL(LA_FOLLOW);
  1006.         SCRIPT_REG_GLOBAL(LA_USE);
  1007.         SCRIPT_REG_GLOBAL(LA_USE_VEHICLE);
  1008.  
  1009.         SCRIPT_REG_GLOBAL(LAS_DEFAULT);
  1010.         SCRIPT_REG_GLOBAL(LAS_ATTACK_FUNNEL);
  1011.         SCRIPT_REG_GLOBAL(LAS_ATTACK_FLANK);
  1012.         SCRIPT_REG_GLOBAL(LAS_ATTACK_FLANK_HIDE);
  1013.         SCRIPT_REG_GLOBAL(LAS_ATTACK_FOLLOW_LEADER);
  1014.         SCRIPT_REG_GLOBAL(LAS_ATTACK_ROW);
  1015.         SCRIPT_REG_GLOBAL(LAS_ATTACK_CIRCLE);
  1016.         SCRIPT_REG_GLOBAL(LAS_ATTACK_LEAPFROG);
  1017.         SCRIPT_REG_GLOBAL(LAS_ATTACK_FRONT);
  1018.         SCRIPT_REG_GLOBAL(LAS_ATTACK_CHAIN);
  1019.         SCRIPT_REG_GLOBAL(LAS_ATTACK_COORDINATED_FIRE1);
  1020.         SCRIPT_REG_GLOBAL(LAS_ATTACK_COORDINATED_FIRE2);
  1021.         SCRIPT_REG_GLOBAL(LAS_ATTACK_USE_SPOTS);
  1022.         SCRIPT_REG_GLOBAL(LAS_ATTACK_HIDE);
  1023.         SCRIPT_REG_GLOBAL(LAS_ATTACK_HIDE_COVER);
  1024.         SCRIPT_REG_GLOBAL(LAS_ATTACK_SWITCH_POSITIONS);
  1025.         SCRIPT_REG_GLOBAL(LAS_ATTACK_CHASE);
  1026.         SCRIPT_REG_GLOBAL(LAS_SEARCH_DEFAULT);
  1027.         SCRIPT_REG_GLOBAL(LAS_SEARCH_COVER);
  1028.         SCRIPT_REG_GLOBAL(UPR_COMBAT_FLIGHT);
  1029.         SCRIPT_REG_GLOBAL(UPR_COMBAT_GROUND);
  1030.         SCRIPT_REG_GLOBAL(UPR_COMBAT_MARINE);
  1031.         SCRIPT_REG_GLOBAL(UPR_COMBAT_RECON);
  1032.  
  1033.         SCRIPT_REG_GLOBAL(AITARGET_NONE);
  1034.         SCRIPT_REG_GLOBAL(AITARGET_MEMORY);
  1035.         SCRIPT_REG_GLOBAL(AITARGET_VISUAL);
  1036.         SCRIPT_REG_GLOBAL(AITARGET_BEACON);
  1037.         SCRIPT_REG_GLOBAL(AITARGET_ENEMY);
  1038.         SCRIPT_REG_GLOBAL(AITARGET_SOUND);
  1039.         SCRIPT_REG_GLOBAL(AITARGET_GRENADE);
  1040.         SCRIPT_REG_GLOBAL(AITARGET_RPG);
  1041.         SCRIPT_REG_GLOBAL(AITARGET_FRIENDLY);
  1042.  
  1043.         SCRIPT_REG_GLOBAL(AIALERTSTATUS_SAFE);
  1044.         SCRIPT_REG_GLOBAL(AIALERTSTATUS_UNSAFE);
  1045.         SCRIPT_REG_GLOBAL(AIALERTSTATUS_READY);
  1046.         SCRIPT_REG_GLOBAL(AIALERTSTATUS_ACTION);
  1047.  
  1048.         SCRIPT_REG_GLOBAL(AIUSEOP_PLANTBOMB);
  1049.         SCRIPT_REG_GLOBAL(AIUSEOP_VEHICLE);
  1050.         SCRIPT_REG_GLOBAL(AIUSEOP_RPG);
  1051.  
  1052.         SCRIPT_REG_GLOBAL(AIREADIBILITY_NORMAL);
  1053.         SCRIPT_REG_GLOBAL(AIREADIBILITY_NOPRIORITY);
  1054.         SCRIPT_REG_GLOBAL(AIREADIBILITY_SEEN);
  1055.         SCRIPT_REG_GLOBAL(AIREADIBILITY_LOST);
  1056.         SCRIPT_REG_GLOBAL(AIREADIBILITY_INTERESTING);
  1057.  
  1058.         //SCRIPT_REG_GLOBAL("SIGNALID_THROWGRENADE", -10);
  1059.         gEnv->pScriptSystem->SetGlobalValue("SIGNALID_READIBILITY", SIGNALFILTER_READABILITY);
  1060.         gEnv->pScriptSystem->SetGlobalValue("SIGNALID_READIBILITYAT", SIGNALFILTER_READABILITYAT);
  1061.         SCRIPT_REG_GLOBAL(SIGNALFILTER_LASTOP);
  1062.         SCRIPT_REG_GLOBAL(SIGNALFILTER_GROUPONLY);
  1063.         SCRIPT_REG_GLOBAL(SIGNALFILTER_GROUPONLY_EXCEPT);
  1064.         SCRIPT_REG_GLOBAL(SIGNALFILTER_FACTIONONLY);
  1065.         SCRIPT_REG_GLOBAL(SIGNALFILTER_ANYONEINCOMM);
  1066.         SCRIPT_REG_GLOBAL(SIGNALFILTER_ANYONEINCOMM_EXCEPT);
  1067.         SCRIPT_REG_GLOBAL(SIGNALFILTER_TARGET);
  1068.         SCRIPT_REG_GLOBAL(SIGNALFILTER_SUPERGROUP);
  1069.         SCRIPT_REG_GLOBAL(SIGNALFILTER_SUPERFACTION);
  1070.         SCRIPT_REG_GLOBAL(SIGNALFILTER_SUPERTARGET);
  1071.         SCRIPT_REG_GLOBAL(SIGNALFILTER_NEARESTGROUP);
  1072.         SCRIPT_REG_GLOBAL(SIGNALFILTER_NEARESTINCOMM);
  1073.         SCRIPT_REG_GLOBAL(SIGNALFILTER_NEARESTINCOMM_FACTION);
  1074.         SCRIPT_REG_GLOBAL(SIGNALFILTER_NEARESTINCOMM_LOOKING);
  1075.         SCRIPT_REG_GLOBAL(SIGNALFILTER_HALFOFGROUP);
  1076.         SCRIPT_REG_GLOBAL(SIGNALFILTER_SENDER);
  1077.         SCRIPT_REG_GLOBAL(SIGNALFILTER_LEADER);
  1078.         SCRIPT_REG_GLOBAL(SIGNALFILTER_LEADERENTITY);
  1079.         SCRIPT_REG_GLOBAL(SIGNALFILTER_FORMATION);
  1080.         SCRIPT_REG_GLOBAL(SIGNALFILTER_FORMATION_EXCEPT);
  1081.  
  1082.         SCRIPT_REG_GLOBAL(AIOBJECTFILTER_SAMEFACTION);
  1083.         SCRIPT_REG_GLOBAL(AIOBJECTFILTER_SAMEGROUP);
  1084.         SCRIPT_REG_GLOBAL(AIOBJECTFILTER_NOGROUP);
  1085.         SCRIPT_REG_GLOBAL(AIOBJECTFILTER_INCLUDEINACTIVE);
  1086.  
  1087.         SCRIPT_REG_GLOBAL(AI_NOGROUP);
  1088.  
  1089.         SCRIPT_REG_GLOBAL(UNIT_CLASS_UNDEFINED);
  1090.         SCRIPT_REG_GLOBAL(UNIT_CLASS_INFANTRY);
  1091.         SCRIPT_REG_GLOBAL(UNIT_CLASS_SCOUT);
  1092.         SCRIPT_REG_GLOBAL(UNIT_CLASS_ENGINEER);
  1093.         SCRIPT_REG_GLOBAL(UNIT_CLASS_MEDIC);
  1094.         SCRIPT_REG_GLOBAL(UNIT_CLASS_LEADER);
  1095.         SCRIPT_REG_GLOBAL(UNIT_CLASS_CIVILIAN);
  1096.         SCRIPT_REG_GLOBAL(UNIT_CLASS_COMPANION);
  1097.         SCRIPT_REG_GLOBAL(SPECIAL_FORMATION_POINT);
  1098.         SCRIPT_REG_GLOBAL(SHOOTING_SPOT_POINT);
  1099.  
  1100.         SCRIPT_REG_GLOBAL(AIANCHOR_NEAREST);
  1101.         SCRIPT_REG_GLOBAL(AIANCHOR_NEAREST_IN_FRONT);
  1102.         SCRIPT_REG_GLOBAL(AIANCHOR_RANDOM_IN_RANGE);
  1103.         SCRIPT_REG_GLOBAL(AIANCHOR_RANDOM_IN_RANGE_FACING_AT);
  1104.         SCRIPT_REG_GLOBAL(AIANCHOR_NEAREST_FACING_AT);
  1105.         SCRIPT_REG_GLOBAL(AIANCHOR_NEAREST_TO_REFPOINT);
  1106.         SCRIPT_REG_GLOBAL(AIANCHOR_FARTHEST);
  1107.         SCRIPT_REG_GLOBAL(AIANCHOR_BEHIND_IN_RANGE);
  1108.         SCRIPT_REG_GLOBAL(AIANCHOR_LEFT_TO_REFPOINT);
  1109.         SCRIPT_REG_GLOBAL(AIANCHOR_RIGHT_TO_REFPOINT);
  1110.         SCRIPT_REG_GLOBAL(AIANCHOR_HIDE_FROM_REFPOINT);
  1111.         SCRIPT_REG_GLOBAL(AIANCHOR_SEES_TARGET);
  1112.         SCRIPT_REG_GLOBAL(AIANCHOR_BEHIND);
  1113.  
  1114.         SCRIPT_REG_GLOBAL(BRANCH_ALWAYS);
  1115.         SCRIPT_REG_GLOBAL(IF_ACTIVE_GOALS);
  1116.         SCRIPT_REG_GLOBAL(IF_ACTIVE_GOALS_HIDE);
  1117.         SCRIPT_REG_GLOBAL(IF_NO_PATH);
  1118.         SCRIPT_REG_GLOBAL(IF_PATH_STILL_FINDING);
  1119.         SCRIPT_REG_GLOBAL(IF_IS_HIDDEN);
  1120.         SCRIPT_REG_GLOBAL(IF_CAN_HIDE);
  1121.         SCRIPT_REG_GLOBAL(IF_CANNOT_HIDE);
  1122.         SCRIPT_REG_GLOBAL(IF_STANCE_IS);
  1123.         SCRIPT_REG_GLOBAL(IF_FIRE_IS);
  1124.         SCRIPT_REG_GLOBAL(IF_HAS_FIRED);
  1125.         SCRIPT_REG_GLOBAL(IF_NO_LASTOP);
  1126.         SCRIPT_REG_GLOBAL(IF_SEES_LASTOP);
  1127.         SCRIPT_REG_GLOBAL(IF_SEES_TARGET);
  1128.         SCRIPT_REG_GLOBAL(IF_EXPOSED_TO_TARGET);
  1129.         SCRIPT_REG_GLOBAL(IF_CAN_SHOOT_TARGET);
  1130.         SCRIPT_REG_GLOBAL(IF_CAN_MELEE);
  1131.         SCRIPT_REG_GLOBAL(IF_NO_ENEMY_TARGET);
  1132.         SCRIPT_REG_GLOBAL(IF_PATH_LONGER);
  1133.         SCRIPT_REG_GLOBAL(IF_PATH_SHORTER);
  1134.         SCRIPT_REG_GLOBAL(IF_PATH_LONGER_RELATIVE);
  1135.         SCRIPT_REG_GLOBAL(IF_NAV_TRIANGULAR);
  1136.         SCRIPT_REG_GLOBAL(IF_NAV_WAYPOINT_HUMAN);
  1137.         SCRIPT_REG_GLOBAL(IF_TARGET_DIST_LESS);
  1138.         SCRIPT_REG_GLOBAL(IF_TARGET_DIST_GREATER);
  1139.         SCRIPT_REG_GLOBAL(IF_TARGET_IN_RANGE);
  1140.         SCRIPT_REG_GLOBAL(IF_TARGET_OUT_OF_RANGE);
  1141.         SCRIPT_REG_GLOBAL(IF_TARGET_MOVED_SINCE_START);
  1142.         SCRIPT_REG_GLOBAL(IF_TARGET_MOVED);
  1143.         SCRIPT_REG_GLOBAL(IF_TARGET_LOST_TIME_MORE);
  1144.         SCRIPT_REG_GLOBAL(IF_TARGET_LOST_TIME_LESS);
  1145.         SCRIPT_REG_GLOBAL(IF_COVER_COMPROMISED);
  1146.         SCRIPT_REG_GLOBAL(IF_COVER_NOT_COMPROMISED);
  1147.         SCRIPT_REG_GLOBAL(IF_COVER_SOFT);
  1148.         SCRIPT_REG_GLOBAL(IF_COVER_NOT_SOFT);
  1149.         SCRIPT_REG_GLOBAL(IF_CAN_SHOOT_TARGET_CROUCHED);
  1150.         SCRIPT_REG_GLOBAL(IF_COVER_FIRE_ENABLED);
  1151.         SCRIPT_REG_GLOBAL(IF_RANDOM);
  1152.         SCRIPT_REG_GLOBAL(IF_LASTOP_FAILED);
  1153.         SCRIPT_REG_GLOBAL(IF_LASTOP_SUCCEED);
  1154.         SCRIPT_REG_GLOBAL(NOT);
  1155.  
  1156.         SCRIPT_REG_GLOBAL(AIFAF_VISIBLE_FROM_REQUESTER);
  1157.         SCRIPT_REG_GLOBAL(AIFAF_INCLUDE_DEVALUED);
  1158.         SCRIPT_REG_GLOBAL(AIFAF_INCLUDE_DISABLED);
  1159.  
  1160.         // These numerical values are deprecated; use the strings instead
  1161.         SCRIPT_REG_GLOBAL(AIPATH_DEFAULT);
  1162.         SCRIPT_REG_GLOBAL(AIPATH_HUMAN);
  1163.         SCRIPT_REG_GLOBAL(AIPATH_HUMAN_COVER);
  1164.         SCRIPT_REG_GLOBAL(AIPATH_CAR);
  1165.         SCRIPT_REG_GLOBAL(AIPATH_TANK);
  1166.         SCRIPT_REG_GLOBAL(AIPATH_BOAT);
  1167.         SCRIPT_REG_GLOBAL(AIPATH_HELI);
  1168.         SCRIPT_REG_GLOBAL(AIPATH_3D);
  1169.         SCRIPT_REG_GLOBAL(AIPATH_SCOUT);
  1170.         SCRIPT_REG_GLOBAL(AIPATH_TROOPER);
  1171.         SCRIPT_REG_GLOBAL(AIPATH_HUNTER);
  1172.  
  1173.         SCRIPT_REG_GLOBAL(PFB_NONE);
  1174.         SCRIPT_REG_GLOBAL(PFB_ATT_TARGET);
  1175.         SCRIPT_REG_GLOBAL(PFB_REF_POINT);
  1176.         SCRIPT_REG_GLOBAL(PFB_BEACON);
  1177.         SCRIPT_REG_GLOBAL(PFB_DEAD_BODIES);
  1178.         SCRIPT_REG_GLOBAL(PFB_EXPLOSIVES);
  1179.         SCRIPT_REG_GLOBAL(PFB_PLAYER);
  1180.         SCRIPT_REG_GLOBAL(PFB_BETWEEN_NAV_TARGET);
  1181.  
  1182.         SCRIPT_REG_GLOBAL(COVER_UNHIDE);
  1183.         SCRIPT_REG_GLOBAL(COVER_HIDE);
  1184.  
  1185.         SCRIPT_REG_GLOBAL(ADJUSTAIM_AIM);
  1186.         SCRIPT_REG_GLOBAL(ADJUSTAIM_HIDE);
  1187.  
  1188.         SCRIPT_REG_GLOBAL(AIPROX_SIGNAL_ON_OBJ_DISABLE);
  1189.         SCRIPT_REG_GLOBAL(AIPROX_VISIBLE_TARGET_ONLY);
  1190.  
  1191.         SCRIPT_REG_GLOBAL(AIANIM_SIGNAL);
  1192.         SCRIPT_REG_GLOBAL(AIANIM_ACTION);
  1193.  
  1194.         SCRIPT_REG_GLOBAL(DIR_NORTH);
  1195.         SCRIPT_REG_GLOBAL(DIR_SOUTH);
  1196.         SCRIPT_REG_GLOBAL(DIR_EAST);
  1197.         SCRIPT_REG_GLOBAL(DIR_WEST);
  1198.  
  1199.         SCRIPT_REG_GLOBAL(WAIT_ALL);
  1200.         SCRIPT_REG_GLOBAL(WAIT_ANY);
  1201.         SCRIPT_REG_GLOBAL(WAIT_ANY_2);
  1202.  
  1203.         SCRIPT_REG_GLOBAL(SOUND_INTERESTING);
  1204.         SCRIPT_REG_GLOBAL(SOUND_THREATENING);
  1205.  
  1206.         SCRIPT_REG_GLOBAL(AI_JUMP_CHECK_COLLISION);
  1207.         SCRIPT_REG_GLOBAL(AI_JUMP_ON_GROUND);
  1208.         SCRIPT_REG_GLOBAL(AI_JUMP_RELATIVE);
  1209.         SCRIPT_REG_GLOBAL(AI_JUMP_MOVING_TARGET);
  1210.  
  1211.         SCRIPT_REG_GLOBAL(JUMP_ANIM_FLY);
  1212.         SCRIPT_REG_GLOBAL(JUMP_ANIM_LAND);
  1213.  
  1214.         SCRIPT_REG_GLOBAL(STANCE_PRONE);
  1215.         SCRIPT_REG_GLOBAL(STANCE_CROUCH);
  1216.         SCRIPT_REG_GLOBAL(STANCE_STAND);
  1217.         SCRIPT_REG_GLOBAL(STANCE_RELAXED);
  1218.         SCRIPT_REG_GLOBAL(STANCE_LOW_COVER);
  1219.         SCRIPT_REG_GLOBAL(STANCE_HIGH_COVER);
  1220.         SCRIPT_REG_GLOBAL(STANCE_ALERTED);
  1221.         SCRIPT_REG_GLOBAL(STANCE_STEALTH);
  1222.         SCRIPT_REG_GLOBAL(STANCE_SWIM);
  1223.  
  1224.         gEnv->pScriptSystem->SetGlobalValue("SPEED_ZERO", AISPEED_ZERO);
  1225.         gEnv->pScriptSystem->SetGlobalValue("SPEED_SLOW", AISPEED_SLOW);
  1226.         gEnv->pScriptSystem->SetGlobalValue("SPEED_WALK", AISPEED_WALK);
  1227.         gEnv->pScriptSystem->SetGlobalValue("SPEED_RUN", AISPEED_RUN);
  1228.         gEnv->pScriptSystem->SetGlobalValue("SPEED_SPRINT", AISPEED_SPRINT);
  1229.  
  1230.         // Marcio: Kept here for retro-compatibility
  1231.         gEnv->pScriptSystem->SetGlobalValue("BODYPOS_PRONE", STANCE_PRONE);
  1232.         gEnv->pScriptSystem->SetGlobalValue("BODYPOS_CROUCH", STANCE_CROUCH);
  1233.         gEnv->pScriptSystem->SetGlobalValue("BODYPOS_STAND", STANCE_STAND);
  1234.         gEnv->pScriptSystem->SetGlobalValue("BODYPOS_RELAX", STANCE_RELAXED);
  1235.         gEnv->pScriptSystem->SetGlobalValue("BODYPOS_STEALTH", STANCE_STEALTH);
  1236.  
  1237.         gEnv->pScriptSystem->SetGlobalValue("MFT_Disabled", eMFT_Disabled);
  1238.         gEnv->pScriptSystem->SetGlobalValue("MFT_UseCoverFireTime", eMFT_UseCoverFireTime);
  1239.         gEnv->pScriptSystem->SetGlobalValue("MFT_Always", eMFT_Always);
  1240.  
  1241.         SCRIPT_REG_FUNC(GoTo);
  1242.         SCRIPT_REG_FUNC(SetSpeed);
  1243.         SCRIPT_REG_FUNC(SetEntitySpeedRange);
  1244.  
  1245.         gEnv->pScriptSystem->SetGlobalValue("AVOIDANCE_NONE", eAvoidance_NONE);
  1246.         gEnv->pScriptSystem->SetGlobalValue("AVOIDANCE_VEHICLES", eAvoidance_Vehicles);
  1247.         gEnv->pScriptSystem->SetGlobalValue("AVOIDANCE_PUPPETS", eAvoidance_Actors);
  1248.         gEnv->pScriptSystem->SetGlobalValue("AVOIDANCE_PLAYERS", eAvoidance_Players);
  1249.         gEnv->pScriptSystem->SetGlobalValue("AVOIDANCE_STATIC_OBSTACLES", eAvoidance_StaticObstacle);
  1250.         gEnv->pScriptSystem->SetGlobalValue("AVOIDANCE_PUSHABLE_OBSTACLES", eAvoidance_PushableObstacle);
  1251.         gEnv->pScriptSystem->SetGlobalValue("AVOIDANCE_DAMAGE_REGION", eAvoidance_DamageRegion);
  1252.         gEnv->pScriptSystem->SetGlobalValue("AVOIDANCE_ALL", eAvoidance_ALL);
  1253.         gEnv->pScriptSystem->SetGlobalValue("AVOIDANCE_DEFAULT", eAvoidance_DEFAULT);
  1254.  
  1255.         gEnv->pScriptSystem->SetGlobalValue("EST_Generic", TargetTrackHelpers::eEST_Generic);
  1256.         gEnv->pScriptSystem->SetGlobalValue("EST_Visual", TargetTrackHelpers::eEST_Visual);
  1257.         gEnv->pScriptSystem->SetGlobalValue("EST_Sound", TargetTrackHelpers::eEST_Sound);
  1258.         gEnv->pScriptSystem->SetGlobalValue("EST_BulletRain", TargetTrackHelpers::eEST_BulletRain);
  1259.  
  1260.         SCRIPT_REG_TEMPLFUNC(SetLastOpResult, "entityID, targetEntityId");
  1261.  
  1262.         RunStartupScript();
  1263.         InitLookUp();
  1264. }
  1265.  
  1266. //====================================================================
  1267. // ~CScriptBind_AI
  1268. //====================================================================
  1269. CScriptBind_AI::~CScriptBind_AI(void)
  1270. {
  1271. }
  1272.  
  1273. //====================================================================
  1274. // RunStartupScript
  1275. //====================================================================
  1276. void CScriptBind_AI::RunStartupScript()
  1277. {
  1278.         m_pSS->ExecuteFile("scripts/ai/aiconfig.lua", true);
  1279. }
  1280.  
  1281. //====================================================================
  1282. // Fetch entity ID from script parameter
  1283. //====================================================================
  1284. EntityId CScriptBind_AI::GetEntityIdFromParam(IFunctionHandler* pH, int i)
  1285. {
  1286.         assert(pH);
  1287.         assert(i > 0);
  1288.         ScriptHandle hdl(0);
  1289.         if (pH->GetParam(i, hdl))
  1290.         {
  1291.                 return static_cast<EntityId>(hdl.n);
  1292.         }
  1293.  
  1294.         return 0;
  1295. }
  1296.  
  1297. //====================================================================
  1298. // Fetch entity pointer from script parameter
  1299. //====================================================================
  1300. IEntity* CScriptBind_AI::GetEntityFromParam(IFunctionHandler* pH, int i)
  1301. {
  1302.         EntityId nID = GetEntityIdFromParam(pH, i);
  1303.         return gEnv->pEntitySystem->GetEntity(nID);
  1304. }
  1305.  
  1306. //====================================================================
  1307. // Warning
  1308. //====================================================================
  1309. int CScriptBind_AI::Warning(IFunctionHandler* pH)
  1310. {
  1311.         SCRIPT_CHECK_PARAMETERS(1);
  1312.         const char* sParam = NULL;
  1313.         pH->GetParam(1, sParam);
  1314.         if (sParam && GetAISystem())
  1315.                 AIWarningID("<Lua> ", "%s", sParam);
  1316.         return (pH->EndFunction());
  1317. }
  1318.  
  1319. //====================================================================
  1320. // Error
  1321. //====================================================================
  1322. int CScriptBind_AI::Error(IFunctionHandler* pH)
  1323. {
  1324.         SCRIPT_CHECK_PARAMETERS(1);
  1325.         const char* sParam = NULL;
  1326.         pH->GetParam(1, sParam);
  1327.         if (sParam && GetAISystem())
  1328.                 AIErrorID("<Lua> ", "%s", sParam);
  1329.         return (pH->EndFunction());
  1330. }
  1331.  
  1332. //====================================================================
  1333. // LogProgress
  1334. //====================================================================
  1335. int CScriptBind_AI::LogProgress(IFunctionHandler* pH)
  1336. {
  1337.         SCRIPT_CHECK_PARAMETERS(1);
  1338.         const char* sParam = NULL;
  1339.         pH->GetParam(1, sParam);
  1340.         if (sParam && GetAISystem())
  1341.                 GetAISystem()->LogProgress("<Lua> ", "%s", sParam);
  1342.         return (pH->EndFunction());
  1343. }
  1344.  
  1345. //====================================================================
  1346. // LogEvent
  1347. //====================================================================
  1348. int CScriptBind_AI::LogEvent(IFunctionHandler* pH)
  1349. {
  1350.         SCRIPT_CHECK_PARAMETERS(1);
  1351.         const char* sParam = NULL;
  1352.         pH->GetParam(1, sParam);
  1353.         if (sParam && GetAISystem())
  1354.                 GetAISystem()->LogEvent("<Lua> ", "%s", sParam);
  1355.         return (pH->EndFunction());
  1356. }
  1357.  
  1358. //====================================================================
  1359. // LogComment
  1360. //====================================================================
  1361. int CScriptBind_AI::LogComment(IFunctionHandler* pH)
  1362. {
  1363.         SCRIPT_CHECK_PARAMETERS(1);
  1364.         const char* sParam = NULL;
  1365.         pH->GetParam(1, sParam);
  1366.         if (sParam && GetAISystem())
  1367.                 GetAISystem()->LogComment("<Lua> ", "%s", sParam);
  1368.         return (pH->EndFunction());
  1369. }
  1370.  
  1371. //====================================================================
  1372. // RecComment
  1373. //====================================================================
  1374. int CScriptBind_AI::RecComment(IFunctionHandler* pH)
  1375. {
  1376.         //      SCRIPT_CHECK_PARAMETERS(2);
  1377.         GET_ENTITY(1);
  1378.         const char* sComment = NULL;
  1379.         pH->GetParam(2, sComment);
  1380.         if (sComment && pEntity && pEntity->GetAI())
  1381.         {
  1382.                 IAIRecordable::RecorderEventData recorderEventData(sComment);
  1383.                 pEntity->GetAI()->RecordEvent(IAIRecordable::E_LUACOMMENT, &recorderEventData);
  1384.  
  1385. #ifdef CRYAISYSTEM_DEBUG
  1386.                 AILogAlways("Lua Comment: Entity: %s: %s", pEntity->GetName(), sComment);
  1387. #endif
  1388.         }
  1389.         return (pH->EndFunction());
  1390. }
  1391.  
  1392. /*
  1393.    //
  1394.    //-----------------------------------------------------------------------------------------------------------
  1395.    int CScriptBind_AI::AddSmartObjectCondition(IFunctionHandler *pH)
  1396.    {
  1397.    SCRIPT_CHECK_PARAMETERS( 1 );
  1398.    SmartScriptTable pTable, pObject, pUser, pLimits, pDelay, pMultipliers, pAction;
  1399.    pH->GetParam( 1, pTable );
  1400.  
  1401.    const char* temp;
  1402.    SmartObjectCondition condition;
  1403.    pTable->GetValue( "sName", temp ); condition.sName = temp;
  1404.    pTable->GetValue( "sDescription", temp ); condition.sDescription = temp;
  1405.    pTable->GetValue( "sFolder", temp ); condition.sFolder = temp;
  1406.    pTable->GetValue( "iMaxAlertness", condition.iMaxAlertness );
  1407.    pTable->GetValue( "bEnabled", condition.bEnabled );
  1408.    pTable->GetValue( "iRuleType", condition.iRuleType );
  1409.    pTable->GetValue( "sohelper_EntranceHelper", temp ); condition.sEntranceHelper = temp;
  1410.    pTable->GetValue( "sohelper_ExitHelper", temp ); condition.sExitHelper = temp;
  1411.    pTable->GetValue( "Object", pObject );
  1412.    pObject->GetValue( "soclass_Class", temp ); condition.sObjectClass = temp;
  1413.    pObject->GetValue( "sopattern_State", temp ); condition.sObjectState = temp;
  1414.    pObject->GetValue( "sohelper_Helper", temp ); condition.sObjectHelper = temp;
  1415.    pTable->GetValue( "User", pUser );
  1416.    pUser->GetValue( "soclass_Class", temp ); condition.sUserClass = temp;
  1417.    pUser->GetValue( "soPattern_State", temp ); condition.sUserState = temp;
  1418.    pUser->GetValue( "sohelper_Helper", temp ); condition.sUserHelper = temp;
  1419.    pTable->GetValue( "Limits", pLimits );
  1420.    pLimits->GetValue( "fDistanceFrom", condition.fDistanceFrom );
  1421.    pLimits->GetValue( "fDistanceTo", condition.fDistanceTo );
  1422.    pLimits->GetValue( "fOrientation", condition.fOrientationLimit );
  1423.    pLimits->GetValue( "fOrientToTargetLimit", condition.fOrientationToTargetLimit );
  1424.    pTable->GetValue( "Delay", pDelay );
  1425.    pDelay->GetValue( "fMinimum", condition.fMinDelay );
  1426.    pDelay->GetValue( "fMaximum", condition.fMaxDelay );
  1427.    pDelay->GetValue( "fMemory", condition.fMemory );
  1428.    pTable->GetValue( "Multipliers", pMultipliers );
  1429.    pMultipliers->GetValue( "fProximity", condition.fProximityFactor );
  1430.    pMultipliers->GetValue( "fOrientation", condition.fOrientationFactor );
  1431.    pMultipliers->GetValue( "fVisibility", condition.fVisibilityFactor );
  1432.    pMultipliers->GetValue( "fRandomness", condition.fRandomnessFactor );
  1433.    pTable->GetValue( "Action", pAction );
  1434.    pAction->GetValue( "fLookAtOnPerc", condition.fLookAtOnPerc );
  1435.    pAction->GetValue( "sostates_ObjectPostActionState", temp ); condition.sObjectPostActionState = temp;
  1436.    pAction->GetValue( "sostates_UserPostActionState", temp ); condition.sUserPostActionState = temp;
  1437.    pAction->GetValue( "soaction_Name", temp ); condition.sAction = temp;
  1438.    pAction->GetValue( "sostates_ObjectPreActionState", temp ); condition.sObjectPreActionState = temp;
  1439.    pAction->GetValue( "sostates_UserPreActionState", temp ); condition.sUserPreActionState = temp;
  1440.  
  1441.    GetAISystem()->AddSmartObjectCondition( condition );
  1442.    return pH->EndFunction();
  1443.    }
  1444.  */
  1445.  
  1446. //
  1447. //-----------------------------------------------------------------------------------------------------------
  1448. int CScriptBind_AI::ExecuteAction(IFunctionHandler* pH)
  1449. {
  1450.         const char* sActionName = NULL;
  1451.         if (!pH->GetParam(1, sActionName))
  1452.         {
  1453.                 gEnv->pAISystem->LogComment("<CScriptBind_AI::ExecuteAction> ", "ERROR: AI Action (param 1) must reference the Action name!");
  1454.                 return pH->EndFunction();
  1455.         }
  1456.  
  1457.         IEntity* pUser = NULL;
  1458.         IEntity* pObject = NULL;
  1459.  
  1460.         EntityId nUserID = GetEntityIdFromParam(pH, 2);
  1461.         if (!nUserID)
  1462.         {
  1463.                 gEnv->pAISystem->LogComment("<CScriptBind_AI::ExecuteAction> ", "ERROR: Not an entity id (param 2)!");
  1464.                 return pH->EndFunction();
  1465.         }
  1466.         else
  1467.         {
  1468.                 pUser = gEnv->pEntitySystem->GetEntity(nUserID);
  1469.                 if (!pUser)
  1470.                 {
  1471.                         gEnv->pAISystem->LogComment("<CScriptBind_AI::ExecuteAction> ", "ERROR: Specified entity id (param 2) not found!");
  1472.                         return pH->EndFunction();
  1473.                 }
  1474.         }
  1475.  
  1476.         EntityId nObjectID = GetEntityIdFromParam(pH, 3);
  1477.         if (!nObjectID)
  1478.         {
  1479.                 gEnv->pAISystem->LogComment("<CScriptBind_AI::ExecuteAction> ", "ERROR: Not an entity id (param 3)!");
  1480.                 return pH->EndFunction();
  1481.         }
  1482.         else
  1483.         {
  1484.                 pObject = gEnv->pEntitySystem->GetEntity(nObjectID);
  1485.                 if (!pObject)
  1486.                 {
  1487.                         gEnv->pAISystem->LogComment("<CScriptBind_AI::ExecuteAction> ", "ERROR: Specified entity id (param 3) not found!");
  1488.                         return pH->EndFunction();
  1489.                 }
  1490.         }
  1491.  
  1492.         int maxAlertness = 0;
  1493.         pH->GetParam(4, maxAlertness);
  1494.  
  1495.         int goalPipeId = 0;
  1496.         if (pH->GetParamCount() > 4)
  1497.                 pH->GetParam(5, goalPipeId);
  1498.  
  1499.         gAIEnv.pAIActionManager->ExecuteAIAction(sActionName, pUser, pObject, maxAlertness, goalPipeId);
  1500.  
  1501.         return pH->EndFunction();
  1502. }
  1503.  
  1504. //
  1505. //-----------------------------------------------------------------------------------------------------------
  1506. int CScriptBind_AI::AbortAction(IFunctionHandler* pH)
  1507. {
  1508.         IEntity* pUser = NULL;
  1509.  
  1510.         EntityId nUserID = GetEntityIdFromParam(pH, 1);
  1511.         if (!nUserID)
  1512.         {
  1513.                 gEnv->pAISystem->LogComment("<CScriptBind_AI::AbortAction> ", "ERROR: Not an entity id (param 1)!");
  1514.                 return pH->EndFunction();
  1515.         }
  1516.         else
  1517.         {
  1518.                 pUser = gEnv->pEntitySystem->GetEntity(nUserID);
  1519.                 if (!pUser)
  1520.                 {
  1521.                         gEnv->pAISystem->LogComment("<CScriptBind_AI::AbortAction> ", "ERROR: Specified entity id (param 1) not found!");
  1522.                         return pH->EndFunction();
  1523.                 }
  1524.         }
  1525.  
  1526.         int goalPipeId = 0;
  1527.         if (pH->GetParamCount() > 1)
  1528.                 pH->GetParam(2, goalPipeId);
  1529.  
  1530.         gAIEnv.pAIActionManager->AbortAIAction(pUser, goalPipeId);
  1531.  
  1532.         return pH->EndFunction();
  1533. }
  1534.  
  1535. //
  1536. //-----------------------------------------------------------------------------------------------------------
  1537. int CScriptBind_AI::SetSmartObjectState(IFunctionHandler* pH)
  1538. {
  1539.         SCRIPT_CHECK_PARAMETERS(2);
  1540.         GET_ENTITY(1);
  1541.         const char* stateName;
  1542.         if (pEntity && gAIEnv.pSmartObjectManager)
  1543.         {
  1544.                 pH->GetParam(2, stateName);
  1545.                 gAIEnv.pSmartObjectManager->SetSmartObjectState(pEntity, stateName);
  1546.         }
  1547.         return pH->EndFunction();
  1548. }
  1549.  
  1550. //
  1551. //-----------------------------------------------------------------------------------------------------------
  1552. int CScriptBind_AI::ModifySmartObjectStates(IFunctionHandler* pH)
  1553. {
  1554.         SCRIPT_CHECK_PARAMETERS(2);
  1555.         GET_ENTITY(1);
  1556.         if (pEntity && gAIEnv.pSmartObjectManager)
  1557.         {
  1558.                 const char* listStates;
  1559.                 pH->GetParam(2, listStates);
  1560.                 gAIEnv.pSmartObjectManager->ModifySmartObjectStates(pEntity, listStates);
  1561.         }
  1562.         return pH->EndFunction();
  1563. }
  1564.  
  1565. //
  1566. //-----------------------------------------------------------------------------------------------------------
  1567. int CScriptBind_AI::SmartObjectEvent(IFunctionHandler* pH)
  1568. {
  1569.         FUNCTION_PROFILER(GetISystem(), PROFILE_AI);
  1570.  
  1571.         int id = 0;
  1572.  
  1573.         if (gAIEnv.pSmartObjectManager)
  1574.         {
  1575.                 const char* sActionName = NULL;
  1576.                 if (!pH->GetParam(1, sActionName))
  1577.                 {
  1578.                         AIErrorID("<CScriptBind_AI::SmartObjectEvent> ", "ERROR: The first parameter must be the name of the smart action!");
  1579.                         return pH->EndFunction();
  1580.                 }
  1581.  
  1582.                 IEntity* pUser = NULL;
  1583.                 IEntity* pObject = NULL;
  1584.  
  1585.                 if (pH->GetParamCount() > 1 && pH->GetParamType(2) != svtNull)
  1586.                 {
  1587.                         pUser = GetEntityFromParam(pH, 2);
  1588.                         if (!pUser)
  1589.                                 AIWarningID("<CScriptBind_AI::SmartObjectEvent> ", "WARNING: Specified entity id (param 2) not found!");
  1590.                 }
  1591.  
  1592.                 if (pH->GetParamCount() > 2 && pH->GetParamType(3) != svtNull)
  1593.                 {
  1594.                         pObject = GetEntityFromParam(pH, 3);
  1595.                         if (!pObject)
  1596.                                 AIWarningID("<CScriptBind_AI::SmartObjectEvent> ", "WARNING: Specified entity id (param 3) not found!");
  1597.                 }
  1598.  
  1599.                 bool bUseRefPoint = false;
  1600.                 Vec3 vRefPoint;
  1601.                 if (pH->GetParamCount() > 3 && pH->GetParamType(4) != svtNull && pH->GetParam(4, vRefPoint))
  1602.                         bUseRefPoint = true;
  1603.  
  1604.                 id = gAIEnv.pSmartObjectManager->SmartObjectEvent(sActionName, pUser, pObject, bUseRefPoint ? &vRefPoint : NULL);
  1605.         }
  1606.  
  1607.         return pH->EndFunction(id);   // returns the id of the inserted goal pipe or 0 if no rule was found
  1608. }
  1609.  
  1610. //
  1611. //-----------------------------------------------------------------------------------------------------------
  1612. int CScriptBind_AI::GetLastUsedSmartObject(IFunctionHandler* pH)
  1613. {
  1614.         GET_ENTITY(1);
  1615.         if (!pEntity)
  1616.         {
  1617.                 AIWarningID("<CScriptBind_AI> ", "GetLastUsedSmartObject: Entity with id [%d] doesn't exist.", nID);
  1618.                 return pH->EndFunction();
  1619.         }
  1620.  
  1621.         IAIObject* pAI = pEntity->GetAI();
  1622.         if (!pAI)
  1623.         {
  1624.                 AIWarningID("<CScriptBind_AI> ", "GetLastUsedSmartObject: Entity [%s] is not registered in AI.", pEntity->GetName());
  1625.                 return pH->EndFunction();
  1626.         }
  1627.  
  1628.         IPipeUser* pPipeUser = pAI->CastToIPipeUser();
  1629.         if (!pPipeUser)
  1630.         {
  1631.                 AIWarningID("<CScriptBind_AI> ", "GetLastUsedSmartObject: Entity [%s] is registered in AI but not as a PipeUser.", pEntity->GetName());
  1632.                 return pH->EndFunction();
  1633.         }
  1634.  
  1635.         IEntity* pObject = gEnv->pEntitySystem->GetEntity(pPipeUser->GetLastUsedSmartObjectId());
  1636.         if (pObject)
  1637.                 return pH->EndFunction(pObject->GetScriptTable());   // returns the script table of the last used smart object entity
  1638.         else
  1639.                 return pH->EndFunction(); // there's no last used smart object - return nil
  1640. }
  1641.  
  1642. //
  1643. //-----------------------------------------------------------------------------------------------------------
  1644. bool CScriptBind_AI::ParseTables(int firstTable, bool parseMovementAbility, IFunctionHandler* pH, AIObjectParams& params, bool& autoDisable)
  1645. {
  1646.         AgentParameters& agentParams = params.m_sParamStruct;
  1647.  
  1648.         SmartScriptTable pTable;
  1649.         SmartScriptTable pTableInstance;
  1650.         SmartScriptTable pMovementTable;
  1651.         SmartScriptTable pMeleeTable;
  1652.         // Properties table
  1653.         if (pH->GetParamCount() > firstTable - 1)
  1654.                 pH->GetParam(firstTable, pTable);
  1655.         else
  1656.                 return false;
  1657.  
  1658.         if (!pTable)
  1659.         {
  1660.                 AIWarning("Failed to find table '%s'...", pH->GetFuncName());
  1661.                 return false;
  1662.         }
  1663.  
  1664.         // Instance Properties table
  1665.         if (pH->GetParamCount() > firstTable)
  1666.                 pH->GetParam(firstTable + 1, pTableInstance);
  1667.         else
  1668.                 return false;
  1669.  
  1670.         if (!pTableInstance)
  1671.         {
  1672.                 AIWarning("Failed to find table instance '%s'...", pH->GetFuncName());
  1673.                 return false;
  1674.         }
  1675.  
  1676.         if (parseMovementAbility)
  1677.         {
  1678.                 // Movement Abilities table
  1679.                 if (pH->GetParamCount() > firstTable + 1)
  1680.                         pH->GetParam(firstTable + 2, pMovementTable);
  1681.                 else
  1682.                         return false;
  1683.         }
  1684.  
  1685.         pTable->GetValue("bFactionHostility", params.m_sParamStruct.factionHostility);
  1686.         pTable->GetValue("bAffectSOM", params.m_sParamStruct.m_bPerceivePlayer);
  1687.         pTable->GetValue("awarenessOfPlayer", params.m_sParamStruct.m_fAwarenessOfPlayer);
  1688.  
  1689.         if (!pTable->GetValue("commrange", params.m_sParamStruct.m_fCommRange))
  1690.                 pTableInstance->GetValue("commrange", params.m_sParamStruct.m_fCommRange);
  1691.         if (!pTable->GetValue("strafingPitch", params.m_sParamStruct.m_fStrafingPitch))
  1692.                 params.m_sParamStruct.m_fStrafingPitch = 0.0f;
  1693.  
  1694.         if (!pTable->GetValue("groupid", params.m_sParamStruct.m_nGroup))
  1695.                 pTableInstance->GetValue("groupid", params.m_sParamStruct.m_nGroup);
  1696.  
  1697.         const char* faction = 0;
  1698.         if (pTable->GetValue("esFaction", faction))
  1699.         {
  1700.                 params.m_sParamStruct.factionID = gAIEnv.pFactionMap->GetFactionID(faction);
  1701.                 if (faction && *faction && (params.m_sParamStruct.factionID == IFactionMap::InvalidFactionID))
  1702.                 {
  1703.                         AIWarning("Unknown faction '%s' being set...", faction);
  1704.                 }
  1705.         }
  1706.         else
  1707.         {
  1708.                 // Mrcio: backwards compatibility
  1709.                 int species = -1;
  1710.                 if (!pTable->GetValue("eiSpecies", species))
  1711.                         pTable->GetValue("species", species);
  1712.  
  1713.                 if (species > -1)
  1714.                         params.m_sParamStruct.factionID = species;
  1715.         }
  1716.  
  1717.         pTableInstance->GetValue("bAutoDisable", autoDisable);
  1718.         // (MATT) Make really sure we never use autodisable for G04 - but actually I think autodisable param will be respected now {2008/11/26}
  1719.         if (gAIEnv.configuration.eCompatibilityMode == ECCM_GAME04 ||
  1720.             gAIEnv.configuration.eCompatibilityMode == ECCM_WARFACE ||
  1721.             gAIEnv.configuration.eCompatibilityMode == ECCM_CRYSIS2)
  1722.                 autoDisable = false;
  1723.  
  1724.         SmartScriptTable TnW;
  1725.         if (pTableInstance->GetValue("AITerritoryAndWave", TnW))
  1726.         {
  1727.                 // Look up territories
  1728.                 char* sTemp = NULL;
  1729.                 TnW->GetValue("aiterritory_Territory", sTemp);
  1730.                 if (sTemp) params.m_sParamStruct.m_sTerritoryName = sTemp;
  1731.  
  1732.                 // Look up waves
  1733.                 TnW->GetValue("aiwave_Wave", sTemp);
  1734.                 if (sTemp) params.m_sParamStruct.m_sWaveName = sTemp;
  1735.         }
  1736.  
  1737.         params.m_sParamStruct.m_bAiIgnoreFgNode = false;
  1738.  
  1739.         float maneuverSpeed, walkSpeed, runSpeed, sprintSpeed;
  1740.  
  1741.         if (pMovementTable)
  1742.         {
  1743.                 pMovementTable->GetValue("b3DMove", params.m_moveAbility.b3DMove);
  1744.                 pMovementTable->GetValue("usePathfinder", params.m_moveAbility.bUsePathfinder);
  1745.                 pMovementTable->GetValue("usePredictiveFollowing", params.m_moveAbility.usePredictiveFollowing);
  1746.                 pMovementTable->GetValue("allowEntityClampingByAnimation", params.m_moveAbility.allowEntityClampingByAnimation);
  1747.                 pMovementTable->GetValue("walkSpeed", walkSpeed);
  1748.                 pMovementTable->GetValue("runSpeed", runSpeed);
  1749.                 pMovementTable->GetValue("sprintSpeed", sprintSpeed);
  1750.                 pMovementTable->GetValue("maxAccel", params.m_moveAbility.maxAccel);
  1751.                 pMovementTable->GetValue("maxDecel", params.m_moveAbility.maxDecel);
  1752.                 pMovementTable->GetValue("maneuverSpeed", maneuverSpeed);
  1753.                 pMovementTable->GetValue("minTurnRadius", params.m_moveAbility.minTurnRadius);
  1754.                 pMovementTable->GetValue("maxTurnRadius", params.m_moveAbility.maxTurnRadius);
  1755.                 pMovementTable->GetValue("pathLookAhead", params.m_moveAbility.pathLookAhead);
  1756.                 pMovementTable->GetValue("pathRadius", params.m_moveAbility.pathRadius);
  1757.                 pMovementTable->GetValue("pathSpeedLookAheadPerSpeed", params.m_moveAbility.pathSpeedLookAheadPerSpeed);
  1758.                 pMovementTable->GetValue("cornerSlowDown", params.m_moveAbility.cornerSlowDown);
  1759.                 pMovementTable->GetValue("slopeSlowDown", params.m_moveAbility.slopeSlowDown);
  1760.                 pMovementTable->GetValue("maneuverTrh", params.m_moveAbility.maneuverTrh);
  1761.                 pMovementTable->GetValue("velDecay", params.m_moveAbility.velDecay);
  1762.                 // for flying.
  1763.                 pMovementTable->GetValue("optimalFlightHeight", params.m_moveAbility.optimalFlightHeight);
  1764.                 pMovementTable->GetValue("minFlightHeight", params.m_moveAbility.minFlightHeight);
  1765.                 pMovementTable->GetValue("maxFlightHeight", params.m_moveAbility.maxFlightHeight);
  1766.  
  1767.                 pMovementTable->GetValue("passRadius", params.m_sParamStruct.m_fPassRadius);
  1768.                 pMovementTable->GetValue("attackZoneHeight", params.m_sParamStruct.m_fAttackZoneHeight);
  1769.  
  1770.                 pMovementTable->GetValue("pathFindPrediction", params.m_moveAbility.pathFindPrediction);
  1771.  
  1772.                 pMovementTable->GetValue("lookIdleTurnSpeed", params.m_sParamStruct.m_lookIdleTurnSpeed);
  1773.                 pMovementTable->GetValue("lookCombatTurnSpeed", params.m_sParamStruct.m_lookCombatTurnSpeed);
  1774.                 pMovementTable->GetValue("aimTurnSpeed", params.m_sParamStruct.m_aimTurnSpeed);
  1775.                 pMovementTable->GetValue("fireTurnSpeed", params.m_sParamStruct.m_fireTurnSpeed);
  1776.                 params.m_sParamStruct.m_lookIdleTurnSpeed = DEG2RAD(params.m_sParamStruct.m_lookIdleTurnSpeed);
  1777.                 params.m_sParamStruct.m_lookCombatTurnSpeed = DEG2RAD(params.m_sParamStruct.m_lookCombatTurnSpeed);
  1778.                 params.m_sParamStruct.m_aimTurnSpeed = DEG2RAD(params.m_sParamStruct.m_aimTurnSpeed);
  1779.                 params.m_sParamStruct.m_fireTurnSpeed = DEG2RAD(params.m_sParamStruct.m_fireTurnSpeed);
  1780.  
  1781.                 pMovementTable->GetValue("resolveStickingInTrace", params.m_moveAbility.resolveStickingInTrace);
  1782.                 pMovementTable->GetValue("pathRegenIntervalDuringTrace", params.m_moveAbility.pathRegenIntervalDuringTrace);
  1783.                 pMovementTable->GetValue("avoidanceRadius", params.m_moveAbility.avoidanceRadius);
  1784.                 pMovementTable->GetValue("lightAffectsSpeed", params.m_moveAbility.lightAffectsSpeed);
  1785.  
  1786.                 pMovementTable->GetValue("directionalScaleRefSpeedMin", params.m_moveAbility.directionalScaleRefSpeedMin);
  1787.                 pMovementTable->GetValue("directionalScaleRefSpeedMax", params.m_moveAbility.directionalScaleRefSpeedMax);
  1788.  
  1789.                 pMovementTable->GetValue("avoidanceAbilities", params.m_moveAbility.avoidanceAbilities);
  1790.                 pMovementTable->GetValue("pushableObstacleWeakAvoidance", params.m_moveAbility.pushableObstacleWeakAvoidance);
  1791.                 pMovementTable->GetValue("pushableObstacleAvoidanceRadius", params.m_moveAbility.pushableObstacleAvoidanceRadius);
  1792.  
  1793.                 pMovementTable->GetValue("pushableObstacleMassMin", params.m_moveAbility.pushableObstacleMassMin);
  1794.                 pMovementTable->GetValue("pushableObstacleMassMax", params.m_moveAbility.pushableObstacleMassMax);
  1795.  
  1796.                 pMovementTable->GetValue("collisionAvoidanceParticipation", params.m_moveAbility.collisionAvoidanceParticipation);
  1797.                 pMovementTable->GetValue("collisionAvoidanceRadiusIncrement", params.m_moveAbility.collisionAvoidanceRadiusIncrement);
  1798.  
  1799.                 pMovementTable->GetValue("distanceToCover", params.m_sParamStruct.distanceToCover);
  1800.                 pMovementTable->GetValue("inCoverRadius", params.m_sParamStruct.inCoverRadius);
  1801.                 pMovementTable->GetValue("effectiveCoverHeight", params.m_sParamStruct.effectiveCoverHeight);
  1802.                 pMovementTable->GetValue("effectiveHighCoverHeight", params.m_sParamStruct.effectiveHighCoverHeight);
  1803.  
  1804.                 const char* pathTypeStr;
  1805.                 if (pMovementTable->GetValue("pathType", pathTypeStr))
  1806.                 {
  1807.                         SetPFProperties(params.m_moveAbility, pathTypeStr);
  1808.                 }
  1809.                 else
  1810.                 {
  1811.                         int pathType(AIPATH_DEFAULT);
  1812.                         pMovementTable->GetValue("pathType", pathType);
  1813.                         SetPFProperties(params.m_moveAbility, static_cast<EAIPathType>(pathType));
  1814.                 }
  1815.  
  1816.                 params.m_moveAbility.movementSpeeds.SetBasicSpeeds(0.5f * walkSpeed, walkSpeed, runSpeed, sprintSpeed, maneuverSpeed);
  1817.  
  1818.                 const char* tableName = 0;
  1819.                 SmartScriptTable pSpeedTable;
  1820.                 if (pMovementTable->GetValue("AIMovementSpeeds", pSpeedTable))
  1821.                 {
  1822.                         SmartScriptTable pStanceSpeedTable;
  1823.                         for (int s = 0; s < AgentMovementSpeeds::AMS_NUM_VALUES; ++s)
  1824.                         {
  1825.                                 switch (s)
  1826.                                 {
  1827.                                 case AgentMovementSpeeds::AMS_RELAXED:
  1828.                                         tableName = "Relaxed";
  1829.                                         break;
  1830.                                 case AgentMovementSpeeds::AMS_COMBAT:
  1831.                                         tableName = "Combat";
  1832.                                         break;
  1833.                                 case AgentMovementSpeeds::AMS_STEALTH:
  1834.                                         tableName = "Stealth";
  1835.                                         break;
  1836.                                 case AgentMovementSpeeds::AMS_ALERTED:
  1837.                                         tableName = "Alerted";
  1838.                                         break;
  1839.                                 case AgentMovementSpeeds::AMS_CROUCH:
  1840.                                         tableName = "Crouch";
  1841.                                         break;
  1842.                                 case AgentMovementSpeeds::AMS_LOW_COVER:
  1843.                                         tableName = "LowCover";
  1844.                                         break;
  1845.                                 case AgentMovementSpeeds::AMS_HIGH_COVER:
  1846.                                         tableName = "HighCover";
  1847.                                         break;
  1848.                                 case AgentMovementSpeeds::AMS_PRONE:
  1849.                                         tableName = "Prone";
  1850.                                         break;
  1851.                                 case AgentMovementSpeeds::AMS_SWIM:
  1852.                                         tableName = "Swim";
  1853.                                         break;
  1854.                                 default:
  1855.                                         tableName = "invalid";
  1856.                                         break;
  1857.                                 }
  1858.                                 if (pSpeedTable->GetValue(tableName, pStanceSpeedTable))
  1859.                                 {
  1860.                                         for (int u = 0; u < AgentMovementSpeeds::AMU_NUM_VALUES /*-1*/; ++u)
  1861.                                         {
  1862.                                                 switch (u)
  1863.                                                 {
  1864.                                                 case AgentMovementSpeeds::AMU_SLOW:
  1865.                                                         tableName = "Slow";
  1866.                                                         break;
  1867.                                                 case AgentMovementSpeeds::AMU_WALK:
  1868.                                                         tableName = "Walk";
  1869.                                                         break;
  1870.                                                 case AgentMovementSpeeds::AMU_RUN:
  1871.                                                         tableName = "Run";
  1872.                                                         break;
  1873.                                                 case AgentMovementSpeeds::AMU_SPRINT:
  1874.                                                         tableName = "Sprint";
  1875.                                                         break;
  1876.                                                 default:
  1877.                                                         tableName = "invalid";
  1878.                                                         break;
  1879.                                                 }
  1880.                                                 SmartScriptTable pUrgencySpeedTable;
  1881.                                                 if (pStanceSpeedTable->GetValue(tableName, pUrgencySpeedTable))
  1882.                                                 {
  1883.                                                         float sdef = 0, smin = 0, smax = 0;
  1884.                                                         pUrgencySpeedTable->GetAt(1, sdef);
  1885.                                                         pUrgencySpeedTable->GetAt(2, smin);
  1886.                                                         pUrgencySpeedTable->GetAt(3, smax);
  1887.  
  1888.                                                         params.m_moveAbility.movementSpeeds.SetRanges(s, u, sdef, smin, smax);
  1889.                                                 }
  1890.                                                 else
  1891.                                                 {
  1892.                                                         if (u > 0)
  1893.                                                                 params.m_moveAbility.movementSpeeds.CopyRanges(s, u, u - 1);
  1894.                                                         //                                                      params.m_moveAbility.movementSpeeds.SetRanges(s, u, -1, -1,-1, -1,-1, -1,-1);
  1895.                                                 }
  1896.                                         }
  1897.                                 }
  1898.                                 /*                              else
  1899.                                         {
  1900.                                           AIWarningID("<CScriptBind_AI> ", "ParseTables: Unable to get element %s from AIMovementSpeeds table", tableName);
  1901.                                         }
  1902.                                  */}
  1903.  
  1904.                 }
  1905.         }
  1906.  
  1907.         // RateOfDeath table
  1908.         SmartScriptTable pRateOfDeath;
  1909.         if (pTable->GetValue("RateOfDeath", pRateOfDeath))
  1910.         {
  1911.                 if (!pRateOfDeath->GetValue("attackrange", params.m_sParamStruct.m_fAttackRange))
  1912.                         pTableInstance->GetValue("attackrange", params.m_sParamStruct.m_fAttackRange);
  1913.                 if (!pRateOfDeath->GetValue("accuracy", params.m_sParamStruct.m_fAccuracy))
  1914.                         pTableInstance->GetValue("accuracy", params.m_sParamStruct.m_fAccuracy);
  1915.                 pRateOfDeath->GetValue("reactionTime", params.m_sParamStruct.m_PerceptionParams.reactionTime);
  1916.         }
  1917.  
  1918.         // perception table
  1919.         SmartScriptTable pPerceptionTable;
  1920.         if (pTable->GetValue("Perception", pPerceptionTable))
  1921.         {
  1922.                 pPerceptionTable->GetValue("FOVSecondary", params.m_sParamStruct.m_PerceptionParams.FOVSecondary);
  1923.                 pPerceptionTable->GetValue("FOVPrimary", params.m_sParamStruct.m_PerceptionParams.FOVPrimary);
  1924.                 pPerceptionTable->GetValue("stanceScale", params.m_sParamStruct.m_PerceptionParams.stanceScale);
  1925.                 pPerceptionTable->GetValue("sightrange", params.m_sParamStruct.m_PerceptionParams.sightRange);
  1926.                 pPerceptionTable->GetValue("sightnearrange", params.m_sParamStruct.m_PerceptionParams.sightNearRange);
  1927.                 pPerceptionTable->GetValue("sightrangeVehicle", params.m_sParamStruct.m_PerceptionParams.sightRangeVehicle);
  1928.                 pPerceptionTable->GetValue("sightdelay", params.m_sParamStruct.m_PerceptionParams.sightDelay);
  1929.                 pPerceptionTable->GetValue("audioScale", params.m_sParamStruct.m_PerceptionParams.audioScale);
  1930.                 pPerceptionTable->GetValue("persistence", params.m_sParamStruct.m_PerceptionParams.targetPersistence);
  1931.                 pPerceptionTable->GetValue("bulletHitRadius", params.m_sParamStruct.m_PerceptionParams.bulletHitRadius);
  1932.                 pPerceptionTable->GetValue("bIsAffectedByLight", params.m_sParamStruct.m_PerceptionParams.isAffectedByLight);
  1933.                 pPerceptionTable->GetValue("minAlarmLevel", params.m_sParamStruct.m_PerceptionParams.minAlarmLevel);
  1934.                 pPerceptionTable->GetValue("minDistanceToSpotDeadBodies", params.m_sParamStruct.m_PerceptionParams.minDistanceToSpotDeadBodies);
  1935.                 pPerceptionTable->GetValue("cloakMaxDistCrouchedAndMoving", params.m_sParamStruct.m_PerceptionParams.cloakMaxDistCrouchedAndMoving);
  1936.                 pPerceptionTable->GetValue("cloakMaxDistCrouchedAndStill", params.m_sParamStruct.m_PerceptionParams.cloakMaxDistCrouchedAndStill);
  1937.                 pPerceptionTable->GetValue("cloakMaxDistMoving", params.m_sParamStruct.m_PerceptionParams.cloakMaxDistMoving);
  1938.                 pPerceptionTable->GetValue("cloakMaxDistStill", params.m_sParamStruct.m_PerceptionParams.cloakMaxDistStill);
  1939.                 Limit(params.m_sParamStruct.m_PerceptionParams.minAlarmLevel, 0.0f, 1.0f);
  1940.                 pTable->GetValue("stuntReactionTimeOut", params.m_sParamStruct.m_PerceptionParams.stuntReactionTimeOut);
  1941.                 pTable->GetValue("collisionReactionScale", params.m_sParamStruct.m_PerceptionParams.collisionReactionScale);
  1942.         }
  1943.  
  1944.         if ((pH->GetParamCount() > firstTable + 2) && (pH->GetParamType(firstTable + 3) == svtObject))
  1945.         {
  1946.                 if (pH->GetParam(firstTable + 3, pMeleeTable))
  1947.                 {
  1948.                         float meleeAngleThreshold = 20.0f;
  1949.  
  1950.                         pMeleeTable->GetValue("damageRadius", agentParams.m_fMeleeRange);
  1951.                         pMeleeTable->GetValue("damageRadiusShort", agentParams.m_fMeleeRangeShort);
  1952.                         pMeleeTable->GetValue("hitRange", agentParams.m_fMeleeHitRange);
  1953.                         pMeleeTable->GetValue("angleThreshold", meleeAngleThreshold);
  1954.                         pMeleeTable->GetValue("damage", agentParams.m_fMeleeDamage);
  1955.                         pMeleeTable->GetValue("knockdownChance", agentParams.m_fMeleeKnowckdownChance);
  1956.                         pMeleeTable->GetValue("impulse", agentParams.m_fMeleeImpulse);
  1957.  
  1958.                         agentParams.m_fMeleeAngleCosineThreshold = cosf(DEG2RAD(meleeAngleThreshold));
  1959.                 }
  1960.         }
  1961.  
  1962.         return true;
  1963. }
  1964.  
  1965. //
  1966. //-----------------------------------------------------------------------------------------------------------
  1967. void CScriptBind_AI::AssignPFPropertiesToPathType(const string& sPathType, AgentPathfindingProperties& properties)
  1968. {
  1969.         GetAISystem()->AssignPFPropertiesToPathType(sPathType, properties);
  1970. }
  1971.  
  1972. //
  1973. //-----------------------------------------------------------------------------------------------------------
  1974. void CScriptBind_AI::SetPFProperties(AgentMovementAbility& moveAbility, EAIPathType nPathType) const
  1975. {
  1976.         SetPFProperties(moveAbility, GetPathTypeName(nPathType));
  1977. }
  1978.  
  1979. //
  1980. //-----------------------------------------------------------------------------------------------------------
  1981. void CScriptBind_AI::SetPFProperties(AgentMovementAbility& moveAbility, const string& sPathType) const
  1982. {
  1983.         const AgentPathfindingProperties* pAgentPathfindingProperties = GetAISystem()->GetPFPropertiesOfPathType(sPathType);
  1984.  
  1985.         if (pAgentPathfindingProperties)
  1986.         {
  1987.                 moveAbility.pathfindingProperties = *pAgentPathfindingProperties;
  1988.         }
  1989.         else
  1990.         {
  1991.                 AIWarningID("<CScriptBind_AI> ", "SetPFProperties: Path type %s not handled - using default", sPathType.c_str());
  1992.  
  1993.                 pAgentPathfindingProperties = GetAISystem()->GetPFPropertiesOfPathType("AIPATH_DEFAULT");
  1994.                 if (pAgentPathfindingProperties)
  1995.                 {
  1996.                         moveAbility.pathfindingProperties = *pAgentPathfindingProperties;
  1997.                 }
  1998.                 else
  1999.                 {
  2000.                         /// character that travels on the surface but has no preferences - except it prefers to walk around
  2001.                         /// hills rather than over them
  2002.                         AgentPathfindingProperties hardcodedDefaultCharacterProperties(
  2003.                           IAISystem::NAV_TRIANGULAR | IAISystem::NAV_WAYPOINT_HUMAN | IAISystem::NAV_SMARTOBJECT,
  2004.                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
  2005.                           5.0f, 0.5f, -10000.0f, 0.0f, 20.0f, 7.0f);
  2006.  
  2007.                         moveAbility.pathfindingProperties = hardcodedDefaultCharacterProperties;
  2008.                 }
  2009.         }
  2010. }
  2011.  
  2012. //
  2013. //-----------------------------------------------------------------------------------------------------------
  2014. int CScriptBind_AI::ResetParameters(IFunctionHandler* pH)
  2015. {
  2016.         // Mrcio: Enabling AI in Multiplayer!
  2017.         if (gEnv->bMultiplayer && !gEnv->bServer)
  2018.                 return pH->EndFunction();
  2019.  
  2020.         GET_ENTITY(1);
  2021.  
  2022.         if (!pEntity)
  2023.         {
  2024.                 AIWarningID("<CScriptBind_AI> ", "Tried to reset parameters with nonExisting entity with id [%d]. ", nID);
  2025.                 return pH->EndFunction();
  2026.         }
  2027.  
  2028.         CAIActor* pActor = CastToCAIActorSafe(pEntity->GetAI());
  2029.         if (!pActor)
  2030.         {
  2031.                 AIWarningID("<CScriptBind_AI> ", "Tried to set parameters with entity without AI actor [%s]. ", pEntity->GetName());
  2032.                 return pH->EndFunction();
  2033.         }
  2034.  
  2035.         AIObjectParams params(AIOBJECT_NONE, pActor->GetParameters(), pActor->GetMovementAbility());
  2036.         bool autoDisable(true);
  2037.  
  2038.         bool bProcessMovement = false;
  2039.         if (pH->GetParamType(2) == svtBool)
  2040.                 pH->GetParam(2, bProcessMovement);
  2041.  
  2042.         if (!ParseTables(3, bProcessMovement, pH, params, autoDisable))
  2043.         {
  2044.                 AIWarningID("<CScriptBind_AI> ", "Failed resetting parameters for AI actor [%s]. (ProcessMovement = %d)", pEntity->GetName(), bProcessMovement ? 1 : 0);
  2045.                 return pH->EndFunction();
  2046.         }
  2047.  
  2048.         pActor->ParseParameters(params, bProcessMovement);
  2049.  
  2050.         // (MATT) Respect autodisable settings on Reset {2008/11/26}
  2051.         IAIObject* pAI = pEntity->GetAI();
  2052.         IAIActorProxy* pPuppetProxy = pAI->GetProxy();
  2053.         if (pPuppetProxy)
  2054.         {
  2055.                 pPuppetProxy->UpdateMeAlways(!autoDisable);
  2056.         }
  2057.  
  2058.         CCCPOINT(CScriptbind_AI_ResetParameters);
  2059.         return pH->EndFunction();
  2060. }
  2061.  
  2062. /*!Create a sequence of AI atomic commands (a goal pipe)
  2063.    @param desired name of the goal pipe
  2064.  */
  2065. //
  2066. //-----------------------------------------------------------------------------------------------------------
  2067.  
  2068. int CScriptBind_AI::CreateGoalPipe(IFunctionHandler* pH)
  2069. {
  2070.         //      CHECK_PARAMETERS(1);
  2071.  
  2072.         const char* name;
  2073.  
  2074.         if (!pH->GetParams(name))
  2075.                 return pH->EndFunction();
  2076.  
  2077.         /*IGoalPipe *pPipe =*/ gAIEnv.pPipeManager->CreateGoalPipe(name, CPipeManager::SilentlyReplaceDuplicate);
  2078.  
  2079.         //      m_mapGoals.insert(goalmap::iterator::value_type(name,pPipe));
  2080.         m_IsGroupOpen = false;
  2081.  
  2082.         return pH->EndFunction();
  2083. }
  2084.  
  2085. //
  2086. //-----------------------------------------------------------------------------------------------------------
  2087. int CScriptBind_AI::BeginGoalPipe(IFunctionHandler* pH)
  2088. {
  2089.         if (m_pCurrentGoalPipe)
  2090.         {
  2091.                 AIWarningID("<CScriptBind_AI> ", "Calling AI.BeginGoalPipe() with active goalpipe '%s', must call AI.EndGoalPipe() to end goalpipe.", m_pCurrentGoalPipe->GetName());
  2092.                 m_pCurrentGoalPipe = 0;
  2093.         }
  2094.  
  2095.         const char* name;
  2096.         if (!pH->GetParams(name))
  2097.                 return pH->EndFunction();
  2098.  
  2099.         m_IsGroupOpen = false;
  2100.         m_pCurrentGoalPipe = gAIEnv.pPipeManager->CreateGoalPipe(name, CPipeManager::SilentlyReplaceDuplicate);
  2101.         if (!m_pCurrentGoalPipe)
  2102.                 AIWarningID("<CScriptBind_AI> ", "AI.BeginGoalPipe: Goalpipe %s was not created.", name);
  2103.  
  2104.         return pH->EndFunction();
  2105. }
  2106.  
  2107. //
  2108. //-----------------------------------------------------------------------------------------------------------
  2109. int CScriptBind_AI::EndGoalPipe(IFunctionHandler* pH)
  2110. {
  2111.         if (!m_pCurrentGoalPipe)
  2112.                 AIWarningID("<CScriptBind_AI> ", "Calling AI.EndGoalPipe() without AI.BeginGoalPipe() (current pipe is null).");
  2113.         m_pCurrentGoalPipe = 0;
  2114.         return pH->EndFunction();
  2115. }
  2116.  
  2117. //
  2118. //-----------------------------------------------------------------------------------------------------------
  2119. int CScriptBind_AI::BeginGroup(IFunctionHandler* pH)
  2120. {
  2121.         if (m_IsGroupOpen)
  2122.                 AIWarningID("<CScriptBind_AI> ", "Calling AI.BeginGroup() twice (no nesed grouping supported).");
  2123.         m_IsGroupOpen = true;
  2124.         return pH->EndFunction();
  2125. }
  2126.  
  2127. //
  2128. //-----------------------------------------------------------------------------------------------------------
  2129. int CScriptBind_AI::EndGroup(IFunctionHandler* pH)
  2130. {
  2131.         if (!m_IsGroupOpen)
  2132.                 AIWarningID("<CScriptBind_AI> ", "Calling AI.EndGroup() without AI.BeginGroup().");
  2133.         m_IsGroupOpen = false;
  2134.         return pH->EndFunction();
  2135. }
  2136.  
  2137. /*!Push a label into a goal pipe. The label is appended at the end of the goal pipe. Pipe of given name has to be previously created.
  2138.    @param name of the goal pipe in which the goal will be pushed.
  2139.    @param name of the label that needs to be pushed into the pipe
  2140.    @see CScriptBind_AI::CreateGoalPipe
  2141.  */
  2142. //
  2143. //-----------------------------------------------------------------------------------------------------------
  2144. int CScriptBind_AI::PushLabel(IFunctionHandler* pH)
  2145. {
  2146.         const char* pipename;
  2147.         const char* labelname;
  2148.         stack_string goalname;
  2149.  
  2150.         if (m_pCurrentGoalPipe)
  2151.         {
  2152.                 // Begin/EndGoalpipe
  2153.                 if (!pH->GetParams(labelname))
  2154.                         return pH->EndFunction();
  2155.                 m_pCurrentGoalPipe->PushLabel(labelname);
  2156.         }
  2157.         else
  2158.         {
  2159.                 // CreateGoalPipe
  2160.                 GoalParameters params;
  2161.                 if (!pH->GetParams(pipename, labelname))
  2162.                         return pH->EndFunction();
  2163.  
  2164.                 IGoalPipe* pPipe = 0;
  2165.  
  2166.                 if (!(pPipe = gAIEnv.pPipeManager->OpenGoalPipe(pipename)))
  2167.                         return pH->EndFunction();
  2168.  
  2169.                 pPipe->PushLabel(labelname);
  2170.         }
  2171.  
  2172.         return pH->EndFunction();
  2173. }
  2174.  
  2175. /*!Push a goal into a goal pipe. The goal is appended at the end of the goal pipe. Pipe of given name has to be previously created.
  2176.    @param name of the goal pipe in which the goal will be pushed.
  2177.    @param name of atomic goal that needs to be pushed into the pipe
  2178.    @param 1 if the goal should block the pipe execution, 0 if the goal should not block the goal execution
  2179.    @see CScriptBind_AI::CreateGoalPipe
  2180.  */
  2181. //
  2182. //-----------------------------------------------------------------------------------------------------------
  2183. int CScriptBind_AI::PushGoal(IFunctionHandler* pH)
  2184. {
  2185.         // TODO : (MATT) For the love of whatever you hold sacred lets remove the dozens of redundant PushGoal lines after this integration {2007/06/08:16:33:14}
  2186.  
  2187.         const char* pipename;
  2188.         const char* temp;
  2189.         string goalname;
  2190.         //      int id;
  2191.         GoalParameters params;
  2192.         bool blocking(false);
  2193.         IGoalPipe::EGroupType grouped(IGoalPipe::eGT_NOGROUP);
  2194.         IGoalPipe* pPipe(0);
  2195.         int cnt(0);
  2196.  
  2197.         // (MATT) Below is required to support old syntax - which could be removed in an afternoon {2008/02/21}
  2198.         if (m_pCurrentGoalPipe)
  2199.         {
  2200.                 // Begin/EndGoalPipe
  2201.                 if (!pH->GetParam(1, temp))
  2202.                         temp = 0;
  2203.                 if (pH->GetParamCount() > 1)
  2204.                         pH->GetParam(2, blocking);
  2205.                 pPipe = m_pCurrentGoalPipe;
  2206.                 cnt = 2;
  2207.         }
  2208.         else
  2209.         {
  2210.                 // CreateGoalPipe
  2211.                 if (!pH->GetParam(1, pipename))
  2212.                         pipename = 0;
  2213.                 if (!pH->GetParam(2, temp))
  2214.                         temp = 0;
  2215.                 if (pH->GetParamCount() > 2)
  2216.                         pH->GetParam(3, blocking);
  2217.                 pPipe = gAIEnv.pPipeManager->OpenGoalPipe(pipename);
  2218.                 cnt = 3;
  2219.         }
  2220.  
  2221.         if (!pPipe)
  2222.                 return pH->EndFunction();
  2223.  
  2224.         if (m_IsGroupOpen)
  2225.                 grouped = IGoalPipe::eGT_GROUPED;
  2226.         if (temp && *temp == '+')
  2227.         {
  2228.                 ++temp;
  2229.                 grouped = IGoalPipe::eGT_GROUPWITHPREV;
  2230.         }
  2231.         goalname = temp;
  2232.  
  2233.         // Ask each registered goalop factory to create a goalop from this
  2234.         EGoalOperations op = CGoalPipe::GetGoalOpEnum(goalname.c_str());
  2235.         IGoalOp* pGoalOp = gAIEnv.pGoalOpFactory->GetGoalOp(goalname.c_str(), pH, cnt + 1, params);
  2236.         if (pGoalOp)
  2237.         {
  2238.                 pPipe->PushGoal(pGoalOp, op, blocking, grouped, params);
  2239.  
  2240.                 return pH->EndFunction();
  2241.         }
  2242.  
  2243.         switch (op)
  2244.         {
  2245.         case eGO_ACQUIRETARGET:
  2246.                 {
  2247.                         pH->GetParam(cnt + 1, temp);
  2248.                         params.str = temp;
  2249.                         pPipe->PushGoal(op, blocking, grouped, params);
  2250.                 }
  2251.                 break;
  2252.         case eGO_ADJUSTAIM:
  2253.                 {
  2254.                         params.nValue = 0;
  2255.                         int aimOrHide = 0;
  2256.                         int useLastOpResultAsBackup = 0;
  2257.                         int allowProne = 0;
  2258.                         params.fValue = 0.0f; // timeout
  2259.  
  2260.                         if (pH->GetParamCount() > cnt + 0)
  2261.                                 pH->GetParam(cnt + 1, aimOrHide); // aim = 0, hide = 1
  2262.                         if (pH->GetParamCount() > cnt + 1)
  2263.                                 pH->GetParam(cnt + 2, useLastOpResultAsBackup); // useLastOpResultAsBackup = 1
  2264.                         if (pH->GetParamCount() > cnt + 2)
  2265.                                 pH->GetParam(cnt + 3, allowProne);
  2266.                         if (pH->GetParamCount() > cnt + 3)
  2267.                                 pH->GetParam(cnt + 4, params.fValue); // timeout
  2268.  
  2269.                         if (aimOrHide) params.nValue |= 0x1;
  2270.                         if (useLastOpResultAsBackup) params.nValue |= 0x2;
  2271.                         if (allowProne) params.nValue |= 0x4;
  2272.  
  2273.                         pPipe->PushGoal(op, blocking, grouped, params);
  2274.                 }
  2275.                 break;
  2276.         case eGO_ANIMATION:
  2277.                 {
  2278.                         // signal/action flag
  2279.                         pH->GetParam(cnt + 1, params.nValue);
  2280.                         // Anim action to set.
  2281.                         pH->GetParam(cnt + 2, temp);
  2282.                         params.str = temp;
  2283.                         // Timeout
  2284.                         params.fValue = -1;
  2285.                         if (pH->GetParamCount() > cnt + 2)
  2286.                                 pH->GetParam(cnt + 3, params.fValue);
  2287.  
  2288.                         pPipe->PushGoal(op, blocking, grouped, params);
  2289.                 }
  2290.                 break;
  2291.         case eGO_ANIMTARGET:
  2292.                 {
  2293.                         // signal/action flag
  2294.                         pH->GetParam(cnt + 1, params.nValue);
  2295.                         // Anim action to set.
  2296.                         pH->GetParam(cnt + 2, temp);
  2297.                         params.str = temp;
  2298.                         // start width
  2299.                         pH->GetParam(cnt + 3, params.vPos.x);
  2300.                         // direction tolerance
  2301.                         pH->GetParam(cnt + 4, params.vPos.y);
  2302.                         // arc radius
  2303.                         pH->GetParam(cnt + 5, params.vPos.z);
  2304.                         // auto alignment
  2305.                         params.bValue = false;
  2306.  
  2307.                         if (pH->GetParamCount() >= cnt + 6)
  2308.                                 pH->GetParam(cnt + 6, params.bValue);
  2309.  
  2310.                         pPipe->PushGoal(op, blocking, grouped, params);
  2311.                 }
  2312.                 break;
  2313.         case eGO_PATHFIND:
  2314.                 {
  2315.                         if (pH->GetParamCount() > cnt)
  2316.                         {
  2317.                                 pH->GetParam(cnt + 1, temp);
  2318.                                 params.str = temp;
  2319.                                 params.pTarget = params.str.empty() ? 0 : gAIEnv.pAIObjectManager->GetAIObjectByName(0, temp);
  2320.                         }
  2321.                         pPipe->PushGoal(op, blocking, grouped, params);
  2322.                 }
  2323.                 break;
  2324.         case eGO_LOCATE:
  2325.                 {
  2326.                         if (pH->GetParamType(cnt + 1) == svtString)
  2327.                         {
  2328.                                 const char* temp2;
  2329.                                 pH->GetParam(cnt + 1, temp2);
  2330.                                 params.str = temp2;
  2331.                                 params.nValue = 0;
  2332.                         }
  2333.                         else if (pH->GetParamType(cnt + 1) == svtNumber)
  2334.                         {
  2335.                                 params.str.clear();
  2336.                                 pH->GetParam(cnt + 1, params.nValue);
  2337.                         }
  2338.  
  2339.                         if (pH->GetParamCount() > cnt + 1)
  2340.                                 pH->GetParam(cnt + 2, params.fValue);
  2341.                         else
  2342.                                 params.fValue = 0;
  2343.  
  2344.                         pPipe->PushGoal(op, blocking, grouped, params);
  2345.                 }
  2346.                 break;
  2347.         case eGO_HIDE:
  2348.                 {
  2349.                         // Distance
  2350.                         pH->GetParam(cnt + 1, params.fValue);
  2351.                         // Method
  2352.                         pH->GetParam(cnt + 2, params.nValue);
  2353.                         // Exact
  2354.                         if (pH->GetParamCount() > cnt + 2)
  2355.                                 pH->GetParam(cnt + 3, params.bValue);
  2356.                         else
  2357.                                 params.bValue = true;
  2358.                         // Min Distance
  2359.                         if (pH->GetParamCount() > cnt + 3)
  2360.                                 pH->GetParam(cnt + 4, params.fValueAux);
  2361.                         // Lastop result
  2362.                         if (pH->GetParamCount() > cnt + 4)
  2363.                                 pH->GetParam(cnt + 5, params.nValueAux);
  2364.  
  2365.                         pPipe->PushGoal(op, blocking, grouped, params);
  2366.                 }
  2367.                 break;
  2368.         case eGO_TACTICALPOS:
  2369.                 {
  2370.                         // Try to fetch the tactical query by name
  2371.                         params.nValue = 0;
  2372.                         const char* sQueryName = "null";
  2373.                         ITacticalPointSystem* pTPS = gAIEnv.pTacticalPointSystem;
  2374.                         if (pH->GetParamType(cnt + 1) == svtString)
  2375.                         {
  2376.                                 if (pH->GetParam(cnt + 1, sQueryName)) // Raises error on fail
  2377.                                 {
  2378.                                         params.nValue = pTPS->GetQueryID(sQueryName);
  2379.                                         if (!params.nValue)
  2380.                                         {
  2381.                                                 // Raise this as a script error so we get a stack trace
  2382.                                                 m_pSS->RaiseError("<CScriptBind_AI> "
  2383.                                                                   "PushGoal: tacticalpos query does not exist (yet) : %s", sQueryName);
  2384.                                         }
  2385.                                 }
  2386.                         }
  2387.                         else
  2388.                         {
  2389.                                 // Try to fetch by ID
  2390.                                 if (pH->GetParam(cnt + 1, params.nValue))
  2391.                                 {
  2392.                                         sQueryName = pTPS->GetQueryName(params.nValue);  // Raises error on fail
  2393.                                         if (!sQueryName)
  2394.                                         {
  2395.                                                 // Raise this as a script error so we get a stack trace
  2396.                                                 m_pSS->RaiseError("<CScriptBind_AI> "
  2397.                                                                   "PushGoal: tacticalpos query with id %d%s could not be found", params.nValue, (params.nValue ? "" : " (nil?)"));
  2398.                                         }
  2399.                                 }
  2400.                         }
  2401.  
  2402.                         if (params.nValue)
  2403.                         {
  2404.                                 // Which register to put it in instead? For now, just refpoint or lastop
  2405.                                 if (pH->GetParamCount() > cnt + 1)
  2406.                                         pH->GetParam(cnt + 2, params.nValueAux);
  2407.  
  2408.                                 pPipe->PushGoal(eGO_TACTICALPOS, blocking, grouped, params);
  2409.                         }
  2410.                 }
  2411.                 break;
  2412.         case eGO_LOOK:
  2413.                 {
  2414.                         // Look mode/style
  2415.                         pH->GetParam(cnt + 1, params.nValue);
  2416.                         // Allow body turn
  2417.                         pH->GetParam(cnt + 2, params.bValue);
  2418.                         // Which register to find the look target - for now just lastop and refpoint
  2419.                         if (pH->GetParamCount() > cnt + 1)
  2420.                                 pH->GetParam(cnt + 3, params.nValueAux);
  2421.  
  2422.                         pPipe->PushGoal(eGO_LOOK, blocking, grouped, params);
  2423.                 }
  2424.                 break;
  2425.         case eGO_TRACE:
  2426.                 {
  2427.                         params.fValue = 0;
  2428.                         params.nValue = 0;
  2429.                         params.fValueAux = 0;
  2430.                         params.nValueAux = 0;
  2431.                         if (pH->GetParamCount() > cnt)
  2432.                         {
  2433.                                 // Exact
  2434.                                 pH->GetParam(cnt + 1, params.nValue);
  2435.                                 // Single step
  2436.                                 if (pH->GetParamCount() > cnt + 1)
  2437.                                         pH->GetParam(cnt + 2, params.nValueAux);
  2438.                                 // Distance
  2439.                                 if (pH->GetParamCount() > cnt + 2)
  2440.                                         pH->GetParam(cnt + 3, params.fValue);
  2441.                         }
  2442.                         pPipe->PushGoal(op, blocking, grouped, params);
  2443.                 }
  2444.                 break;
  2445.         case eGO_LOOKAT:
  2446.                 {
  2447.                         pH->GetParam(cnt + 1, params.fValue);
  2448.                         if (pH->GetParamCount() > cnt + 1)
  2449.                                 pH->GetParam(cnt + 2, params.fValueAux);
  2450.                         if (pH->GetParamCount() > cnt + 2)
  2451.                                 pH->GetParam(cnt + 3, params.bValue);    //use LastOp
  2452.                         if (pH->GetParamCount() > cnt + 3)
  2453.                                 pH->GetParam(cnt + 4, params.nValue);
  2454.                         // Allow body turn
  2455.                         if (pH->GetParamCount() > cnt + 4)
  2456.                                 pH->GetParam(cnt + 5, params.nValueAux);
  2457.                         else
  2458.                                 params.nValueAux = 1;
  2459.  
  2460.                         pPipe->PushGoal(op, blocking, grouped, params);
  2461.                 }
  2462.                 break;
  2463.         case eGO_LOOKAROUND:
  2464.                 {
  2465.                         // float lookAtRange, float scanIntervalRange, float intervalMin, float intervalMax, flags
  2466.                         // Look at range
  2467.                         pH->GetParam(cnt + 1, params.fValue);
  2468.                         // Scan Interval
  2469.                         if (pH->GetParamCount() > cnt + 1)
  2470.                                 pH->GetParam(cnt + 2, params.fValueAux);
  2471.                         else
  2472.                                 params.fValueAux = -1;
  2473.                         // Timeout min
  2474.                         if (pH->GetParamCount() > cnt + 2)
  2475.                                 pH->GetParam(cnt + 3, params.vPos.x);
  2476.                         else
  2477.                                 params.vPos.x = -1;
  2478.                         // Timeout max
  2479.                         if (pH->GetParamCount() > cnt + 3)
  2480.                                 pH->GetParam(cnt + 4, params.vPos.y);
  2481.                         else
  2482.                                 params.vPos.y = -1;
  2483.                         // flags: break look when live target , use last op as reference direction
  2484.                         int flags = 0;
  2485.                         if (pH->GetParamCount() > cnt + 4)
  2486.                                 pH->GetParam(cnt + 5, flags);
  2487.                         params.nValue = flags;
  2488.                         // Allow body turn
  2489.                         if (pH->GetParamCount() > cnt + 5)
  2490.                                 pH->GetParam(cnt + 6, params.nValueAux);
  2491.                         else
  2492.                                 params.nValueAux = 1;
  2493.                         // Avoid looking at obstacles around the agent (uses ray casts...)
  2494.                         if (pH->GetParamCount() > cnt + 6)
  2495.                                 pH->GetParam(cnt + 7, params.bValue);
  2496.                         else
  2497.                                 params.bValue = false;
  2498.  
  2499.                         pPipe->PushGoal(op, blocking, grouped, params);
  2500.                 }
  2501.                 break;
  2502.         case eGO_DEVALUE:
  2503.                 {
  2504.                         if (pH->GetParamCount() > cnt)
  2505.                         {
  2506.                                 pH->GetParam(cnt + 1, params.fValue);
  2507.                                 if (pH->GetParamCount() > cnt + 1)
  2508.                                         pH->GetParam(cnt + 2, params.bValue);
  2509.                                 else
  2510.                                         params.bValue = false;
  2511.                         }
  2512.                         else
  2513.                                 params.fValue = false;
  2514.  
  2515.                         pPipe->PushGoal(op, blocking, grouped, params);
  2516.                 }
  2517.                 break;
  2518.         case eGO_SIGNAL:
  2519.                 {
  2520.                         params.nValueAux = 0;
  2521.                         pH->GetParam(cnt + 1, params.nValueAux); // get the signal id
  2522.                         params.nValue = 0;
  2523.  
  2524.                         if (pH->GetParamCount() > cnt + 1)
  2525.                         {
  2526.                                 const char* sTemp;
  2527.                                 if (pH->GetParam(cnt + 2, sTemp)) // get the signal text
  2528.                                         params.str = sTemp;
  2529.                         }
  2530.  
  2531.                         if (pH->GetParamCount() > cnt + 2)
  2532.                         {
  2533.                                 pH->GetParam(cnt + 3, params.nValue);  // get the desired filter
  2534.                         }
  2535.  
  2536.                         if (pH->GetParamCount() > cnt + 3)
  2537.                         {
  2538.                                 pH->GetParam(cnt + 4, params.fValueAux);  // extra signal data passed as data.iValue.
  2539.                         }
  2540.  
  2541.                         pPipe->PushGoal(op, blocking, grouped, params);
  2542.                 }
  2543.                 break;
  2544.         case eGO_SCRIPT:
  2545.                 {
  2546.                         string scriptCode;
  2547.                         ScriptVarType functionType = pH->GetParamType(cnt + 1);
  2548.  
  2549.                         if (functionType == svtString)
  2550.                         {
  2551.                                 const char* funcBody = 0;
  2552.  
  2553.                                 pH->GetParam(cnt + 1, funcBody);
  2554.                                 if (funcBody)
  2555.                                         scriptCode = funcBody;
  2556.                         }
  2557.                         else
  2558.                         {
  2559.                                 assert(!"Invalid GoalOp Parameter!");
  2560.                         }
  2561.  
  2562.                         params.scriptCode = scriptCode;
  2563.  
  2564.                         pPipe->PushGoal(op, blocking, grouped, params);
  2565.                 }
  2566.                 break;
  2567.         case eGO_APPROACH:
  2568.                 {
  2569.                         // Approach distance
  2570.                         pH->GetParam(cnt + 1, params.fValue);
  2571.  
  2572.                         // Lastop result usage flags, see EAILastOpResFlags.
  2573.                         params.nValue = 0;
  2574.                         if (pH->GetParamCount() > cnt + 1)
  2575.                                 pH->GetParam(cnt + 2, params.nValue);
  2576.                         // get the accuracy.
  2577.                         params.fValueAux = 1.f;
  2578.                         if (pH->GetParamCount() > cnt + 2)
  2579.                                 pH->GetParam(cnt + 3, params.fValueAux);
  2580.                         // Special signal to send when pathfinding fails.
  2581.                         if (pH->GetParamCount() > cnt + 3)
  2582.                         {
  2583.                                 const char* sTemp = "";
  2584.                                 if (pH->GetParam(cnt + 4, sTemp))
  2585.                                 {
  2586.                                         if (strlen(sTemp) > 1)
  2587.                                                 params.str = sTemp;
  2588.                                 }
  2589.                         }
  2590.                         // Approach distance Variance
  2591.                         params.vPos.x = 0.0f;
  2592.                         if (pH->GetParamCount() > cnt + 4)
  2593.                                 pH->GetParam(cnt + 5, params.vPos.x);
  2594.  
  2595.                         pPipe->PushGoal(op, blocking, grouped, params);
  2596.                 }
  2597.                 break;
  2598.         case eGO_BACKOFF:
  2599.                 {
  2600.                         pH->GetParam(cnt + 1, params.fValue); // distance
  2601.                         if (pH->GetParamCount() > cnt + 1)
  2602.                                 pH->GetParam(cnt + 2, params.fValueAux);//max duration
  2603.                         if (pH->GetParamCount() > cnt + 2)
  2604.                                 pH->GetParam(cnt + 3, params.nValue);//filter (use/look last op, direction)
  2605.                         if (pH->GetParamCount() > cnt + 3)
  2606.                                 pH->GetParam(cnt + 4, params.nValueAux); //min distance
  2607.  
  2608.                         pPipe->PushGoal(op, blocking, grouped, params);
  2609.                 }
  2610.                 break;
  2611.         case eGO_STANCE:
  2612.         case eGO_BODYPOS:
  2613.                 {
  2614.                         pH->GetParam(cnt + 1, params.nValue);
  2615.                         if (pH->GetParamCount() > cnt + 1)
  2616.                                 pH->GetParam(cnt + 2, params.bValue);
  2617.                         else
  2618.                                 params.bValue = false;
  2619.                         pPipe->PushGoal(op, blocking, grouped, params);
  2620.                 }
  2621.                 break;
  2622.         case eGO_TIMEOUT:
  2623.                 {
  2624.                         pH->GetParam(cnt + 1, params.fValue);
  2625.                         if (pH->GetParamCount() > cnt + 1)
  2626.                                 pH->GetParam(cnt + 2, params.fValueAux);
  2627.                         else
  2628.                                 params.fValueAux = 0;
  2629.                         pPipe->PushGoal(op, blocking, grouped, params);
  2630.                 }
  2631.                 break;
  2632.         case eGO_BRANCH:
  2633.                 {
  2634.                         // Label or Branch offset.
  2635.                         if (pH->GetParamType(cnt + 1) == svtString)
  2636.                         {
  2637.                                 // Label
  2638.                                 pH->GetParam(cnt + 1, temp);
  2639.                                 params.str = temp;
  2640.                         }
  2641.                         else
  2642.                         {
  2643.                                 // Jump offset
  2644.                                 pH->GetParam(cnt + 1, params.nValueAux);
  2645.                         }
  2646.  
  2647.                         if (pH->GetParamCount() > cnt + 1)
  2648.                         {
  2649.                                 // Branch type (see EOPBranchType).
  2650.                                 pH->GetParam(cnt + 2, params.nValue);
  2651.  
  2652.                                 // Parameters.
  2653.                                 if (pH->GetParamCount() > cnt + 2)
  2654.                                         pH->GetParam(cnt + 3, params.fValue);
  2655.                                 if (pH->GetParamCount() > cnt + 3)
  2656.                                         pH->GetParam(cnt + 4, params.fValueAux);
  2657.                                 else
  2658.                                         params.fValueAux = -1.0f;
  2659.                         }
  2660.                         else
  2661.                                 params.nValue = 0;
  2662.  
  2663.                         pPipe->PushGoal(op, blocking, grouped, params);
  2664.                 }
  2665.                 break;
  2666.         case eGO_RANDOM:
  2667.                 {
  2668.                         pH->GetParam(cnt + 1, params.nValue);
  2669.                         pH->GetParam(cnt + 2, params.fValue);
  2670.                         pPipe->PushGoal(op, blocking, grouped, params);
  2671.                 }
  2672.                 break;
  2673.         case eGO_CLEAR:
  2674.                 {
  2675.                         if (pH->GetParamCount() > cnt)
  2676.                                 pH->GetParam(cnt + 1, params.fValue);
  2677.                         else
  2678.                                 params.fValue = 1.0f;
  2679.                         pPipe->PushGoal(op, blocking, grouped, params);
  2680.                 }
  2681.                 break;
  2682.         case eGO_FIRECMD:
  2683.                 {
  2684.                         // Fire mode, see EFireMode (IAgent.h ) for complete list of modes.
  2685.                         if (pH->GetParamCount() > cnt)
  2686.                                 pH->GetParam(cnt + 1, params.nValue);
  2687.                         // Use last op result.
  2688.                         int useLastOpResult = 0;
  2689.                         params.bValue = false;
  2690.                         if (pH->GetParamCount() > cnt + 1)
  2691.                         {
  2692.                                 pH->GetParam(cnt + 2, useLastOpResult);
  2693.                                 if (useLastOpResult & 1)
  2694.                                         params.bValue = true;
  2695.                         }
  2696.                         // Min timeout
  2697.                         params.fValue = -1.f;
  2698.                         if (pH->GetParamCount() > cnt + 2)
  2699.                                 pH->GetParam(cnt + 3, params.fValue);
  2700.                         // Max timeout
  2701.                         params.fValueAux = -1.f;
  2702.                         if (pH->GetParamCount() > cnt + 3)
  2703.                                 pH->GetParam(cnt + 4, params.fValueAux);
  2704.  
  2705.                         pPipe->PushGoal(op, blocking, grouped, params);
  2706.                 }
  2707.                 break;
  2708.         case eGO_STICKMINIMUMDISTANCE:
  2709.         case eGO_STICK:
  2710.                 {
  2711.                         // Stick distance
  2712.                         pH->GetParam(cnt + 1, params.fValue);
  2713.  
  2714.                         // Lastop result usage flags, see EAILastOpResFlags.
  2715.                         params.nValue = 0;
  2716.                         if (pH->GetParamCount() > cnt + 1)
  2717.                                 pH->GetParam(cnt + 2, params.nValue);
  2718.  
  2719.                         // Stick flags, see EStickFlags.
  2720.                         // When creating the goal pipe this flag actually indicates "break when approached the target".
  2721.                         params.nValueAux = 0;
  2722.                         if (pH->GetParamCount() > cnt + 2)
  2723.                                 pH->GetParam(cnt + 3, params.nValueAux);
  2724.  
  2725.                         // Pathfinding accuracy
  2726.                         params.fValueAux = params.fValue;
  2727.                         if (pH->GetParamCount() > cnt + 3)
  2728.                                 pH->GetParam(cnt + 4, params.fValueAux);
  2729.  
  2730.                         // End distance variance, the variance distance is substraceted from the end distance.
  2731.                         params.vPos.x = 0.0f;
  2732.                         if (pH->GetParamCount() > cnt + 4)
  2733.                                 pH->GetParam(cnt + 5, params.vPos.x);
  2734.  
  2735.                         params.bValue = (op == eGO_STICK);
  2736.  
  2737.                         pPipe->PushGoal(op, blocking, grouped, params);
  2738.                 }
  2739.                 break;
  2740.         case eGO_CHARGE:
  2741.                 {
  2742.                         assert(false);
  2743.                 }
  2744.                 break;
  2745.         case eGO_STRAFE:
  2746.                 {
  2747.                         int n = pH->GetParamCount();
  2748.                         // Distance Start
  2749.                         params.fValue = 0;
  2750.                         pH->GetParam(cnt + 1, params.fValue);
  2751.                         // Distance End
  2752.                         params.fValueAux = 0;
  2753.                         if (n > cnt + 1)
  2754.                                 pH->GetParam(cnt + 2, params.fValueAux);
  2755.                         // Strafe while moving
  2756.                         int whileMoving = 0;
  2757.                         if (n > cnt + 2)
  2758.                                 pH->GetParam(cnt + 3, whileMoving);
  2759.                         params.bValue = whileMoving != 0;
  2760.  
  2761.                         pPipe->PushGoal(op, blocking, grouped, params);
  2762.                 }
  2763.                 break;
  2764.         case eGO_WAITSIGNAL:
  2765.                 {
  2766.                         // signal to wait for
  2767.                         pH->GetParam(cnt + 1, temp);
  2768.                         params.str = temp;
  2769.  
  2770.                         // extra signal data to wait for
  2771.                         if (pH->GetParamType(cnt + 2) == svtNull)
  2772.                                 params.fValue = 0;
  2773.                         else
  2774.                         {