AICallback

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.springrts.ai
Interface AICallback

public interface AICallback

Lets Java Skirmish AIs call back to the Spring engine. We are using JNA, so we do not need native code for Java -> C wrapping. We still need native code for C -> Java wrapping though.

Method Summary
`int`	`Clb_0MULTI1FETCH3ResourceByName0Resource(int teamId, String resourceName)`
`int`	`Clb_0MULTI1FETCH3UnitDefByName0UnitDef(int teamId, String unitName)`
`int`	`Clb_0MULTI1FETCH3WeaponDefByName0WeaponDef(int teamId, String weaponDefName)`
`int`	`Clb_0MULTI1SIZE0Feature(int teamId)` Returns all features currently in LOS, or all features on the map if cheating is enabled.
`int`	`Clb_0MULTI1SIZE0FeatureDef(int teamId)`
`int`	`Clb_0MULTI1SIZE0Group(int teamId)`
`int`	`Clb_0MULTI1SIZE0Resource(int teamId)`
`int`	`Clb_0MULTI1SIZE0UnitDef(int teamId)` A UnitDef contains all properties of a unit that are specific to its type, for example the number and type of weapons or max-speed.
`int`	`Clb_0MULTI1SIZE0WeaponDef(int teamId)`
`int`	`Clb_0MULTI1SIZE3EnemyUnits0Unit(int teamId)` Returns all units that are not in this teams ally-team nor neutral and are in LOS.
`int`	`Clb_0MULTI1SIZE3EnemyUnitsIn0Unit(int teamId, AIFloat3 pos, float radius)` Returns all units that are not in this teams ally-team nor neutral and are in LOS plus they have to be located in the specified area of the map.
`int`	`Clb_0MULTI1SIZE3EnemyUnitsInRadarAndLos0Unit(int teamId)` Returns all units that are not in this teams ally-team nor neutral and are in some way visible (sight or radar).
`int`	`Clb_0MULTI1SIZE3FeaturesIn0Feature(int teamId, AIFloat3 pos, float radius)` Returns all features in a specified area that are currently in LOS, or all features in this area if cheating is enabled.
`int`	`Clb_0MULTI1SIZE3FriendlyUnits0Unit(int teamId)` Returns all units that are in this teams ally-team, including this teams units.
`int`	`Clb_0MULTI1SIZE3FriendlyUnitsIn0Unit(int teamId, AIFloat3 pos, float radius)` Returns all units that are in this teams ally-team, including this teams units plus they have to be located in the specified area of the map.
`int`	`Clb_0MULTI1SIZE3NeutralUnits0Unit(int teamId)` Returns all units that are neutral and are in LOS.
`int`	`Clb_0MULTI1SIZE3NeutralUnitsIn0Unit(int teamId, AIFloat3 pos, float radius)` Returns all units that are neutral and are in LOS plus they have to be located in the specified area of the map.
`int`	`Clb_0MULTI1SIZE3SelectedUnits0Unit(int teamId)` Returns all units that are currently selected (usually only contains units if a human payer is controlling this team as well).
`int`	`Clb_0MULTI1SIZE3TeamUnits0Unit(int teamId)` Returns all units that are of the team controlled by this AI instance.
`int`	`Clb_0MULTI1VALS0Feature(int teamId, int[] featureIds, int featureIds_max)`
`int`	`Clb_0MULTI1VALS0FeatureDef(int teamId, int[] featureDefIds, int featureDefIds_max)`
`int`	`Clb_0MULTI1VALS0Group(int teamId, int[] groupIds, int groupIds_max)`
`int`	`Clb_0MULTI1VALS0UnitDef(int teamId, int[] unitDefIds, int unitDefIds_max)`
`int`	`Clb_0MULTI1VALS3EnemyUnits0Unit(int teamId, int[] unitIds, int unitIds_max)`
`int`	`Clb_0MULTI1VALS3EnemyUnitsIn0Unit(int teamId, AIFloat3 pos, float radius, int[] unitIds, int unitIds_max)`
`int`	`Clb_0MULTI1VALS3EnemyUnitsInRadarAndLos0Unit(int teamId, int[] unitIds, int unitIds_max)`
`int`	`Clb_0MULTI1VALS3FeaturesIn0Feature(int teamId, AIFloat3 pos, float radius, int[] featureIds, int featureIds_max)`
`int`	`Clb_0MULTI1VALS3FriendlyUnits0Unit(int teamId, int[] unitIds, int unitIds_max)`
`int`	`Clb_0MULTI1VALS3FriendlyUnitsIn0Unit(int teamId, AIFloat3 pos, float radius, int[] unitIds, int unitIds_max)`
`int`	`Clb_0MULTI1VALS3NeutralUnits0Unit(int teamId, int[] unitIds, int unitIds_max)`
`int`	`Clb_0MULTI1VALS3NeutralUnitsIn0Unit(int teamId, AIFloat3 pos, float radius, int[] unitIds, int unitIds_max)`
`int`	`Clb_0MULTI1VALS3SelectedUnits0Unit(int teamId, int[] unitIds, int unitIds_max)`
`int`	`Clb_0MULTI1VALS3TeamUnits0Unit(int teamId, int[] unitIds, int unitIds_max)`
`boolean`	`Clb_Cheats_isEnabled(int teamId)`
`boolean`	`Clb_Cheats_isOnlyPassive(int teamId)`
`boolean`	`Clb_Cheats_setEnabled(int teamId, boolean enable)`
`boolean`	`Clb_Cheats_setEventsEnabled(int teamId, boolean enabled)`
`String`	`Clb_DataDirs_allocatePath(int teamId, String relPath, boolean writeable, boolean create, boolean dir, boolean common)`
`String`	`Clb_DataDirs_getConfigDir(int teamId)` This interfaces main data dir, which is where the shared library and the InterfaceInfo.lua file are located, e.g.: /usr/share/games/spring/AI/Skirmish/RAI/0.601/
`byte`	`Clb_DataDirs_getPathSeparator(int teamId)` Returns '/' on posix and '\\' on windows
`String`	`Clb_DataDirs_getWriteableDir(int teamId)` This interfaces writeable data dir, which is where eg logs, caches and learning data should be stored, e.g.: /home/userX/.spring/AI/Skirmish/RAI/0.601/
`boolean`	`Clb_DataDirs_locatePath(int teamId, String path, int path_sizeMax, String relPath, boolean writeable, boolean create, boolean dir, boolean common)` Returns an absolute path which consists of: data-dir + Skirmish-AI-path + relative-path.
`String`	`Clb_DataDirs_Roots_allocatePath(int teamId, String relPath, boolean writeable, boolean create, boolean dir)`
`boolean`	`Clb_DataDirs_Roots_getDir(int teamId, String path, int path_sizeMax, int dirIndex)` Returns the data dir at dirIndex, which is valid between 0 and (DataDirs_Roots_getSize() - 1).
`int`	`Clb_DataDirs_Roots_getSize(int teamId)` Returns the number of springs data dirs.
`boolean`	`Clb_DataDirs_Roots_locatePath(int teamId, String path, int path_sizeMax, String relPath, boolean writeable, boolean create, boolean dir)` Returns an absolute path which consists of: data-dir + relative-path.
`float`	`Clb_Economy_0REF1Resource2resourceId0getCurrent(int teamId, int resourceId)`
`float`	`Clb_Economy_0REF1Resource2resourceId0getIncome(int teamId, int resourceId)`
`float`	`Clb_Economy_0REF1Resource2resourceId0getStorage(int teamId, int resourceId)`
`float`	`Clb_Economy_0REF1Resource2resourceId0getUsage(int teamId, int resourceId)`
`int`	`Clb_Engine_handleCommand(int teamId, int toId, int commandId, int commandTopic, Pointer commandData)` Whenever an AI wants to change the engine state in any way, it has to call this method.
`String`	`Clb_Engine_Version_getAdditional(int teamId)` Returns additional information (compiler flags, svn revision etc.)
`String`	`Clb_Engine_Version_getBuildTime(int teamId)` Returns the time of build
`String`	`Clb_Engine_Version_getFull(int teamId)` Returns "Major.Minor.Patchset (Additional)"
`String`	`Clb_Engine_Version_getMajor(int teamId)` Returns the major engine revision number (e.g.
`String`	`Clb_Engine_Version_getMinor(int teamId)` Returns the minor engine revision
`String`	`Clb_Engine_Version_getNormal(int teamId)` Returns "Major.Minor"
`String`	`Clb_Engine_Version_getPatchset(int teamId)` Clients that only differ in patchset can still play together.
`int`	`Clb_Feature_0SINGLE1FETCH2FeatureDef0getDef(int teamId, int featureId)`
`float`	`Clb_Feature_getHealth(int teamId, int featureId)`
`AIFloat3`	`Clb_Feature_getPosition(int teamId, int featureId)`
`float`	`Clb_Feature_getReclaimLeft(int teamId, int featureId)`
`void`	`Clb_FeatureDef_0MAP1KEYS0getCustomParams(int teamId, int featureDefId, String[] keys)`
`int`	`Clb_FeatureDef_0MAP1SIZE0getCustomParams(int teamId, int featureDefId)`
`void`	`Clb_FeatureDef_0MAP1VALS0getCustomParams(int teamId, int featureDefId, String[] values)`
`float`	`Clb_FeatureDef_0REF1Resource2resourceId0getContainedResource(int teamId, int featureDefId, int resourceId)`
`AIFloat3`	`Clb_FeatureDef_CollisionVolume_getOffsets(int teamId, int featureDefId)` The collision volume's offset relative to the feature's center position
`AIFloat3`	`Clb_FeatureDef_CollisionVolume_getScales(int teamId, int featureDefId)` The collision volume's full axis lengths.
`int`	`Clb_FeatureDef_CollisionVolume_getTest(int teamId, int featureDefId)` Collission test algorithm used.
`String`	`Clb_FeatureDef_CollisionVolume_getType(int teamId, int featureDefId)` The type of the collision volume's form.
`String`	`Clb_FeatureDef_getDeathFeature(int teamId, int featureDefId)` Name of the FeatureDef that this turns into when killed (not reclaimed).
`String`	`Clb_FeatureDef_getDescription(int teamId, int featureDefId)`
`int`	`Clb_FeatureDef_getDrawType(int teamId, int featureDefId)`
`String`	`Clb_FeatureDef_getFileName(int teamId, int featureDefId)`
`float`	`Clb_FeatureDef_getMass(int teamId, int featureDefId)` Used to see if the object can be overrun by units of a certain heavyness
`float`	`Clb_FeatureDef_getMaxHealth(int teamId, int featureDefId)`
`String`	`Clb_FeatureDef_getModelName(int teamId, int featureDefId)`
`String`	`Clb_FeatureDef_getName(int teamId, int featureDefId)`
`float`	`Clb_FeatureDef_getReclaimTime(int teamId, int featureDefId)`
`int`	`Clb_FeatureDef_getResurrectable(int teamId, int featureDefId)` Used to determine whether the feature is resurrectable.
`int`	`Clb_FeatureDef_getSmokeTime(int teamId, int featureDefId)`
`int`	`Clb_FeatureDef_getXSize(int teamId, int featureDefId)` Size of the feature along the X axis - in other words: height.
`int`	`Clb_FeatureDef_getZSize(int teamId, int featureDefId)` Size of the feature along the Z axis - in other words: width.
`boolean`	`Clb_FeatureDef_isBlocking(int teamId, int featureDefId)`
`boolean`	`Clb_FeatureDef_isBurnable(int teamId, int featureDefId)`
`boolean`	`Clb_FeatureDef_isDestructable(int teamId, int featureDefId)`
`boolean`	`Clb_FeatureDef_isFloating(int teamId, int featureDefId)`
`boolean`	`Clb_FeatureDef_isGeoThermal(int teamId, int featureDefId)`
`boolean`	`Clb_FeatureDef_isNoSelect(int teamId, int featureDefId)`
`boolean`	`Clb_FeatureDef_isReclaimable(int teamId, int featureDefId)`
`boolean`	`Clb_FeatureDef_isUpright(int teamId, int featureDefId)`
`boolean`	`Clb_File_getContent(int teamId, String fileName, Pointer buffer, int bufferLen)` Returns false when file does not exist, or the buffer is too small
`int`	`Clb_File_getSize(int teamId, String fileName)` Return -1 when the file does not exist
`int`	`Clb_Game_getAiInterfaceVersion(int teamId)`
`int`	`Clb_Game_getCurrentFrame(int teamId)` Deprecated.
`int`	`Clb_Game_getMode(int teamId)`
`int`	`Clb_Game_getMyAllyTeam(int teamId)`
`int`	`Clb_Game_getMyTeam(int teamId)`
`int`	`Clb_Game_getPlayerTeam(int teamId, int playerId)`
`String`	`Clb_Game_getSetupScript(int teamId)`
`float`	`Clb_Game_getSpeedFactor(int teamId)`
`String`	`Clb_Game_getTeamSide(int teamId, int otherTeamId)`
`boolean`	`Clb_Game_isDebugModeEnabled(int teamId)`
`boolean`	`Clb_Game_isExceptionHandlingEnabled(int teamId)`
`boolean`	`Clb_Game_isPaused(int teamId)`
`int`	`Clb_Group_0MULTI1SIZE0SupportedCommand(int teamId, int groupId)`
`boolean`	`Clb_Group_isSelected(int teamId, int groupId)`
`int`	`Clb_Group_OrderPreview_0ARRAY1SIZE0getParams(int teamId, int groupId)`
`int`	`Clb_Group_OrderPreview_0ARRAY1VALS0getParams(int teamId, int groupId, float[] params, int params_max)`
`int`	`Clb_Group_OrderPreview_getId(int teamId, int groupId)` For the id, see CMD_xxx codes in Sim/Unit/CommandAI/Command.h (custom codes can also be used)
`byte`	`Clb_Group_OrderPreview_getOptions(int teamId, int groupId)`
`int`	`Clb_Group_OrderPreview_getTag(int teamId, int groupId)`
`int`	`Clb_Group_OrderPreview_getTimeOut(int teamId, int groupId)`
`int`	`Clb_Group_SupportedCommand_0ARRAY1SIZE0getParams(int teamId, int groupId, int commandId)`
`int`	`Clb_Group_SupportedCommand_0ARRAY1VALS0getParams(int teamId, int groupId, int commandId, String[] params, int params_max)`
`int`	`Clb_Group_SupportedCommand_getId(int teamId, int groupId, int commandId)` For the id, see CMD_xxx codes in Sim/Unit/CommandAI/Command.h (custom codes can also be used)
`String`	`Clb_Group_SupportedCommand_getName(int teamId, int groupId, int commandId)`
`String`	`Clb_Group_SupportedCommand_getToolTip(int teamId, int groupId, int commandId)`
`boolean`	`Clb_Group_SupportedCommand_isDisabled(int teamId, int groupId, int commandId)`
`boolean`	`Clb_Group_SupportedCommand_isShowUnique(int teamId, int groupId, int commandId)`
`AIFloat3`	`Clb_Gui_Camera_getDirection(int teamId)`
`AIFloat3`	`Clb_Gui_Camera_getPosition(int teamId)`
`float`	`Clb_Gui_getScreenX(int teamId)`
`float`	`Clb_Gui_getScreenY(int teamId)`
`float`	`Clb_Gui_getViewRange(int teamId)`
`void`	`Clb_Log_exception(int teamId, String msg, int severety, boolean die)` Inform the engine of an error that happend in the interface.
`void`	`Clb_Log_log(int teamId, String msg)` This will end up in infolog
`int`	`Clb_Map_0ARRAY1SIZE0getHeightMap(int teamId)` Returns the height for the center of the squares.
`int`	`Clb_Map_0ARRAY1SIZE0getJammerMap(int teamId)` the radar jammer map A square with value 0 means you do not have radar jamming coverage.
`int`	`Clb_Map_0ARRAY1SIZE0getLosMap(int teamId)` the level of sight map gs->mapx >> losMipLevel A square with value zero means you do not have LOS coverage on it.
`int`	`Clb_Map_0ARRAY1SIZE0getRadarMap(int teamId)` the radar map A square with value 0 means you do not have radar coverage on it.
`int`	`Clb_Map_0ARRAY1SIZE0getSlopeMap(int teamId)` the slope map The values are 1 minus the y-component of the (average) facenormal of the square.
`int`	`Clb_Map_0ARRAY1SIZE0REF1Resource2resourceId0getResourceMapRaw(int teamId, int resourceId)` resource maps This map shows the resource density on the map.
`int`	`Clb_Map_0ARRAY1SIZE0REF1Resource2resourceId0getResourceMapSpotsPositions(int teamId, int resourceId)` Returns positions indicating where to place resource extractors on the map.
`int`	`Clb_Map_0ARRAY1VALS0getHeightMap(int teamId, float[] heights, int heights_max)`
`int`	`Clb_Map_0ARRAY1VALS0getJammerMap(int teamId, short[] jammerValues, int jammerValues_max)`
`int`	`Clb_Map_0ARRAY1VALS0getLosMap(int teamId, short[] losValues, int losValues_max)`
`int`	`Clb_Map_0ARRAY1VALS0getRadarMap(int teamId, short[] radarValues, int radarValues_max)`
`int`	`Clb_Map_0ARRAY1VALS0getSlopeMap(int teamId, float[] slopes, int slopes_max)`
`int`	`Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0getResourceMapRaw(int teamId, int resourceId, byte[] resources, int resources_max)`
`int`	`Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0getResourceMapSpotsPositions(int teamId, int resourceId, AIFloat3[] spots, int spots_max)`
`float`	`Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0initResourceMapSpotsAverageIncome(int teamId, int resourceId)` Returns the average resource income for an extractor on one of the evaluated positions.
`AIFloat3`	`Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0initResourceMapSpotsNearest(int teamId, int resourceId, AIFloat3 pos)` Returns the nearest resource extractor spot to a specified position out of the evaluated list.
`int`	`Clb_Map_0MULTI1SIZE0Line(int teamId, boolean includeAllies)` Returns all lines drawn with this AIs team color, and additionally the ones drawn with allied team colors, if `includeAllies` is true.
`int`	`Clb_Map_0MULTI1SIZE0Point(int teamId, boolean includeAllies)` Returns all points drawn with this AIs team color, and additionally the ones drawn with allied team colors, if `includeAllies` is true.
`float`	`Clb_Map_0REF1Resource2resourceId0getExtractorRadius(int teamId, int resourceId)` Returns extraction radius for resource extractors
`float`	`Clb_Map_0REF1Resource2resourceId0getMaxResource(int teamId, int resourceId)` Returns what value 255 in the resource map is worth
`AIFloat3`	`Clb_Map_0REF1UnitDef2unitDefId0findClosestBuildSite(int teamId, int unitDefId, AIFloat3 pos, float searchRadius, int minDist, int facing)` Returns the closest position from a given position that a building can be built at.
`boolean`	`Clb_Map_0REF1UnitDef2unitDefId0isPossibleToBuildAt(int teamId, int unitDefId, AIFloat3 pos, int facing)`
`int`	`Clb_Map_getChecksum(int teamId)`
`float`	`Clb_Map_getCurWind(int teamId)`
`float`	`Clb_Map_getElevationAt(int teamId, float x, float z)` Gets the elevation of the map at position (x, z)
`float`	`Clb_Map_getGravity(int teamId)`
`int`	`Clb_Map_getHeight(int teamId)` Returns the maps height in full resolution
`float`	`Clb_Map_getMaxHeight(int teamId)`
`float`	`Clb_Map_getMaxWind(int teamId)`
`float`	`Clb_Map_getMinHeight(int teamId)`
`float`	`Clb_Map_getMinWind(int teamId)`
`AIFloat3`	`Clb_Map_getMousePos(int teamId)`
`String`	`Clb_Map_getName(int teamId)`
`AIFloat3`	`Clb_Map_getStartPos(int teamId)`
`float`	`Clb_Map_getTidalStrength(int teamId)`
`int`	`Clb_Map_getWidth(int teamId)` Returns the maps width in full resolution
`boolean`	`Clb_Map_isPosInCamera(int teamId, AIFloat3 pos, float radius)`
`AIFloat3`	`Clb_Map_Line_getColor(int teamId, int lineId)`
`AIFloat3`	`Clb_Map_Line_getFirstPosition(int teamId, int lineId)`
`AIFloat3`	`Clb_Map_Line_getSecondPosition(int teamId, int lineId)`
`AIFloat3`	`Clb_Map_Point_getColor(int teamId, int pointId)`
`String`	`Clb_Map_Point_getLabel(int teamId, int pointId)`
`AIFloat3`	`Clb_Map_Point_getPosition(int teamId, int pointId)`
`float`	`Clb_Mod_getAirLosMul(int teamId)` units airsightdistance will be multiplied with this, for testing purposes
`int`	`Clb_Mod_getAirMipLevel(int teamId)` miplevel to use for airlos
`boolean`	`Clb_Mod_getAllowTeamColors(int teamId)`
`float`	`Clb_Mod_getCaptureEnergyCostFactor(int teamId)` How much should energy should capture cost, default 0.0
`boolean`	`Clb_Mod_getConstructionDecay(int teamId)` Should constructions without builders decay?
`float`	`Clb_Mod_getConstructionDecaySpeed(int teamId)` How fast do they decay?
`int`	`Clb_Mod_getConstructionDecayTime(int teamId)` How long until they start decaying?
`String`	`Clb_Mod_getDescription(int teamId)`
`String`	`Clb_Mod_getFileName(int teamId)` archive filename
`int`	`Clb_Mod_getFireAtCrashing(int teamId)` 1 = units fire at crashing aircrafts, 0 = units ignore crashing aircrafts
`int`	`Clb_Mod_getFireAtKilled(int teamId)` 1 = units fire at enemies running Killed() script, 0 = units ignore such enemies
`int`	`Clb_Mod_getFlankingBonusModeDefault(int teamId)` 0=no flanking bonus; 1=global coords, mobile; 2=unit coords, mobile; 3=unit coords, locked
`String`	`Clb_Mod_getHumanName(int teamId)` archive filename
`int`	`Clb_Mod_getLosMipLevel(int teamId)` miplevel for los
`float`	`Clb_Mod_getLosMul(int teamId)` units sightdistance will be multiplied with this, for testing purposes
`int`	`Clb_Mod_getMultiReclaim(int teamId)` 0 = 1 reclaimer per feature max, otherwise unlimited
`String`	`Clb_Mod_getMutator(int teamId)`
`boolean`	`Clb_Mod_getReclaimAllowAllies(int teamId)` Allow reclaiming allies? default true
`boolean`	`Clb_Mod_getReclaimAllowEnemies(int teamId)` Allow reclaiming enemies? default true
`float`	`Clb_Mod_getReclaimFeatureEnergyCostFactor(int teamId)` How much should energy should reclaiming a feature cost, default 0.0
`int`	`Clb_Mod_getReclaimMethod(int teamId)` 0 = gradual reclaim, 1 = all reclaimed at end, otherwise reclaim in reclaimMethod chunks
`float`	`Clb_Mod_getReclaimUnitEfficiency(int teamId)` How much metal should reclaim return, default 1.0
`float`	`Clb_Mod_getReclaimUnitEnergyCostFactor(int teamId)` How much energy should reclaiming a unit cost, default 0.0
`int`	`Clb_Mod_getReclaimUnitMethod(int teamId)` 0 = Revert to wireframe, gradual reclaim, 1 = Subtract HP, give full metal at end, default 1
`float`	`Clb_Mod_getRepairEnergyCostFactor(int teamId)` How much should energy should repair cost, default 0.0
`boolean`	`Clb_Mod_getRequireSonarUnderWater(int teamId)` when underwater, units are not in LOS unless also in sonar
`float`	`Clb_Mod_getResurrectEnergyCostFactor(int teamId)` How much should energy should resurrect cost, default 0.5
`String`	`Clb_Mod_getShortName(int teamId)`
`int`	`Clb_Mod_getTransportAir(int teamId)` 0 = all air units cannot be transported, 1 = all air units can be transported (mass and size restrictions still apply).
`int`	`Clb_Mod_getTransportGround(int teamId)` 0 = all ground units cannot be transported, 1 = all ground units can be transported (mass and size restrictions still apply).
`int`	`Clb_Mod_getTransportHover(int teamId)` 0 = all hover units cannot be transported, 1 = all hover units can be transported (mass and size restrictions still apply).
`int`	`Clb_Mod_getTransportShip(int teamId)` 0 = all naval units cannot be transported, 1 = all naval units can be transported (mass and size restrictions still apply).
`String`	`Clb_Mod_getVersion(int teamId)`
`String`	`Clb_Resource_getName(int teamId, int resourceId)`
`float`	`Clb_Resource_getOptimum(int teamId, int resourceId)`
`String`	`Clb_SkirmishAI_Info_getDescription(int teamId, int infoIndex)` Returns the description of the key at index infoIndex in the info map for this Skirmish AI, or NULL if the infoIndex is invalid.
`String`	`Clb_SkirmishAI_Info_getKey(int teamId, int infoIndex)` Returns the key at index infoIndex in the info map for this Skirmish AI, or NULL if the infoIndex is invalid.
`int`	`Clb_SkirmishAI_Info_getSize(int teamId)` Returns the number of info key-value pairs in the info map for this Skirmish AI.
`String`	`Clb_SkirmishAI_Info_getValue(int teamId, int infoIndex)` Returns the value at index infoIndex in the info map for this Skirmish AI, or NULL if the infoIndex is invalid.
`String`	`Clb_SkirmishAI_Info_getValueByKey(int teamId, String key)` Returns the value associated with the given key in the info map for this Skirmish AI, or NULL if not found.
`String`	`Clb_SkirmishAI_OptionValues_getKey(int teamId, int optionIndex)` Returns the key at index optionIndex in the options map for this Skirmish AI, or NULL if the optionIndex is invalid.
`int`	`Clb_SkirmishAI_OptionValues_getSize(int teamId)` Returns the number of option key-value pairs in the options map for this Skirmish AI.
`String`	`Clb_SkirmishAI_OptionValues_getValue(int teamId, int optionIndex)` Returns the value at index optionIndex in the options map for this Skirmish AI, or NULL if the optionIndex is invalid.
`String`	`Clb_SkirmishAI_OptionValues_getValueByKey(int teamId, String key)` Returns the value associated with the given key in the options map for this Skirmish AI, or NULL if not found.
`int`	`Clb_SkirmishAIs_getMax(int teamId)` Returns the maximum number of skirmish AIs in any game
`int`	`Clb_SkirmishAIs_getSize(int teamId)` Returns the number of skirmish AIs in this game
`int`	`Clb_Teams_getSize(int teamId)` Returns the number of teams in this game
`int`	`Clb_Unit_0MULTI1SIZE0ModParam(int teamId, int unitId)` This is a set of parameters that is initialized in CreateUnitRulesParams() and may change during the game.
`int`	`Clb_Unit_0MULTI1SIZE0ResourceInfo(int teamId, int unitId)`
`int`	`Clb_Unit_0MULTI1SIZE0SupportedCommand(int teamId, int unitId)` The commands that this unit can understand, other commands will be ignored
`int`	`Clb_Unit_0MULTI1SIZE1Command0CurrentCommand(int teamId, int unitId)`
`float`	`Clb_Unit_0REF1Resource2resourceId0getResourceMake(int teamId, int unitId, int resourceId)`
`float`	`Clb_Unit_0REF1Resource2resourceId0getResourceUse(int teamId, int unitId, int resourceId)`
`int`	`Clb_Unit_0SINGLE1FETCH2UnitDef0getDef(int teamId, int unitId)` Returns the unit's unitdef struct from which you can read all the statistics of the unit, do NOT try to change any values in it.
`int`	`Clb_Unit_0STATIC0getLimit(int teamId)` Returns the numnber of units a team can have, after which it can not build any more.
`int`	`Clb_Unit_CurrentCommand_0ARRAY1SIZE0getParams(int teamId, int unitId, int commandId)`
`int`	`Clb_Unit_CurrentCommand_0ARRAY1VALS0getParams(int teamId, int unitId, int commandId, float[] params, int params_max)`
`int`	`Clb_Unit_CurrentCommand_0STATIC0getType(int teamId, int unitId)` For the type of the command queue, see CCommandQueue::CommandQueueType in Sim/Unit/CommandAI/CommandQueue.h
`int`	`Clb_Unit_CurrentCommand_getId(int teamId, int unitId, int commandId)` For the id, see CMD_xxx codes in Sim/Unit/CommandAI/Command.h (custom codes can also be used)
`byte`	`Clb_Unit_CurrentCommand_getOptions(int teamId, int unitId, int commandId)`
`int`	`Clb_Unit_CurrentCommand_getTag(int teamId, int unitId, int commandId)`
`int`	`Clb_Unit_CurrentCommand_getTimeOut(int teamId, int unitId, int commandId)`
`int`	`Clb_Unit_getAiHint(int teamId, int unitId)` Indicates the units main function.
`int`	`Clb_Unit_getAllyTeam(int teamId, int unitId)`
`int`	`Clb_Unit_getBuildingFacing(int teamId, int unitId)` Returns the unit's build facing (0-3)
`float`	`Clb_Unit_getCurrentFuel(int teamId, int unitId)`
`float`	`Clb_Unit_getExperience(int teamId, int unitId)` How experienced the unit is (0.0f-1.0f)
`int`	`Clb_Unit_getGroup(int teamId, int unitId)` Returns the group a unit belongs to, -1 if none
`float`	`Clb_Unit_getHealth(int teamId, int unitId)` The unit's current health
`int`	`Clb_Unit_getLastUserOrderFrame(int teamId, int unitId)` Number of the last frame this unit received an order from a player.
`int`	`Clb_Unit_getLineage(int teamId, int unitId)` The unit's origin lies in this team.
`float`	`Clb_Unit_getMaxHealth(int teamId, int unitId)` The unit's max health
`float`	`Clb_Unit_getMaxRange(int teamId, int unitId)` The furthest any weapon of the unit can fire
`float`	`Clb_Unit_getMaxSpeed(int teamId, int unitId)` The unit's max speed
`AIFloat3`	`Clb_Unit_getPos(int teamId, int unitId)`
`float`	`Clb_Unit_getPower(int teamId, int unitId)` Indicate the relative power of the unit, used for experience calulations etc.
`float`	`Clb_Unit_getSpeed(int teamId, int unitId)`
`int`	`Clb_Unit_getStockpile(int teamId, int unitId)`
`int`	`Clb_Unit_getStockpileQueued(int teamId, int unitId)`
`int`	`Clb_Unit_getTeam(int teamId, int unitId)`
`boolean`	`Clb_Unit_isActivated(int teamId, int unitId)`
`boolean`	`Clb_Unit_isBeingBuilt(int teamId, int unitId)` Returns true if the unit is currently being built
`boolean`	`Clb_Unit_isCloaked(int teamId, int unitId)`
`boolean`	`Clb_Unit_isNeutral(int teamId, int unitId)`
`boolean`	`Clb_Unit_isParalyzed(int teamId, int unitId)`
`String`	`Clb_Unit_ModParam_getName(int teamId, int unitId, int modParamId)`
`float`	`Clb_Unit_ModParam_getValue(int teamId, int unitId, int modParamId)`
`int`	`Clb_Unit_SupportedCommand_0ARRAY1SIZE0getParams(int teamId, int unitId, int commandId)`
`int`	`Clb_Unit_SupportedCommand_0ARRAY1VALS0getParams(int teamId, int unitId, int commandId, String[] params, int params_max)`
`int`	`Clb_Unit_SupportedCommand_getId(int teamId, int unitId, int commandId)` For the id, see CMD_xxx codes in Sim/Unit/CommandAI/Command.h (custom codes can also be used)
`String`	`Clb_Unit_SupportedCommand_getName(int teamId, int unitId, int commandId)`
`String`	`Clb_Unit_SupportedCommand_getToolTip(int teamId, int unitId, int commandId)`
`boolean`	`Clb_Unit_SupportedCommand_isDisabled(int teamId, int unitId, int commandId)`
`boolean`	`Clb_Unit_SupportedCommand_isShowUnique(int teamId, int unitId, int commandId)`
`int`	`Clb_UnitDef_0ARRAY1SIZE1UnitDef0getBuildOptions(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_0ARRAY1VALS1UnitDef0getBuildOptions(int teamId, int unitDefId, int[] unitDefIds, int unitDefIds_max)`
`boolean`	`Clb_UnitDef_0AVAILABLE0MoveData(int teamId, int unitDefId)`
`void`	`Clb_UnitDef_0MAP1KEYS0getCustomParams(int teamId, int unitDefId, String[] keys)`
`int`	`Clb_UnitDef_0MAP1SIZE0getCustomParams(int teamId, int unitDefId)`
`void`	`Clb_UnitDef_0MAP1VALS0getCustomParams(int teamId, int unitDefId, String[] values)`
`int`	`Clb_UnitDef_0MULTI1SIZE0WeaponMount(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_0REF1Resource2resourceId0getCost(int teamId, int unitDefId, int resourceId)`
`float`	`Clb_UnitDef_0REF1Resource2resourceId0getExtractsResource(int teamId, int unitDefId, int resourceId)`
`float`	`Clb_UnitDef_0REF1Resource2resourceId0getMakesResource(int teamId, int unitDefId, int resourceId)` This amount of the resource will be created when the unit is on and enough energy can be drained.
`float`	`Clb_UnitDef_0REF1Resource2resourceId0getResourceExtractorRange(int teamId, int unitDefId, int resourceId)`
`float`	`Clb_UnitDef_0REF1Resource2resourceId0getResourceMake(int teamId, int unitDefId, int resourceId)` This amount of the resource will always be created.
`float`	`Clb_UnitDef_0REF1Resource2resourceId0getStorage(int teamId, int unitDefId, int resourceId)`
`float`	`Clb_UnitDef_0REF1Resource2resourceId0getTidalResourceGenerator(int teamId, int unitDefId, int resourceId)`
`float`	`Clb_UnitDef_0REF1Resource2resourceId0getUpkeep(int teamId, int unitDefId, int resourceId)`
`float`	`Clb_UnitDef_0REF1Resource2resourceId0getWindResourceGenerator(int teamId, int unitDefId, int resourceId)`
`boolean`	`Clb_UnitDef_0REF1Resource2resourceId0isResourceMaker(int teamId, int unitDefId, int resourceId)`
`boolean`	`Clb_UnitDef_0REF1Resource2resourceId0isSquareResourceExtractor(int teamId, int unitDefId, int resourceId)`
`int`	`Clb_UnitDef_0SINGLE1FETCH2UnitDef0getDecoyDef(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_0SINGLE1FETCH2WeaponDef0getShieldDef(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_0SINGLE1FETCH2WeaponDef0getStockpileDef(int teamId, int unitDefId)`
`AIFloat3`	`Clb_UnitDef_CollisionVolume_getOffsets(int teamId, int unitDefId)` The collision volume's offset relative to the unit's center position
`AIFloat3`	`Clb_UnitDef_CollisionVolume_getScales(int teamId, int unitDefId)` The collision volume's full axis lengths.
`int`	`Clb_UnitDef_CollisionVolume_getTest(int teamId, int unitDefId)` Collission test algorithm used.
`String`	`Clb_UnitDef_CollisionVolume_getType(int teamId, int unitDefId)` The type of the collision volume's form.
`AIFloat3`	`Clb_UnitDef_FlankingBonus_getDir(int teamId, int unitDefId)` The unit takes less damage when attacked from this direction.
`float`	`Clb_UnitDef_FlankingBonus_getMax(int teamId, int unitDefId)` Damage factor for the least protected direction
`float`	`Clb_UnitDef_FlankingBonus_getMin(int teamId, int unitDefId)` Damage factor for the most protected direction
`float`	`Clb_UnitDef_FlankingBonus_getMobilityAdd(int teamId, int unitDefId)` How much the ability of the flanking bonus direction to move builds up each frame.
`int`	`Clb_UnitDef_FlankingBonus_getMode(int teamId, int unitDefId)` The flanking bonus indicates how much additional damage you can inflict to a unit, if it gets attacked from different directions.
`int`	`Clb_UnitDef_getAiHint(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getAirLosRadius(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getArmoredMultiple(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getArmorType(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getAutoHeal(int teamId, int unitDefId)` This amount of auto-heal will always be applied.
`int`	`Clb_UnitDef_getBuildAngle(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getBuildDistance(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getBuildingDecalDecaySpeed(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getBuildingDecalSizeX(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getBuildingDecalSizeY(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getBuildingDecalType(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getBuildSpeed(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getBuildTime(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getCaptureSpeed(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getCategory(int teamId, int unitDefId)`
`String`	`Clb_UnitDef_getCategoryString(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getCloakCost(int teamId, int unitDefId)` Energy cost per second to stay cloaked when stationary
`float`	`Clb_UnitDef_getCloakCostMoving(int teamId, int unitDefId)` Energy cost per second to stay cloaked when moving
`int`	`Clb_UnitDef_getCobId(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getControlRadius(int teamId, int unitDefId)`
`String`	`Clb_UnitDef_getDeathExplosion(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getDecloakDistance(int teamId, int unitDefId)` If enemy unit comes within this range, decloaking is forced
`float`	`Clb_UnitDef_getDlHoverFactor(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getDrag(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getFallSpeed(int teamId, int unitDefId)` Dictates fall speed of all transported units.
`String`	`Clb_UnitDef_getFileName(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getFireState(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getFlareDelay(int teamId, int unitDefId)`
`AIFloat3`	`Clb_UnitDef_getFlareDropVector(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getFlareEfficiency(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getFlareReloadTime(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getFlareSalvoDelay(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getFlareSalvoSize(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getFlareTime(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getFrontToSpeed(int teamId, int unitDefId)`
`String`	`Clb_UnitDef_getGaia(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getHealth(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getHeight(int teamId, int unitDefId)` Forces loading of the unit model
`int`	`Clb_UnitDef_getHighTrajectoryType(int teamId, int unitDefId)` Indicates the trajectory types supported by this unit.
`String`	`Clb_UnitDef_getHumanName(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getIdleAutoHeal(int teamId, int unitDefId)` This amount of auto-heal will only be applied while the unit is idling.
`int`	`Clb_UnitDef_getIdleTime(int teamId, int unitDefId)` Time a unit needs to idle before it is considered idling.
`int`	`Clb_UnitDef_getJammerRadius(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getKamikazeDist(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getLoadingRadius(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getLosHeight(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getLosRadius(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMass(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMaxAcceleration(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMaxAileron(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMaxBank(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMaxDeceleration(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMaxElevator(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMaxFuel(int teamId, int unitDefId)` Maximum flight time in seconds before the aircraft needs to return to an air repair bay to refuel.
`float`	`Clb_UnitDef_getMaxHeightDif(int teamId, int unitDefId)` Maximum terra-form height this building allows.
`float`	`Clb_UnitDef_getMaxPitch(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMaxRepairSpeed(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMaxRudder(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMaxSlope(int teamId, int unitDefId)` Build location relevant maximum steepness of the underlaying terrain.
`int`	`Clb_UnitDef_getMaxThisUnit(int teamId, int unitDefId)` Number of units of this type allowed simultaneously in the game
`float`	`Clb_UnitDef_getMaxWaterDepth(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMaxWeaponRange(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMinAirBasePower(int teamId, int unitDefId)` Minimum build power of airbases that this aircraft can land on
`float`	`Clb_UnitDef_getMinCollisionSpeed(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMinTransportMass(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getMinTransportSize(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMinWaterDepth(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getMoveState(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getMoveType(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getMyGravity(int teamId, int unitDefId)`
`String`	`Clb_UnitDef_getName(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getNoChaseCategory(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getPower(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getRadarRadius(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getRadius(int teamId, int unitDefId)` Forces loading of the unit model
`float`	`Clb_UnitDef_getReclaimSpeed(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getRefuelTime(int teamId, int unitDefId)` Time to fully refuel the unit
`float`	`Clb_UnitDef_getRepairSpeed(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getResurrectSpeed(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getSeismicRadius(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getSeismicSignature(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getSelfDCountdown(int teamId, int unitDefId)`
`String`	`Clb_UnitDef_getSelfDExplosion(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getSlideTolerance(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getSonarJamRadius(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getSonarRadius(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getSpeed(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getSpeedToFront(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getTechLevel(int teamId, int unitDefId)`
`String`	`Clb_UnitDef_getTedClassString(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getTerraformSpeed(int teamId, int unitDefId)`
`String`	`Clb_UnitDef_getTooltip(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getTrackOffset(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getTrackStrength(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getTrackStretch(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getTrackType(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getTrackWidth(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getTransportCapacity(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getTransportMass(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getTransportSize(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getTransportUnloadMethod(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getTurnInPlaceDistance(int teamId, int unitDefId)` Units above this distance to goal will try to turn while keeping some of their speed.
`float`	`Clb_UnitDef_getTurnInPlaceSpeedLimit(int teamId, int unitDefId)` Units below this speed will turn in place regardless of their turnInPlace setting.
`float`	`Clb_UnitDef_getTurnRadius(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getTurnRate(int teamId, int unitDefId)`
`String`	`Clb_UnitDef_getType(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getUnitFallSpeed(int teamId, int unitDefId)` Sets the transported units FBI, overrides fallSpeed
`float`	`Clb_UnitDef_getUnloadSpread(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getVerticalSpeed(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getWantedHeight(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getWaterline(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getWingAngle(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_getWingDrag(int teamId, int unitDefId)`
`String`	`Clb_UnitDef_getWreckName(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getXSize(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_getZSize(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToAssist(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToAttack(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToCapture(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToCloak(int teamId, int unitDefId)` If the unit can cloak
`boolean`	`Clb_UnitDef_isAbleToCrash(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToDGun(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToDropFlare(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToFight(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToFireControl(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToFly(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToGuard(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToHover(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToKamikaze(int teamId, int unitDefId)` Will the unit self destruct if an enemy comes to close?
`boolean`	`Clb_UnitDef_isAbleToLoopbackAttack(int teamId, int unitDefId)` Only matters for fighter aircraft
`boolean`	`Clb_UnitDef_isAbleToMove(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToPatrol(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToReclaim(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToRepair(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToRepeat(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToRestore(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToResurrect(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToSelfD(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToSelfRepair(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAbleToSubmerge(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isActivateWhenBuilt(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAirBase(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAirStrafe(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isAssistable(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isBuilder(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isBuildRange3D(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isCapturable(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isCollide(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isCommander(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isDecloakOnFire(int teamId, int unitDefId)` Will the unit decloak upon firing?
`boolean`	`Clb_UnitDef_isDecloakSpherical(int teamId, int unitDefId)` Use a spherical, instead of a cylindrical test?
`boolean`	`Clb_UnitDef_isDontLand(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isFactoryHeadingTakeoff(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isFeature(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isFirePlatform(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isFloater(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isFullHealthFactory(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isHideDamage(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isHoldSteady(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isHoverAttack(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isLeaveTracks(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isLevelGround(int teamId, int unitDefId)` Indicates whether the ground will be leveled/flattened out after this building has been built on it.
`boolean`	`Clb_UnitDef_isNeedGeo(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isNotTransportable(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isOnOffable(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isPushResistant(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isReclaimable(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isReleaseHeld(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isShowPlayerName(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isSonarStealth(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isStartCloaked(int teamId, int unitDefId)` If the unit wants to start out cloaked
`boolean`	`Clb_UnitDef_isStealth(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isStrafeToAttack(int teamId, int unitDefId)` Should the unit move sideways when it can not shoot?
`boolean`	`Clb_UnitDef_isTargetingFacility(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isTransportByEnemy(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isTurnInPlace(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isUpright(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isUseBuildingGroundDecal(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_isValid(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_MoveData_getCrushStrength(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_MoveData_getDepth(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_MoveData_getDepthMod(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_MoveData_getFollowGround(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_MoveData_getMaxAcceleration(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_MoveData_getMaxBreaking(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_MoveData_getMaxSlope(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_MoveData_getMaxSpeed(int teamId, int unitDefId)`
`short`	`Clb_UnitDef_MoveData_getMaxTurnRate(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_MoveData_getMoveFamily(int teamId, int unitDefId)` enum MoveFamily { Tank=0, KBot=1, Hover=2, Ship=3 };
`int`	`Clb_UnitDef_MoveData_getMoveType(int teamId, int unitDefId)` enum MoveType { Ground_Move=0, Hover_Move=1, Ship_Move=2 };
`String`	`Clb_UnitDef_MoveData_getName(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_MoveData_getPathType(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_MoveData_getSize(int teamId, int unitDefId)`
`float`	`Clb_UnitDef_MoveData_getSlopeMod(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_MoveData_getTerrainClass(int teamId, int unitDefId)`
`boolean`	`Clb_UnitDef_MoveData_isSubMarine(int teamId, int unitDefId)`
`int`	`Clb_UnitDef_WeaponMount_0SINGLE1FETCH2WeaponDef0getWeaponDef(int teamId, int unitDefId, int weaponMountId)`
`int`	`Clb_UnitDef_WeaponMount_getBadTargetCategory(int teamId, int unitDefId, int weaponMountId)`
`float`	`Clb_UnitDef_WeaponMount_getFuelUsage(int teamId, int unitDefId, int weaponMountId)` How many seconds of fuel it costs for the owning unit to fire this weapon.
`AIFloat3`	`Clb_UnitDef_WeaponMount_getMainDir(int teamId, int unitDefId, int weaponMountId)`
`float`	`Clb_UnitDef_WeaponMount_getMaxAngleDif(int teamId, int unitDefId, int weaponMountId)`
`String`	`Clb_UnitDef_WeaponMount_getName(int teamId, int unitDefId, int weaponMountId)`
`int`	`Clb_UnitDef_WeaponMount_getOnlyTargetCategory(int teamId, int unitDefId, int weaponMountId)`
`int`	`Clb_UnitDef_WeaponMount_getSlavedTo(int teamId, int unitDefId, int weaponMountId)`
`void`	`Clb_WeaponDef_0MAP1KEYS0getCustomParams(int teamId, int weaponDefId, String[] keys)`
`int`	`Clb_WeaponDef_0MAP1SIZE0getCustomParams(int teamId, int weaponDefId)`
`void`	`Clb_WeaponDef_0MAP1VALS0getCustomParams(int teamId, int weaponDefId, String[] values)`
`float`	`Clb_WeaponDef_0REF1Resource2resourceId0getCost(int teamId, int weaponDefId, int resourceId)`
`int`	`Clb_WeaponDef_0STATIC0getNumDamageTypes(int teamId)`
`int`	`Clb_WeaponDef_Damage_0ARRAY1SIZE0getTypes(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_Damage_0ARRAY1VALS0getTypes(int teamId, int weaponDefId, float[] types, int types_max)`
`float`	`Clb_WeaponDef_Damage_getCraterBoost(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_Damage_getCraterMult(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_Damage_getImpulseBoost(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_Damage_getImpulseFactor(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_Damage_getParalyzeDamageTime(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getAccuracy(int teamId, int weaponDefId)` Inaccuracy of whole burst
`float`	`Clb_WeaponDef_getAreaOfEffect(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getBeamTime(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getBounceRebound(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getBounceSlip(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getCameraShake(int teamId, int weaponDefId)`
`String`	`Clb_WeaponDef_getCegTag(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getCollisionFlags(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getCollisionSize(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getCoreThickness(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getCoverageRange(int teamId, int weaponDefId)` Range of interceptors.
`float`	`Clb_WeaponDef_getCylinderTargetting(int teamId, int weaponDefId)` If greater than 0, the range will be checked in a cylinder (height=range*cylinderTargetting) instead of a sphere.
`float`	`Clb_WeaponDef_getDance(int teamId, int weaponDefId)` How much the missile will dance.
`String`	`Clb_WeaponDef_getDescription(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getDuration(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getDynDamageExp(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getDynDamageMin(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getDynDamageRange(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getEdgeEffectiveness(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getExplosionSpeed(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getFalloffRate(int teamId, int weaponDefId)`
`String`	`Clb_WeaponDef_getFileName(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getFireStarter(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getFlightTime(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getGraphicsType(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getHeightBoostFactor(int teamId, int weaponDefId)` Controls cannon range height boost.
`float`	`Clb_WeaponDef_getHeightMod(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getHighTrajectory(int teamId, int weaponDefId)` Per weapon high trajectory setting.
`float`	`Clb_WeaponDef_getIntensity(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getInterceptedByShieldType(int teamId, int weaponDefId)` The type of shields that can intercept this weapon (bitfield).
`int`	`Clb_WeaponDef_getInterceptor(int teamId, int weaponDefId)` Can intercept targetable weapons shots.
`float`	`Clb_WeaponDef_getLaserFlareSize(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getLeadBonus(int teamId, int weaponDefId)` Factor for increasing the leadLimit with experience
`float`	`Clb_WeaponDef_getLeadLimit(int teamId, int weaponDefId)` Maximum distance the weapon will lead the target
`int`	`Clb_WeaponDef_getLodDistance(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getMaxAngle(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getMaxVelocity(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getMinIntensity(int teamId, int weaponDefId)` For beam-lasers only - always hit with some minimum intensity (a damage coeffcient normally dependent on distance).
`float`	`Clb_WeaponDef_getMovingAccuracy(int teamId, int weaponDefId)` Inaccuracy while owner moving
`float`	`Clb_WeaponDef_getMyGravity(int teamId, int weaponDefId)`
`String`	`Clb_WeaponDef_getName(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getNumBounce(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getOnlyTargetCategory(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getPredictBoost(int teamId, int weaponDefId)` Replaces hardcoded behaviour for burnblow cannons
`float`	`Clb_WeaponDef_getProjectileSpeed(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getProjectilesPerShot(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getProximityPriority(int teamId, int weaponDefId)` Multiplier for the distance to the target for priority calculations.
`float`	`Clb_WeaponDef_getRange(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getReload(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getRestTime(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getSalvoDelay(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getSalvoSize(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getSize(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getSizeGrowth(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getSprayAngle(int teamId, int weaponDefId)` Inaccuracy of individual shots inside burst
`float`	`Clb_WeaponDef_getStartVelocity(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getStockpileTime(int teamId, int weaponDefId)` Build time of a missile
`float`	`Clb_WeaponDef_getSupplyCost(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getTargetable(int teamId, int weaponDefId)` Shoots interceptable projectiles.
`float`	`Clb_WeaponDef_getTargetBorder(int teamId, int weaponDefId)` If nonzero, targetting units will TryTarget at the edge of collision sphere (radius*tag value, [-1;1]) instead of its centre.
`float`	`Clb_WeaponDef_getTargetMoveError(int teamId, int weaponDefId)` Fraction of targets move speed that is used as error offset
`float`	`Clb_WeaponDef_getThickness(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getTrajectoryHeight(int teamId, int weaponDefId)` How high trajectory missiles will try to fly in.
`float`	`Clb_WeaponDef_getTurnRate(int teamId, int weaponDefId)`
`String`	`Clb_WeaponDef_getType(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getUpTime(int teamId, int weaponDefId)`
`int`	`Clb_WeaponDef_getVisibleShieldHitFrames(int teamId, int weaponDefId)` The number of frames to draw the shield after it has been hit.
`float`	`Clb_WeaponDef_getWeaponAcceleration(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_getWobble(int teamId, int weaponDefId)` How much the missile will wobble around its course.
`boolean`	`Clb_WeaponDef_isAbleToAttackGround(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isAvoidFeature(int teamId, int weaponDefId)` Tries to avoid features while aiming?
`boolean`	`Clb_WeaponDef_isAvoidFriendly(int teamId, int weaponDefId)` Tries to avoid friendly units while aiming?
`boolean`	`Clb_WeaponDef_isAvoidNeutral(int teamId, int weaponDefId)` Tries to avoid neutral units while aiming?
`boolean`	`Clb_WeaponDef_isBeamBurst(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isDropped(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isDynDamageInverted(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isExteriorShield(int teamId, int weaponDefId)` If the shield only affects stuff coming from outside shield radius.
`boolean`	`Clb_WeaponDef_isFireSubmersed(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isFixedLauncher(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isGravityAffected(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isGroundBounce(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isImpactOnly(int teamId, int weaponDefId)` The weapon damages by impacting, not by exploding.
`boolean`	`Clb_WeaponDef_isLargeBeamLaser(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isManualFire(int teamId, int weaponDefId)` Has to be fired manually (by the player or an AI, example: D-Gun)
`boolean`	`Clb_WeaponDef_isNoAutoTarget(int teamId, int weaponDefId)` Can not target anything (for example: anti-nuke, D-Gun)
`boolean`	`Clb_WeaponDef_isNoExplode(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isNoSelfDamage(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isOnlyForward(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isParalyzer(int teamId, int weaponDefId)` The weapon will only paralyze, not do real damage.
`boolean`	`Clb_WeaponDef_isSelfExplode(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isShield(int teamId, int weaponDefId)` If the weapon is a shield rather than a weapon.
`boolean`	`Clb_WeaponDef_isShieldRepulser(int teamId, int weaponDefId)` If the weapon should be repulsed or absorbed.
`boolean`	`Clb_WeaponDef_isSmartShield(int teamId, int weaponDefId)` If the shield only affects enemy projectiles.
`boolean`	`Clb_WeaponDef_isSoundTrigger(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isStockpileable(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isSubMissile(int teamId, int weaponDefId)` Lets a torpedo travel above water like it does below water
`boolean`	`Clb_WeaponDef_isSweepFire(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isTracks(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isTurret(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isVisibleShield(int teamId, int weaponDefId)` If the shield should be graphically shown.
`boolean`	`Clb_WeaponDef_isVisibleShieldRepulse(int teamId, int weaponDefId)` If a small graphic should be shown at each repulse.
`boolean`	`Clb_WeaponDef_isWaterBounce(int teamId, int weaponDefId)`
`boolean`	`Clb_WeaponDef_isWaterWeapon(int teamId, int weaponDefId)`
`float`	`Clb_WeaponDef_Shield_0REF1Resource2resourceId0getPowerRegenResource(int teamId, int weaponDefId, int resourceId)` How much of a given resource is needed to regenerate power with max speed per second.
`float`	`Clb_WeaponDef_Shield_0REF1Resource2resourceId0getResourceUse(int teamId, int weaponDefId, int resourceId)` Amount of the resource used per shot or per second, depending on the type of projectile.
`float`	`Clb_WeaponDef_Shield_getAlpha(int teamId, int weaponDefId)` The shields alpha value.
`AIFloat3`	`Clb_WeaponDef_Shield_getBadColor(int teamId, int weaponDefId)` The color of the shield when it is empty.
`float`	`Clb_WeaponDef_Shield_getForce(int teamId, int weaponDefId)` Shield acceleration on plasma stuff.
`AIFloat3`	`Clb_WeaponDef_Shield_getGoodColor(int teamId, int weaponDefId)` The color of the shield when it is at full power.
`int`	`Clb_WeaponDef_Shield_getInterceptType(int teamId, int weaponDefId)` The type of the shield (bitfield).
`float`	`Clb_WeaponDef_Shield_getMaxSpeed(int teamId, int weaponDefId)` Maximum speed to which the shield can repulse plasma.
`float`	`Clb_WeaponDef_Shield_getPower(int teamId, int weaponDefId)` Amount of damage the shield can reflect.
`float`	`Clb_WeaponDef_Shield_getPowerRegen(int teamId, int weaponDefId)` Amount of power that is regenerated per second.
`float`	`Clb_WeaponDef_Shield_getRadius(int teamId, int weaponDefId)` Size of shield covered area
`int`	`Clb_WeaponDef_Shield_getRechargeDelay(int teamId, int weaponDefId)` Number of frames to delay recharging by after each hit.
`float`	`Clb_WeaponDef_Shield_getStartingPower(int teamId, int weaponDefId)` How much power the shield has when it is created.

Method Detail

Clb_Engine_handleCommand

int Clb_Engine_handleCommand(int teamId,
                             int toId,
                             int commandId,
                             int commandTopic,
                             Pointer commandData)

Whenever an AI wants to change the engine state in any way, it has to call this method. In other words, all commands from AIs to the engine (and other AIs) go through this method.

Parameters:: teamId - the team number of the AI that sends the command; toId - the team number of the AI that should receive the command, or COMMAND_TO_ID_ENGINE if it is addressed to the engine; commandId - used on asynchronous commands, this allows the AI to identify a possible result event, which would come with the same id; commandTopic - unique identifier of a command (see COMMAND_* defines in AISCommands.h); commandData - a commandTopic specific struct, which contains the data associated with the command (see *Command structs)
Returns:: 0: if command handling ok != 0: something else otherwise

Clb_Engine_Version_getMajor

String Clb_Engine_Version_getMajor(int teamId)

Returns the major engine revision number (e.g. 0.77)

Clb_Engine_Version_getMinor

String Clb_Engine_Version_getMinor(int teamId)

Returns the minor engine revision

Clb_Engine_Version_getPatchset

String Clb_Engine_Version_getPatchset(int teamId)

Clients that only differ in patchset can still play together. Also demos should be compatible between patchsets.

Clb_Engine_Version_getAdditional

String Clb_Engine_Version_getAdditional(int teamId)

Returns additional information (compiler flags, svn revision etc.)

Clb_Engine_Version_getBuildTime

String Clb_Engine_Version_getBuildTime(int teamId)

Returns the time of build

Clb_Engine_Version_getNormal

String Clb_Engine_Version_getNormal(int teamId)

Returns "Major.Minor"

Clb_Engine_Version_getFull

String Clb_Engine_Version_getFull(int teamId)

Returns "Major.Minor.Patchset (Additional)"

Clb_Teams_getSize

int Clb_Teams_getSize(int teamId)

Returns the number of teams in this game

Clb_SkirmishAIs_getSize

int Clb_SkirmishAIs_getSize(int teamId)

Returns the number of skirmish AIs in this game

Clb_SkirmishAIs_getMax

int Clb_SkirmishAIs_getMax(int teamId)

Returns the maximum number of skirmish AIs in any game

Clb_SkirmishAI_Info_getSize

int Clb_SkirmishAI_Info_getSize(int teamId)

Returns the number of info key-value pairs in the info map for this Skirmish AI.

Clb_SkirmishAI_Info_getKey

String Clb_SkirmishAI_Info_getKey(int teamId,
                                  int infoIndex)

Returns the key at index infoIndex in the info map for this Skirmish AI, or NULL if the infoIndex is invalid.

Clb_SkirmishAI_Info_getValue

String Clb_SkirmishAI_Info_getValue(int teamId,
                                    int infoIndex)

Returns the value at index infoIndex in the info map for this Skirmish AI, or NULL if the infoIndex is invalid.

Clb_SkirmishAI_Info_getDescription

String Clb_SkirmishAI_Info_getDescription(int teamId,
                                          int infoIndex)

Returns the description of the key at index infoIndex in the info map for this Skirmish AI, or NULL if the infoIndex is invalid.

Clb_SkirmishAI_Info_getValueByKey

String Clb_SkirmishAI_Info_getValueByKey(int teamId,
                                         String key)

Returns the value associated with the given key in the info map for this Skirmish AI, or NULL if not found.

Clb_SkirmishAI_OptionValues_getSize

int Clb_SkirmishAI_OptionValues_getSize(int teamId)

Returns the number of option key-value pairs in the options map for this Skirmish AI.

Clb_SkirmishAI_OptionValues_getKey

String Clb_SkirmishAI_OptionValues_getKey(int teamId,
                                          int optionIndex)

Returns the key at index optionIndex in the options map for this Skirmish AI, or NULL if the optionIndex is invalid.

Clb_SkirmishAI_OptionValues_getValue

String Clb_SkirmishAI_OptionValues_getValue(int teamId,
                                            int optionIndex)

Returns the value at index optionIndex in the options map for this Skirmish AI, or NULL if the optionIndex is invalid.

Clb_SkirmishAI_OptionValues_getValueByKey

String Clb_SkirmishAI_OptionValues_getValueByKey(int teamId,
                                                 String key)

Returns the value associated with the given key in the options map for this Skirmish AI, or NULL if not found.

Clb_Log_log

void Clb_Log_log(int teamId,
                 String msg)

This will end up in infolog

Clb_Log_exception

void Clb_Log_exception(int teamId,
                       String msg,
                       int severety,
                       boolean die)

Inform the engine of an error that happend in the interface.

Parameters:: msg - error message; severety - from 10 for minor to 0 for fatal; die - if this is set to true, the engine assumes the interface is in an irreparable state, and it will unload it immediately.

Clb_DataDirs_getPathSeparator

byte Clb_DataDirs_getPathSeparator(int teamId)

Returns '/' on posix and '\\' on windows

Clb_DataDirs_getConfigDir

String Clb_DataDirs_getConfigDir(int teamId)

This interfaces main data dir, which is where the shared library and the InterfaceInfo.lua file are located, e.g.: /usr/share/games/spring/AI/Skirmish/RAI/0.601/

Clb_DataDirs_getWriteableDir

String Clb_DataDirs_getWriteableDir(int teamId)

This interfaces writeable data dir, which is where eg logs, caches and learning data should be stored, e.g.: /home/userX/.spring/AI/Skirmish/RAI/0.601/

Clb_DataDirs_locatePath

boolean Clb_DataDirs_locatePath(int teamId,
                                String path,
                                int path_sizeMax,
                                String relPath,
                                boolean writeable,
                                boolean create,
                                boolean dir,
                                boolean common)

Returns an absolute path which consists of: data-dir + Skirmish-AI-path + relative-path. example: input: "log/main.log", writeable, create, !dir, !common output: "/home/userX/.spring/AI/Skirmish/RAI/0.601/log/main.log" The path "/home/userX/.spring/AI/Skirmish/RAI/0.601/log/" is created, if it does not yet exist.

Parameters:: path - store for the resulting absolute path; path_sizeMax - storage size of the above; writeable - if true, only the writeable data-dir is considered; create - if true, and realPath is not found, its dir structure is created recursively under the writeable data-dir; dir - if true, realPath specifies a dir, which means if create is true, the whole path will be created, including the last part; common - if true, the version independent data-dir is formed, which uses "common" instead of the version, eg: "/home/userX/.spring/AI/Skirmish/RAI/common/..."
Returns:: whether the locating process was successfull -> the path exists and is stored in an absolute form in path
See Also:: DataDirs_Roots_locatePath

Clb_DataDirs_allocatePath

String Clb_DataDirs_allocatePath(int teamId,
                                 String relPath,
                                 boolean writeable,
                                 boolean create,
                                 boolean dir,
                                 boolean common)

See Also:: locatePath()

Clb_DataDirs_Roots_getSize

int Clb_DataDirs_Roots_getSize(int teamId)

Returns the number of springs data dirs.

Clb_DataDirs_Roots_getDir

boolean Clb_DataDirs_Roots_getDir(int teamId,
                                  String path,
                                  int path_sizeMax,
                                  int dirIndex)

Returns the data dir at dirIndex, which is valid between 0 and (DataDirs_Roots_getSize() - 1).

Clb_DataDirs_Roots_locatePath

boolean Clb_DataDirs_Roots_locatePath(int teamId,
                                      String path,
                                      int path_sizeMax,
                                      String relPath,
                                      boolean writeable,
                                      boolean create,
                                      boolean dir)

Returns an absolute path which consists of: data-dir + relative-path. example: input: "AI/Skirmish", writeable, create, dir output: "/home/userX/.spring/AI/Skirmish/" The path "/home/userX/.spring/AI/Skirmish/" is created, if it does not yet exist.

Parameters:: path - store for the resulting absolute path; path_sizeMax - storage size of the above; relPath - the relative path to find; writeable - if true, only the writeable data-dir is considered; create - if true, and realPath is not found, its dir structure is created recursively under the writeable data-dir; dir - if true, realPath specifies a dir, which means if create is true, the whole path will be created, including the last part
Returns:: whether the locating process was successfull -> the path exists and is stored in an absolute form in path
See Also:: DataDirs_locatePath

Clb_DataDirs_Roots_allocatePath

String Clb_DataDirs_Roots_allocatePath(int teamId,
                                       String relPath,
                                       boolean writeable,
                                       boolean create,
                                       boolean dir)

Clb_Game_getCurrentFrame

int Clb_Game_getCurrentFrame(int teamId)

Deprecated.

Returns the current game time measured in frames (the simulation runs at 30 frames per second at normal speed) This should not be used, as we get the frame from the SUpdateEvent.

Clb_Game_getAiInterfaceVersion

int Clb_Game_getAiInterfaceVersion(int teamId)

Clb_Game_getMyTeam

int Clb_Game_getMyTeam(int teamId)

Clb_Game_getMyAllyTeam

int Clb_Game_getMyAllyTeam(int teamId)

Clb_Game_getPlayerTeam

int Clb_Game_getPlayerTeam(int teamId,
                           int playerId)

Clb_Game_getTeamSide

String Clb_Game_getTeamSide(int teamId,
                            int otherTeamId)

Clb_Game_isExceptionHandlingEnabled

boolean Clb_Game_isExceptionHandlingEnabled(int teamId)

Clb_Game_isDebugModeEnabled

boolean Clb_Game_isDebugModeEnabled(int teamId)

Clb_Game_getMode

int Clb_Game_getMode(int teamId)

Clb_Game_isPaused

boolean Clb_Game_isPaused(int teamId)

Clb_Game_getSpeedFactor

float Clb_Game_getSpeedFactor(int teamId)

Clb_Game_getSetupScript

String Clb_Game_getSetupScript(int teamId)

Clb_Gui_getViewRange

float Clb_Gui_getViewRange(int teamId)

Clb_Gui_getScreenX

float Clb_Gui_getScreenX(int teamId)

Clb_Gui_getScreenY

float Clb_Gui_getScreenY(int teamId)

Clb_Gui_Camera_getDirection

AIFloat3 Clb_Gui_Camera_getDirection(int teamId)

Clb_Gui_Camera_getPosition

AIFloat3 Clb_Gui_Camera_getPosition(int teamId)

Clb_Cheats_isEnabled

boolean Clb_Cheats_isEnabled(int teamId)

Clb_Cheats_setEnabled

boolean Clb_Cheats_setEnabled(int teamId,
                              boolean enable)

Clb_Cheats_setEventsEnabled

boolean Clb_Cheats_setEventsEnabled(int teamId,
                                    boolean enabled)

Clb_Cheats_isOnlyPassive

boolean Clb_Cheats_isOnlyPassive(int teamId)

Clb_0MULTI1SIZE0Resource

int Clb_0MULTI1SIZE0Resource(int teamId)

Clb_0MULTI1FETCH3ResourceByName0Resource

int Clb_0MULTI1FETCH3ResourceByName0Resource(int teamId,
                                             String resourceName)

Clb_Resource_getName

String Clb_Resource_getName(int teamId,
                            int resourceId)

Clb_Resource_getOptimum

float Clb_Resource_getOptimum(int teamId,
                              int resourceId)

Clb_Economy_0REF1Resource2resourceId0getCurrent

float Clb_Economy_0REF1Resource2resourceId0getCurrent(int teamId,
                                                      int resourceId)

Clb_Economy_0REF1Resource2resourceId0getIncome

float Clb_Economy_0REF1Resource2resourceId0getIncome(int teamId,
                                                     int resourceId)

Clb_Economy_0REF1Resource2resourceId0getUsage

float Clb_Economy_0REF1Resource2resourceId0getUsage(int teamId,
                                                    int resourceId)

Clb_Economy_0REF1Resource2resourceId0getStorage

float Clb_Economy_0REF1Resource2resourceId0getStorage(int teamId,
                                                      int resourceId)

Clb_File_getSize

int Clb_File_getSize(int teamId,
                     String fileName)

Return -1 when the file does not exist

Clb_File_getContent

boolean Clb_File_getContent(int teamId,
                            String fileName,
                            Pointer buffer,
                            int bufferLen)

Returns false when file does not exist, or the buffer is too small

Clb_0MULTI1SIZE0UnitDef

int Clb_0MULTI1SIZE0UnitDef(int teamId)

A UnitDef contains all properties of a unit that are specific to its type, for example the number and type of weapons or max-speed. These properties are usually fixed, and not meant to change during a game. The unitId is a unique id for this type of unit.

Clb_0MULTI1VALS0UnitDef

int Clb_0MULTI1VALS0UnitDef(int teamId,
                            int[] unitDefIds,
                            int unitDefIds_max)

Clb_0MULTI1FETCH3UnitDefByName0UnitDef

int Clb_0MULTI1FETCH3UnitDefByName0UnitDef(int teamId,
                                           String unitName)

Clb_UnitDef_getHeight

float Clb_UnitDef_getHeight(int teamId,
                            int unitDefId)

Forces loading of the unit model

Clb_UnitDef_getRadius

float Clb_UnitDef_getRadius(int teamId,
                            int unitDefId)

Forces loading of the unit model

Clb_UnitDef_isValid

boolean Clb_UnitDef_isValid(int teamId,
                            int unitDefId)

Clb_UnitDef_getName

String Clb_UnitDef_getName(int teamId,
                           int unitDefId)

Clb_UnitDef_getHumanName

String Clb_UnitDef_getHumanName(int teamId,
                                int unitDefId)

Clb_UnitDef_getFileName

String Clb_UnitDef_getFileName(int teamId,
                               int unitDefId)

Clb_UnitDef_getAiHint

int Clb_UnitDef_getAiHint(int teamId,
                          int unitDefId)

Clb_UnitDef_getCobId

int Clb_UnitDef_getCobId(int teamId,
                         int unitDefId)

Clb_UnitDef_getTechLevel

int Clb_UnitDef_getTechLevel(int teamId,
                             int unitDefId)

Clb_UnitDef_getGaia

String Clb_UnitDef_getGaia(int teamId,
                           int unitDefId)

Clb_UnitDef_0REF1Resource2resourceId0getUpkeep

float Clb_UnitDef_0REF1Resource2resourceId0getUpkeep(int teamId,
                                                     int unitDefId,
                                                     int resourceId)

Clb_UnitDef_0REF1Resource2resourceId0getResourceMake

float Clb_UnitDef_0REF1Resource2resourceId0getResourceMake(int teamId,
                                                           int unitDefId,
                                                           int resourceId)

This amount of the resource will always be created.

Clb_UnitDef_0REF1Resource2resourceId0getMakesResource

float Clb_UnitDef_0REF1Resource2resourceId0getMakesResource(int teamId,
                                                            int unitDefId,
                                                            int resourceId)

This amount of the resource will be created when the unit is on and enough energy can be drained.

Clb_UnitDef_0REF1Resource2resourceId0getCost

float Clb_UnitDef_0REF1Resource2resourceId0getCost(int teamId,
                                                   int unitDefId,
                                                   int resourceId)

Clb_UnitDef_0REF1Resource2resourceId0getExtractsResource

float Clb_UnitDef_0REF1Resource2resourceId0getExtractsResource(int teamId,
                                                               int unitDefId,
                                                               int resourceId)

Clb_UnitDef_0REF1Resource2resourceId0getResourceExtractorRange

float Clb_UnitDef_0REF1Resource2resourceId0getResourceExtractorRange(int teamId,
                                                                     int unitDefId,
                                                                     int resourceId)

Clb_UnitDef_0REF1Resource2resourceId0getWindResourceGenerator

float Clb_UnitDef_0REF1Resource2resourceId0getWindResourceGenerator(int teamId,
                                                                    int unitDefId,
                                                                    int resourceId)

Clb_UnitDef_0REF1Resource2resourceId0getTidalResourceGenerator

float Clb_UnitDef_0REF1Resource2resourceId0getTidalResourceGenerator(int teamId,
                                                                     int unitDefId,
                                                                     int resourceId)

Clb_UnitDef_0REF1Resource2resourceId0getStorage

float Clb_UnitDef_0REF1Resource2resourceId0getStorage(int teamId,
                                                      int unitDefId,
                                                      int resourceId)

Clb_UnitDef_0REF1Resource2resourceId0isSquareResourceExtractor

boolean Clb_UnitDef_0REF1Resource2resourceId0isSquareResourceExtractor(int teamId,
                                                                       int unitDefId,
                                                                       int resourceId)

Clb_UnitDef_0REF1Resource2resourceId0isResourceMaker

boolean Clb_UnitDef_0REF1Resource2resourceId0isResourceMaker(int teamId,
                                                             int unitDefId,
                                                             int resourceId)

Clb_UnitDef_getBuildTime

float Clb_UnitDef_getBuildTime(int teamId,
                               int unitDefId)

Clb_UnitDef_getAutoHeal

float Clb_UnitDef_getAutoHeal(int teamId,
                              int unitDefId)

This amount of auto-heal will always be applied.

Clb_UnitDef_getIdleAutoHeal

float Clb_UnitDef_getIdleAutoHeal(int teamId,
                                  int unitDefId)

This amount of auto-heal will only be applied while the unit is idling.

Clb_UnitDef_getIdleTime

int Clb_UnitDef_getIdleTime(int teamId,
                            int unitDefId)

Time a unit needs to idle before it is considered idling.

Clb_UnitDef_getPower

float Clb_UnitDef_getPower(int teamId,
                           int unitDefId)

Clb_UnitDef_getHealth

float Clb_UnitDef_getHealth(int teamId,
                            int unitDefId)

Clb_UnitDef_getCategory

int Clb_UnitDef_getCategory(int teamId,
                            int unitDefId)

Clb_UnitDef_getSpeed

float Clb_UnitDef_getSpeed(int teamId,
                           int unitDefId)

Clb_UnitDef_getTurnRate

float Clb_UnitDef_getTurnRate(int teamId,
                              int unitDefId)

Clb_UnitDef_isTurnInPlace

boolean Clb_UnitDef_isTurnInPlace(int teamId,
                                  int unitDefId)

Clb_UnitDef_getTurnInPlaceDistance

float Clb_UnitDef_getTurnInPlaceDistance(int teamId,
                                         int unitDefId)

Units above this distance to goal will try to turn while keeping some of their speed. 0 to disable

Clb_UnitDef_getTurnInPlaceSpeedLimit

float Clb_UnitDef_getTurnInPlaceSpeedLimit(int teamId,
                                           int unitDefId)

Units below this speed will turn in place regardless of their turnInPlace setting.

Clb_UnitDef_getMoveType

int Clb_UnitDef_getMoveType(int teamId,
                            int unitDefId)

Clb_UnitDef_isUpright

boolean Clb_UnitDef_isUpright(int teamId,
                              int unitDefId)

Clb_UnitDef_isCollide

boolean Clb_UnitDef_isCollide(int teamId,
                              int unitDefId)

Clb_UnitDef_getControlRadius

float Clb_UnitDef_getControlRadius(int teamId,
                                   int unitDefId)

Clb_UnitDef_getLosRadius

float Clb_UnitDef_getLosRadius(int teamId,
                               int unitDefId)

Clb_UnitDef_getAirLosRadius

float Clb_UnitDef_getAirLosRadius(int teamId,
                                  int unitDefId)

Clb_UnitDef_getLosHeight

float Clb_UnitDef_getLosHeight(int teamId,
                               int unitDefId)

Clb_UnitDef_getRadarRadius

int Clb_UnitDef_getRadarRadius(int teamId,
                               int unitDefId)

Clb_UnitDef_getSonarRadius

int Clb_UnitDef_getSonarRadius(int teamId,
                               int unitDefId)

Clb_UnitDef_getJammerRadius

int Clb_UnitDef_getJammerRadius(int teamId,
                                int unitDefId)

Clb_UnitDef_getSonarJamRadius

int Clb_UnitDef_getSonarJamRadius(int teamId,
                                  int unitDefId)

Clb_UnitDef_getSeismicRadius

int Clb_UnitDef_getSeismicRadius(int teamId,
                                 int unitDefId)

Clb_UnitDef_getSeismicSignature

float Clb_UnitDef_getSeismicSignature(int teamId,
                                      int unitDefId)

Clb_UnitDef_isStealth

boolean Clb_UnitDef_isStealth(int teamId,
                              int unitDefId)

Clb_UnitDef_isSonarStealth

boolean Clb_UnitDef_isSonarStealth(int teamId,
                                   int unitDefId)

Clb_UnitDef_isBuildRange3D

boolean Clb_UnitDef_isBuildRange3D(int teamId,
                                   int unitDefId)

Clb_UnitDef_getBuildDistance

float Clb_UnitDef_getBuildDistance(int teamId,
                                   int unitDefId)

Clb_UnitDef_getBuildSpeed

float Clb_UnitDef_getBuildSpeed(int teamId,
                                int unitDefId)

Clb_UnitDef_getReclaimSpeed

float Clb_UnitDef_getReclaimSpeed(int teamId,
                                  int unitDefId)

Clb_UnitDef_getRepairSpeed

float Clb_UnitDef_getRepairSpeed(int teamId,
                                 int unitDefId)

Clb_UnitDef_getMaxRepairSpeed

float Clb_UnitDef_getMaxRepairSpeed(int teamId,
                                    int unitDefId)

Clb_UnitDef_getResurrectSpeed

float Clb_UnitDef_getResurrectSpeed(int teamId,
                                    int unitDefId)

Clb_UnitDef_getCaptureSpeed

float Clb_UnitDef_getCaptureSpeed(int teamId,
                                  int unitDefId)

Clb_UnitDef_getTerraformSpeed

float Clb_UnitDef_getTerraformSpeed(int teamId,
                                    int unitDefId)

Clb_UnitDef_getMass

float Clb_UnitDef_getMass(int teamId,
                          int unitDefId)

Clb_UnitDef_isPushResistant

boolean Clb_UnitDef_isPushResistant(int teamId,
                                    int unitDefId)

Clb_UnitDef_isStrafeToAttack

boolean Clb_UnitDef_isStrafeToAttack(int teamId,
                                     int unitDefId)

Should the unit move sideways when it can not shoot?

Clb_UnitDef_getMinCollisionSpeed

float Clb_UnitDef_getMinCollisionSpeed(int teamId,
                                       int unitDefId)

Clb_UnitDef_getSlideTolerance

float Clb_UnitDef_getSlideTolerance(int teamId,
                                    int unitDefId)

Clb_UnitDef_getMaxSlope

float Clb_UnitDef_getMaxSlope(int teamId,
                              int unitDefId)

Build location relevant maximum steepness of the underlaying terrain. Used to calculate the maxHeightDif.

Clb_UnitDef_getMaxHeightDif

float Clb_UnitDef_getMaxHeightDif(int teamId,
                                  int unitDefId)

Maximum terra-form height this building allows. If this value is 0.0, you can only build this structure on totally flat terrain.

Clb_UnitDef_getMinWaterDepth

float Clb_UnitDef_getMinWaterDepth(int teamId,
                                   int unitDefId)

Clb_UnitDef_getWaterline

float Clb_UnitDef_getWaterline(int teamId,
                               int unitDefId)

Clb_UnitDef_getMaxWaterDepth

float Clb_UnitDef_getMaxWaterDepth(int teamId,
                                   int unitDefId)

Clb_UnitDef_getArmoredMultiple

float Clb_UnitDef_getArmoredMultiple(int teamId,
                                     int unitDefId)

Clb_UnitDef_getArmorType

int Clb_UnitDef_getArmorType(int teamId,
                             int unitDefId)

Clb_UnitDef_FlankingBonus_getMode

int Clb_UnitDef_FlankingBonus_getMode(int teamId,
                                      int unitDefId)

The flanking bonus indicates how much additional damage you can inflict to a unit, if it gets attacked from different directions. See the spring source code if you want to know it more precisely.

Returns:: 0: no flanking bonus 1: global coords, mobile 2: unit coords, mobile 3: unit coords, locked

Clb_UnitDef_FlankingBonus_getDir

AIFloat3 Clb_UnitDef_FlankingBonus_getDir(int teamId,
                                          int unitDefId)

The unit takes less damage when attacked from this direction. This encourage flanking fire.

Clb_UnitDef_FlankingBonus_getMax

float Clb_UnitDef_FlankingBonus_getMax(int teamId,
                                       int unitDefId)

Damage factor for the least protected direction

Clb_UnitDef_FlankingBonus_getMin

float Clb_UnitDef_FlankingBonus_getMin(int teamId,
                                       int unitDefId)

Damage factor for the most protected direction

Clb_UnitDef_FlankingBonus_getMobilityAdd

float Clb_UnitDef_FlankingBonus_getMobilityAdd(int teamId,
                                               int unitDefId)

How much the ability of the flanking bonus direction to move builds up each frame.

Clb_UnitDef_CollisionVolume_getType

String Clb_UnitDef_CollisionVolume_getType(int teamId,
                                           int unitDefId)

The type of the collision volume's form.

Returns:: "Ell" "Cyl[T]" (where [T] is one of ['X', 'Y', 'Z']) "Box"

Clb_UnitDef_CollisionVolume_getScales

AIFloat3 Clb_UnitDef_CollisionVolume_getScales(int teamId,
                                               int unitDefId)

The collision volume's full axis lengths.

Clb_UnitDef_CollisionVolume_getOffsets

AIFloat3 Clb_UnitDef_CollisionVolume_getOffsets(int teamId,
                                                int unitDefId)

The collision volume's offset relative to the unit's center position

Clb_UnitDef_CollisionVolume_getTest

int Clb_UnitDef_CollisionVolume_getTest(int teamId,
                                        int unitDefId)

Collission test algorithm used.

Returns:: 0: discrete 1: continuous

Clb_UnitDef_getMaxWeaponRange

float Clb_UnitDef_getMaxWeaponRange(int teamId,
                                    int unitDefId)

Clb_UnitDef_getType

String Clb_UnitDef_getType(int teamId,
                           int unitDefId)

Clb_UnitDef_getTooltip

String Clb_UnitDef_getTooltip(int teamId,
                              int unitDefId)

Clb_UnitDef_getWreckName

String Clb_UnitDef_getWreckName(int teamId,
                                int unitDefId)

Clb_UnitDef_getDeathExplosion

String Clb_UnitDef_getDeathExplosion(int teamId,
                                     int unitDefId)

Clb_UnitDef_getSelfDExplosion

String Clb_UnitDef_getSelfDExplosion(int teamId,
                                     int unitDefId)

Clb_UnitDef_getTedClassString

String Clb_UnitDef_getTedClassString(int teamId,
                                     int unitDefId)

Clb_UnitDef_getCategoryString

String Clb_UnitDef_getCategoryString(int teamId,
                                     int unitDefId)

Clb_UnitDef_isAbleToSelfD

boolean Clb_UnitDef_isAbleToSelfD(int teamId,
                                  int unitDefId)

Clb_UnitDef_getSelfDCountdown

int Clb_UnitDef_getSelfDCountdown(int teamId,
                                  int unitDefId)

Clb_UnitDef_isAbleToSubmerge

boolean Clb_UnitDef_isAbleToSubmerge(int teamId,
                                     int unitDefId)

Clb_UnitDef_isAbleToFly

boolean Clb_UnitDef_isAbleToFly(int teamId,
                                int unitDefId)

Clb_UnitDef_isAbleToMove

boolean Clb_UnitDef_isAbleToMove(int teamId,
                                 int unitDefId)

Clb_UnitDef_isAbleToHover

boolean Clb_UnitDef_isAbleToHover(int teamId,
                                  int unitDefId)

Clb_UnitDef_isFloater

boolean Clb_UnitDef_isFloater(int teamId,
                              int unitDefId)

Clb_UnitDef_isBuilder

boolean Clb_UnitDef_isBuilder(int teamId,
                              int unitDefId)

Clb_UnitDef_isActivateWhenBuilt

boolean Clb_UnitDef_isActivateWhenBuilt(int teamId,
                                        int unitDefId)

Clb_UnitDef_isOnOffable

boolean Clb_UnitDef_isOnOffable(int teamId,
                                int unitDefId)

Clb_UnitDef_isFullHealthFactory

boolean Clb_UnitDef_isFullHealthFactory(int teamId,
                                        int unitDefId)

Clb_UnitDef_isFactoryHeadingTakeoff

boolean Clb_UnitDef_isFactoryHeadingTakeoff(int teamId,
                                            int unitDefId)

Clb_UnitDef_isReclaimable

boolean Clb_UnitDef_isReclaimable(int teamId,
                                  int unitDefId)

Clb_UnitDef_isCapturable

boolean Clb_UnitDef_isCapturable(int teamId,
                                 int unitDefId)

Clb_UnitDef_isAbleToRestore

boolean Clb_UnitDef_isAbleToRestore(int teamId,
                                    int unitDefId)

Clb_UnitDef_isAbleToRepair

boolean Clb_UnitDef_isAbleToRepair(int teamId,
                                   int unitDefId)

Clb_UnitDef_isAbleToSelfRepair

boolean Clb_UnitDef_isAbleToSelfRepair(int teamId,
                                       int unitDefId)

Clb_UnitDef_isAbleToReclaim

boolean Clb_UnitDef_isAbleToReclaim(int teamId,
                                    int unitDefId)

Clb_UnitDef_isAbleToAttack

boolean Clb_UnitDef_isAbleToAttack(int teamId,
                                   int unitDefId)

Clb_UnitDef_isAbleToPatrol

boolean Clb_UnitDef_isAbleToPatrol(int teamId,
                                   int unitDefId)

Clb_UnitDef_isAbleToFight

boolean Clb_UnitDef_isAbleToFight(int teamId,
                                  int unitDefId)

Clb_UnitDef_isAbleToGuard

boolean Clb_UnitDef_isAbleToGuard(int teamId,
                                  int unitDefId)

Clb_UnitDef_isAbleToAssist

boolean Clb_UnitDef_isAbleToAssist(int teamId,
                                   int unitDefId)

Clb_UnitDef_isAssistable

boolean Clb_UnitDef_isAssistable(int teamId,
                                 int unitDefId)

Clb_UnitDef_isAbleToRepeat

boolean Clb_UnitDef_isAbleToRepeat(int teamId,
                                   int unitDefId)

Clb_UnitDef_isAbleToFireControl

boolean Clb_UnitDef_isAbleToFireControl(int teamId,
                                        int unitDefId)

Clb_UnitDef_getFireState

int Clb_UnitDef_getFireState(int teamId,
                             int unitDefId)

Clb_UnitDef_getMoveState

int Clb_UnitDef_getMoveState(int teamId,
                             int unitDefId)

Clb_UnitDef_getWingDrag

float Clb_UnitDef_getWingDrag(int teamId,
                              int unitDefId)

Clb_UnitDef_getWingAngle

float Clb_UnitDef_getWingAngle(int teamId,
                               int unitDefId)

Clb_UnitDef_getDrag

float Clb_UnitDef_getDrag(int teamId,
                          int unitDefId)

Clb_UnitDef_getFrontToSpeed

float Clb_UnitDef_getFrontToSpeed(int teamId,
                                  int unitDefId)

Clb_UnitDef_getSpeedToFront

float Clb_UnitDef_getSpeedToFront(int teamId,
                                  int unitDefId)

Clb_UnitDef_getMyGravity

float Clb_UnitDef_getMyGravity(int teamId,
                               int unitDefId)

Clb_UnitDef_getMaxBank

float Clb_UnitDef_getMaxBank(int teamId,
                             int unitDefId)

Clb_UnitDef_getMaxPitch

float Clb_UnitDef_getMaxPitch(int teamId,
                              int unitDefId)

Clb_UnitDef_getTurnRadius

float Clb_UnitDef_getTurnRadius(int teamId,
                                int unitDefId)

Clb_UnitDef_getWantedHeight

float Clb_UnitDef_getWantedHeight(int teamId,
                                  int unitDefId)

Clb_UnitDef_getVerticalSpeed

float Clb_UnitDef_getVerticalSpeed(int teamId,
                                   int unitDefId)

Clb_UnitDef_isAbleToCrash

boolean Clb_UnitDef_isAbleToCrash(int teamId,
                                  int unitDefId)

Clb_UnitDef_isHoverAttack

boolean Clb_UnitDef_isHoverAttack(int teamId,
                                  int unitDefId)

Clb_UnitDef_isAirStrafe

boolean Clb_UnitDef_isAirStrafe(int teamId,
                                int unitDefId)

Clb_UnitDef_getDlHoverFactor

float Clb_UnitDef_getDlHoverFactor(int teamId,
                                   int unitDefId)

Returns:: < 0: it can land >= 0: how much the unit will move during hovering on the spot

Clb_UnitDef_getMaxAcceleration

float Clb_UnitDef_getMaxAcceleration(int teamId,
                                     int unitDefId)

Clb_UnitDef_getMaxDeceleration

float Clb_UnitDef_getMaxDeceleration(int teamId,
                                     int unitDefId)

Clb_UnitDef_getMaxAileron

float Clb_UnitDef_getMaxAileron(int teamId,
                                int unitDefId)

Clb_UnitDef_getMaxElevator

float Clb_UnitDef_getMaxElevator(int teamId,
                                 int unitDefId)

Clb_UnitDef_getMaxRudder

float Clb_UnitDef_getMaxRudder(int teamId,
                               int unitDefId)

Clb_UnitDef_getXSize

int Clb_UnitDef_getXSize(int teamId,
                         int unitDefId)

Clb_UnitDef_getZSize

int Clb_UnitDef_getZSize(int teamId,
                         int unitDefId)

Clb_UnitDef_getBuildAngle

int Clb_UnitDef_getBuildAngle(int teamId,
                              int unitDefId)

Clb_UnitDef_getLoadingRadius

float Clb_UnitDef_getLoadingRadius(int teamId,
                                   int unitDefId)

Clb_UnitDef_getUnloadSpread

float Clb_UnitDef_getUnloadSpread(int teamId,
                                  int unitDefId)

Clb_UnitDef_getTransportCapacity

int Clb_UnitDef_getTransportCapacity(int teamId,
                                     int unitDefId)

Clb_UnitDef_getTransportSize

int Clb_UnitDef_getTransportSize(int teamId,
                                 int unitDefId)

Clb_UnitDef_getMinTransportSize

int Clb_UnitDef_getMinTransportSize(int teamId,
                                    int unitDefId)

Clb_UnitDef_isAirBase

boolean Clb_UnitDef_isAirBase(int teamId,
                              int unitDefId)

Clb_UnitDef_isFirePlatform

boolean Clb_UnitDef_isFirePlatform(int teamId,
                                   int unitDefId)

Clb_UnitDef_getTransportMass

float Clb_UnitDef_getTransportMass(int teamId,
                                   int unitDefId)

Clb_UnitDef_getMinTransportMass

float Clb_UnitDef_getMinTransportMass(int teamId,
                                      int unitDefId)

Clb_UnitDef_isHoldSteady

boolean Clb_UnitDef_isHoldSteady(int teamId,
                                 int unitDefId)

Clb_UnitDef_isReleaseHeld

boolean Clb_UnitDef_isReleaseHeld(int teamId,
                                  int unitDefId)

Clb_UnitDef_isNotTransportable

boolean Clb_UnitDef_isNotTransportable(int teamId,
                                       int unitDefId)

Clb_UnitDef_isTransportByEnemy

boolean Clb_UnitDef_isTransportByEnemy(int teamId,
                                       int unitDefId)

Clb_UnitDef_getTransportUnloadMethod

int Clb_UnitDef_getTransportUnloadMethod(int teamId,
                                         int unitDefId)

Returns:: 0: land unload 1: fly-over drop 2: land flood

Clb_UnitDef_getFallSpeed

float Clb_UnitDef_getFallSpeed(int teamId,
                               int unitDefId)

Dictates fall speed of all transported units. This only makes sense for air transports, if they an drop units while in the air.

Clb_UnitDef_getUnitFallSpeed

float Clb_UnitDef_getUnitFallSpeed(int teamId,
                                   int unitDefId)

Sets the transported units FBI, overrides fallSpeed

Clb_UnitDef_isAbleToCloak

boolean Clb_UnitDef_isAbleToCloak(int teamId,
                                  int unitDefId)

If the unit can cloak

Clb_UnitDef_isStartCloaked

boolean Clb_UnitDef_isStartCloaked(int teamId,
                                   int unitDefId)

If the unit wants to start out cloaked

Clb_UnitDef_getCloakCost

float Clb_UnitDef_getCloakCost(int teamId,
                               int unitDefId)

Energy cost per second to stay cloaked when stationary

Clb_UnitDef_getCloakCostMoving

float Clb_UnitDef_getCloakCostMoving(int teamId,
                                     int unitDefId)

Energy cost per second to stay cloaked when moving

Clb_UnitDef_getDecloakDistance

float Clb_UnitDef_getDecloakDistance(int teamId,
                                     int unitDefId)

If enemy unit comes within this range, decloaking is forced

Clb_UnitDef_isDecloakSpherical

boolean Clb_UnitDef_isDecloakSpherical(int teamId,
                                       int unitDefId)

Use a spherical, instead of a cylindrical test?

Clb_UnitDef_isDecloakOnFire

boolean Clb_UnitDef_isDecloakOnFire(int teamId,
                                    int unitDefId)

Will the unit decloak upon firing?

Clb_UnitDef_isAbleToKamikaze

boolean Clb_UnitDef_isAbleToKamikaze(int teamId,
                                     int unitDefId)

Will the unit self destruct if an enemy comes to close?

Clb_UnitDef_getKamikazeDist

float Clb_UnitDef_getKamikazeDist(int teamId,
                                  int unitDefId)

Clb_UnitDef_isTargetingFacility

boolean Clb_UnitDef_isTargetingFacility(int teamId,
                                        int unitDefId)

Clb_UnitDef_isAbleToDGun

boolean Clb_UnitDef_isAbleToDGun(int teamId,
                                 int unitDefId)

Clb_UnitDef_isNeedGeo

boolean Clb_UnitDef_isNeedGeo(int teamId,
                              int unitDefId)

Clb_UnitDef_isFeature

boolean Clb_UnitDef_isFeature(int teamId,
                              int unitDefId)

Clb_UnitDef_isHideDamage

boolean Clb_UnitDef_isHideDamage(int teamId,
                                 int unitDefId)

Clb_UnitDef_isCommander

boolean Clb_UnitDef_isCommander(int teamId,
                                int unitDefId)

Clb_UnitDef_isShowPlayerName

boolean Clb_UnitDef_isShowPlayerName(int teamId,
                                     int unitDefId)

Clb_UnitDef_isAbleToResurrect

boolean Clb_UnitDef_isAbleToResurrect(int teamId,
                                      int unitDefId)

Clb_UnitDef_isAbleToCapture

boolean Clb_UnitDef_isAbleToCapture(int teamId,
                                    int unitDefId)

Clb_UnitDef_getHighTrajectoryType

int Clb_UnitDef_getHighTrajectoryType(int teamId,
                                      int unitDefId)

Indicates the trajectory types supported by this unit.

Returns:: 0: (default) = only low 1: only high 2: choose

Clb_UnitDef_getNoChaseCategory

int Clb_UnitDef_getNoChaseCategory(int teamId,
                                   int unitDefId)

Clb_UnitDef_isLeaveTracks

boolean Clb_UnitDef_isLeaveTracks(int teamId,
                                  int unitDefId)

Clb_UnitDef_getTrackWidth

float Clb_UnitDef_getTrackWidth(int teamId,
                                int unitDefId)

Clb_UnitDef_getTrackOffset

float Clb_UnitDef_getTrackOffset(int teamId,
                                 int unitDefId)

Clb_UnitDef_getTrackStrength

float Clb_UnitDef_getTrackStrength(int teamId,
                                   int unitDefId)

Clb_UnitDef_getTrackStretch

float Clb_UnitDef_getTrackStretch(int teamId,
                                  int unitDefId)

Clb_UnitDef_getTrackType

int Clb_UnitDef_getTrackType(int teamId,
                             int unitDefId)

Clb_UnitDef_isAbleToDropFlare

boolean Clb_UnitDef_isAbleToDropFlare(int teamId,
                                      int unitDefId)

Clb_UnitDef_getFlareReloadTime

float Clb_UnitDef_getFlareReloadTime(int teamId,
                                     int unitDefId)

Clb_UnitDef_getFlareEfficiency

float Clb_UnitDef_getFlareEfficiency(int teamId,
                                     int unitDefId)

Clb_UnitDef_getFlareDelay

float Clb_UnitDef_getFlareDelay(int teamId,
                                int unitDefId)

Clb_UnitDef_getFlareDropVector

AIFloat3 Clb_UnitDef_getFlareDropVector(int teamId,
                                        int unitDefId)

Clb_UnitDef_getFlareTime

int Clb_UnitDef_getFlareTime(int teamId,
                             int unitDefId)

Clb_UnitDef_getFlareSalvoSize

int Clb_UnitDef_getFlareSalvoSize(int teamId,
                                  int unitDefId)

Clb_UnitDef_getFlareSalvoDelay

int Clb_UnitDef_getFlareSalvoDelay(int teamId,
                                   int unitDefId)

Clb_UnitDef_isAbleToLoopbackAttack

boolean Clb_UnitDef_isAbleToLoopbackAttack(int teamId,
                                           int unitDefId)

Only matters for fighter aircraft

Clb_UnitDef_isLevelGround

boolean Clb_UnitDef_isLevelGround(int teamId,
                                  int unitDefId)

Indicates whether the ground will be leveled/flattened out after this building has been built on it. Only matters for buildings.

Clb_UnitDef_isUseBuildingGroundDecal

boolean Clb_UnitDef_isUseBuildingGroundDecal(int teamId,
                                             int unitDefId)

Clb_UnitDef_getBuildingDecalType

int Clb_UnitDef_getBuildingDecalType(int teamId,
                                     int unitDefId)

Clb_UnitDef_getBuildingDecalSizeX

int Clb_UnitDef_getBuildingDecalSizeX(int teamId,
                                      int unitDefId)

Clb_UnitDef_getBuildingDecalSizeY

int Clb_UnitDef_getBuildingDecalSizeY(int teamId,
                                      int unitDefId)

Clb_UnitDef_getBuildingDecalDecaySpeed

float Clb_UnitDef_getBuildingDecalDecaySpeed(int teamId,
                                             int unitDefId)

Clb_UnitDef_getMaxFuel

float Clb_UnitDef_getMaxFuel(int teamId,
                             int unitDefId)

Maximum flight time in seconds before the aircraft needs to return to an air repair bay to refuel.

Clb_UnitDef_getRefuelTime

float Clb_UnitDef_getRefuelTime(int teamId,
                                int unitDefId)

Time to fully refuel the unit

Clb_UnitDef_getMinAirBasePower

float Clb_UnitDef_getMinAirBasePower(int teamId,
                                     int unitDefId)

Minimum build power of airbases that this aircraft can land on

Clb_UnitDef_getMaxThisUnit

int Clb_UnitDef_getMaxThisUnit(int teamId,
                               int unitDefId)

Number of units of this type allowed simultaneously in the game

Clb_UnitDef_0SINGLE1FETCH2UnitDef0getDecoyDef

int Clb_UnitDef_0SINGLE1FETCH2UnitDef0getDecoyDef(int teamId,
                                                  int unitDefId)

Clb_UnitDef_isDontLand

boolean Clb_UnitDef_isDontLand(int teamId,
                               int unitDefId)

Clb_UnitDef_0SINGLE1FETCH2WeaponDef0getShieldDef

int Clb_UnitDef_0SINGLE1FETCH2WeaponDef0getShieldDef(int teamId,
                                                     int unitDefId)

Clb_UnitDef_0SINGLE1FETCH2WeaponDef0getStockpileDef

int Clb_UnitDef_0SINGLE1FETCH2WeaponDef0getStockpileDef(int teamId,
                                                        int unitDefId)

Clb_UnitDef_0ARRAY1SIZE1UnitDef0getBuildOptions

int Clb_UnitDef_0ARRAY1SIZE1UnitDef0getBuildOptions(int teamId,
                                                    int unitDefId)

Clb_UnitDef_0ARRAY1VALS1UnitDef0getBuildOptions

int Clb_UnitDef_0ARRAY1VALS1UnitDef0getBuildOptions(int teamId,
                                                    int unitDefId,
                                                    int[] unitDefIds,
                                                    int unitDefIds_max)

Clb_UnitDef_0MAP1SIZE0getCustomParams

int Clb_UnitDef_0MAP1SIZE0getCustomParams(int teamId,
                                          int unitDefId)

Clb_UnitDef_0MAP1KEYS0getCustomParams

void Clb_UnitDef_0MAP1KEYS0getCustomParams(int teamId,
                                           int unitDefId,
                                           String[] keys)

Clb_UnitDef_0MAP1VALS0getCustomParams

void Clb_UnitDef_0MAP1VALS0getCustomParams(int teamId,
                                           int unitDefId,
                                           String[] values)

Clb_UnitDef_0AVAILABLE0MoveData

boolean Clb_UnitDef_0AVAILABLE0MoveData(int teamId,
                                        int unitDefId)

Clb_UnitDef_MoveData_getMaxAcceleration

float Clb_UnitDef_MoveData_getMaxAcceleration(int teamId,
                                              int unitDefId)

Clb_UnitDef_MoveData_getMaxBreaking

float Clb_UnitDef_MoveData_getMaxBreaking(int teamId,
                                          int unitDefId)

Clb_UnitDef_MoveData_getMaxSpeed

float Clb_UnitDef_MoveData_getMaxSpeed(int teamId,
                                       int unitDefId)

Clb_UnitDef_MoveData_getMaxTurnRate

short Clb_UnitDef_MoveData_getMaxTurnRate(int teamId,
                                          int unitDefId)

Clb_UnitDef_MoveData_getSize

int Clb_UnitDef_MoveData_getSize(int teamId,
                                 int unitDefId)

Clb_UnitDef_MoveData_getDepth

float Clb_UnitDef_MoveData_getDepth(int teamId,
                                    int unitDefId)

Clb_UnitDef_MoveData_getMaxSlope

float Clb_UnitDef_MoveData_getMaxSlope(int teamId,
                                       int unitDefId)

Clb_UnitDef_MoveData_getSlopeMod

float Clb_UnitDef_MoveData_getSlopeMod(int teamId,
                                       int unitDefId)

Clb_UnitDef_MoveData_getDepthMod

float Clb_UnitDef_MoveData_getDepthMod(int teamId,
                                       int unitDefId)

Clb_UnitDef_MoveData_getPathType

int Clb_UnitDef_MoveData_getPathType(int teamId,
                                     int unitDefId)

Clb_UnitDef_MoveData_getCrushStrength

float Clb_UnitDef_MoveData_getCrushStrength(int teamId,
                                            int unitDefId)

Clb_UnitDef_MoveData_getMoveType

int Clb_UnitDef_MoveData_getMoveType(int teamId,
                                     int unitDefId)

enum MoveType { Ground_Move=0, Hover_Move=1, Ship_Move=2 };

Clb_UnitDef_MoveData_getMoveFamily

int Clb_UnitDef_MoveData_getMoveFamily(int teamId,
                                       int unitDefId)

enum MoveFamily { Tank=0, KBot=1, Hover=2, Ship=3 };

Clb_UnitDef_MoveData_getTerrainClass

int Clb_UnitDef_MoveData_getTerrainClass(int teamId,
                                         int unitDefId)

Clb_UnitDef_MoveData_getFollowGround

boolean Clb_UnitDef_MoveData_getFollowGround(int teamId,
                                             int unitDefId)

Clb_UnitDef_MoveData_isSubMarine

boolean Clb_UnitDef_MoveData_isSubMarine(int teamId,
                                         int unitDefId)

Clb_UnitDef_MoveData_getName

String Clb_UnitDef_MoveData_getName(int teamId,
                                    int unitDefId)

Clb_UnitDef_0MULTI1SIZE0WeaponMount

int Clb_UnitDef_0MULTI1SIZE0WeaponMount(int teamId,
                                        int unitDefId)

Clb_UnitDef_WeaponMount_getName

String Clb_UnitDef_WeaponMount_getName(int teamId,
                                       int unitDefId,
                                       int weaponMountId)

Clb_UnitDef_WeaponMount_0SINGLE1FETCH2WeaponDef0getWeaponDef

int Clb_UnitDef_WeaponMount_0SINGLE1FETCH2WeaponDef0getWeaponDef(int teamId,
                                                                 int unitDefId,
                                                                 int weaponMountId)

Clb_UnitDef_WeaponMount_getSlavedTo

int Clb_UnitDef_WeaponMount_getSlavedTo(int teamId,
                                        int unitDefId,
                                        int weaponMountId)

Clb_UnitDef_WeaponMount_getMainDir

AIFloat3 Clb_UnitDef_WeaponMount_getMainDir(int teamId,
                                            int unitDefId,
                                            int weaponMountId)

Clb_UnitDef_WeaponMount_getMaxAngleDif

float Clb_UnitDef_WeaponMount_getMaxAngleDif(int teamId,
                                             int unitDefId,
                                             int weaponMountId)

Clb_UnitDef_WeaponMount_getFuelUsage

float Clb_UnitDef_WeaponMount_getFuelUsage(int teamId,
                                           int unitDefId,
                                           int weaponMountId)

How many seconds of fuel it costs for the owning unit to fire this weapon.

Clb_UnitDef_WeaponMount_getBadTargetCategory

int Clb_UnitDef_WeaponMount_getBadTargetCategory(int teamId,
                                                 int unitDefId,
                                                 int weaponMountId)

Clb_UnitDef_WeaponMount_getOnlyTargetCategory

int Clb_UnitDef_WeaponMount_getOnlyTargetCategory(int teamId,
                                                  int unitDefId,
                                                  int weaponMountId)

Clb_Unit_0STATIC0getLimit

int Clb_Unit_0STATIC0getLimit(int teamId)

Returns the numnber of units a team can have, after which it can not build any more. It is possible that a team has more units then this value at some point in the game. This is possible for example with taking, reclaiming or capturing units. This value is usefull for controlling game performance (eg. setting it could possibly will prevent old PCs from lagging becuase of games with lots of units).

Clb_0MULTI1SIZE3EnemyUnits0Unit

int Clb_0MULTI1SIZE3EnemyUnits0Unit(int teamId)

Returns all units that are not in this teams ally-team nor neutral and are in LOS.

Clb_0MULTI1VALS3EnemyUnits0Unit

int Clb_0MULTI1VALS3EnemyUnits0Unit(int teamId,
                                    int[] unitIds,
                                    int unitIds_max)

Clb_0MULTI1SIZE3EnemyUnitsIn0Unit

int Clb_0MULTI1SIZE3EnemyUnitsIn0Unit(int teamId,
                                      AIFloat3 pos,
                                      float radius)

Returns all units that are not in this teams ally-team nor neutral and are in LOS plus they have to be located in the specified area of the map.

Clb_0MULTI1VALS3EnemyUnitsIn0Unit

int Clb_0MULTI1VALS3EnemyUnitsIn0Unit(int teamId,
                                      AIFloat3 pos,
                                      float radius,
                                      int[] unitIds,
                                      int unitIds_max)

Clb_0MULTI1SIZE3EnemyUnitsInRadarAndLos0Unit

int Clb_0MULTI1SIZE3EnemyUnitsInRadarAndLos0Unit(int teamId)

Returns all units that are not in this teams ally-team nor neutral and are in some way visible (sight or radar).

Clb_0MULTI1VALS3EnemyUnitsInRadarAndLos0Unit

int Clb_0MULTI1VALS3EnemyUnitsInRadarAndLos0Unit(int teamId,
                                                 int[] unitIds,
                                                 int unitIds_max)

Clb_0MULTI1SIZE3FriendlyUnits0Unit

int Clb_0MULTI1SIZE3FriendlyUnits0Unit(int teamId)

Returns all units that are in this teams ally-team, including this teams units.

Clb_0MULTI1VALS3FriendlyUnits0Unit

int Clb_0MULTI1VALS3FriendlyUnits0Unit(int teamId,
                                       int[] unitIds,
                                       int unitIds_max)

Clb_0MULTI1SIZE3FriendlyUnitsIn0Unit

int Clb_0MULTI1SIZE3FriendlyUnitsIn0Unit(int teamId,
                                         AIFloat3 pos,
                                         float radius)

Returns all units that are in this teams ally-team, including this teams units plus they have to be located in the specified area of the map.

Clb_0MULTI1VALS3FriendlyUnitsIn0Unit

int Clb_0MULTI1VALS3FriendlyUnitsIn0Unit(int teamId,
                                         AIFloat3 pos,
                                         float radius,
                                         int[] unitIds,
                                         int unitIds_max)

Clb_0MULTI1SIZE3NeutralUnits0Unit

int Clb_0MULTI1SIZE3NeutralUnits0Unit(int teamId)

Returns all units that are neutral and are in LOS.

Clb_0MULTI1VALS3NeutralUnits0Unit

int Clb_0MULTI1VALS3NeutralUnits0Unit(int teamId,
                                      int[] unitIds,
                                      int unitIds_max)

Clb_0MULTI1SIZE3NeutralUnitsIn0Unit

int Clb_0MULTI1SIZE3NeutralUnitsIn0Unit(int teamId,
                                        AIFloat3 pos,
                                        float radius)

Returns all units that are neutral and are in LOS plus they have to be located in the specified area of the map.

Clb_0MULTI1VALS3NeutralUnitsIn0Unit

int Clb_0MULTI1VALS3NeutralUnitsIn0Unit(int teamId,
                                        AIFloat3 pos,
                                        float radius,
                                        int[] unitIds,
                                        int unitIds_max)

Clb_0MULTI1SIZE3TeamUnits0Unit

int Clb_0MULTI1SIZE3TeamUnits0Unit(int teamId)

Returns all units that are of the team controlled by this AI instance. This list can also be created dynamically by the AI, through updating a list on each unit-created and unit-destroyed event.

Clb_0MULTI1VALS3TeamUnits0Unit

int Clb_0MULTI1VALS3TeamUnits0Unit(int teamId,
                                   int[] unitIds,
                                   int unitIds_max)

Clb_0MULTI1SIZE3SelectedUnits0Unit

int Clb_0MULTI1SIZE3SelectedUnits0Unit(int teamId)

Returns all units that are currently selected (usually only contains units if a human payer is controlling this team as well).

Clb_0MULTI1VALS3SelectedUnits0Unit

int Clb_0MULTI1VALS3SelectedUnits0Unit(int teamId,
                                       int[] unitIds,
                                       int unitIds_max)

Clb_Unit_0SINGLE1FETCH2UnitDef0getDef

int Clb_Unit_0SINGLE1FETCH2UnitDef0getDef(int teamId,
                                          int unitId)

Returns the unit's unitdef struct from which you can read all the statistics of the unit, do NOT try to change any values in it.

Clb_Unit_0MULTI1SIZE0ModParam

int Clb_Unit_0MULTI1SIZE0ModParam(int teamId,
                                  int unitId)

This is a set of parameters that is initialized in CreateUnitRulesParams() and may change during the game. Each parameter is uniquely identified only by its id (which is the index in the vector). Parameters may or may not have a name.

Clb_Unit_ModParam_getName

String Clb_Unit_ModParam_getName(int teamId,
                                 int unitId,
                                 int modParamId)

Clb_Unit_ModParam_getValue

float Clb_Unit_ModParam_getValue(int teamId,
                                 int unitId,
                                 int modParamId)

Clb_Unit_getTeam

int Clb_Unit_getTeam(int teamId,
                     int unitId)

Clb_Unit_getAllyTeam

int Clb_Unit_getAllyTeam(int teamId,
                         int unitId)

Clb_Unit_getLineage

int Clb_Unit_getLineage(int teamId,
                        int unitId)

The unit's origin lies in this team. example: It was created by a factory that was created by a builder from a factory built by a commander of this team. It does not matter at all, to which team the commander/builder/factories were shared. Only capturing can break the chain.

Clb_Unit_getAiHint

int Clb_Unit_getAiHint(int teamId,
                       int unitId)

Indicates the units main function. This can be used as help for (skirmish) AIs. example: A unit can shoot, build and transport other units. To human players, it is obvious that transportation is the units main function, as it can transport a lot of units, but has only weak build- and fire-power. Instead of letting the AI developers write complex algorithms to find out the same, mod developers can set this value.

Returns:: 0: ??? 1: ??? 2: ??? ...

Clb_Unit_getStockpile

int Clb_Unit_getStockpile(int teamId,
                          int unitId)

Clb_Unit_getStockpileQueued

int Clb_Unit_getStockpileQueued(int teamId,
                                int unitId)

Clb_Unit_getCurrentFuel

float Clb_Unit_getCurrentFuel(int teamId,
                              int unitId)

Clb_Unit_getMaxSpeed

float Clb_Unit_getMaxSpeed(int teamId,
                           int unitId)

The unit's max speed

Clb_Unit_getMaxRange

float Clb_Unit_getMaxRange(int teamId,
                           int unitId)

The furthest any weapon of the unit can fire

Clb_Unit_getMaxHealth

float Clb_Unit_getMaxHealth(int teamId,
                            int unitId)

The unit's max health

Clb_Unit_getExperience

float Clb_Unit_getExperience(int teamId,
                             int unitId)

How experienced the unit is (0.0f-1.0f)

Clb_Unit_getGroup

int Clb_Unit_getGroup(int teamId,
                      int unitId)

Returns the group a unit belongs to, -1 if none

Clb_Unit_0MULTI1SIZE1Command0CurrentCommand

int Clb_Unit_0MULTI1SIZE1Command0CurrentCommand(int teamId,
                                                int unitId)

Clb_Unit_CurrentCommand_0STATIC0getType

int Clb_Unit_CurrentCommand_0STATIC0getType(int teamId,
                                            int unitId)

For the type of the command queue, see CCommandQueue::CommandQueueType in Sim/Unit/CommandAI/CommandQueue.h

Clb_Unit_CurrentCommand_getId

int Clb_Unit_CurrentCommand_getId(int teamId,
                                  int unitId,
                                  int commandId)

For the id, see CMD_xxx codes in Sim/Unit/CommandAI/Command.h (custom codes can also be used)

Clb_Unit_CurrentCommand_getOptions

byte Clb_Unit_CurrentCommand_getOptions(int teamId,
                                        int unitId,
                                        int commandId)

Clb_Unit_CurrentCommand_getTag

int Clb_Unit_CurrentCommand_getTag(int teamId,
                                   int unitId,
                                   int commandId)

Clb_Unit_CurrentCommand_getTimeOut

int Clb_Unit_CurrentCommand_getTimeOut(int teamId,
                                       int unitId,
                                       int commandId)

Clb_Unit_CurrentCommand_0ARRAY1SIZE0getParams

int Clb_Unit_CurrentCommand_0ARRAY1SIZE0getParams(int teamId,
                                                  int unitId,
                                                  int commandId)

Clb_Unit_CurrentCommand_0ARRAY1VALS0getParams

int Clb_Unit_CurrentCommand_0ARRAY1VALS0getParams(int teamId,
                                                  int unitId,
                                                  int commandId,
                                                  float[] params,
                                                  int params_max)

Clb_Unit_0MULTI1SIZE0SupportedCommand

int Clb_Unit_0MULTI1SIZE0SupportedCommand(int teamId,
                                          int unitId)

The commands that this unit can understand, other commands will be ignored

Clb_Unit_SupportedCommand_getId

int Clb_Unit_SupportedCommand_getId(int teamId,
                                    int unitId,
                                    int commandId)

For the id, see CMD_xxx codes in Sim/Unit/CommandAI/Command.h (custom codes can also be used)

Clb_Unit_SupportedCommand_getName

String Clb_Unit_SupportedCommand_getName(int teamId,
                                         int unitId,
                                         int commandId)

Clb_Unit_SupportedCommand_getToolTip

String Clb_Unit_SupportedCommand_getToolTip(int teamId,
                                            int unitId,
                                            int commandId)

Clb_Unit_SupportedCommand_isShowUnique

boolean Clb_Unit_SupportedCommand_isShowUnique(int teamId,
                                               int unitId,
                                               int commandId)

Clb_Unit_SupportedCommand_isDisabled

boolean Clb_Unit_SupportedCommand_isDisabled(int teamId,
                                             int unitId,
                                             int commandId)

Clb_Unit_SupportedCommand_0ARRAY1SIZE0getParams

int Clb_Unit_SupportedCommand_0ARRAY1SIZE0getParams(int teamId,
                                                    int unitId,
                                                    int commandId)

Clb_Unit_SupportedCommand_0ARRAY1VALS0getParams

int Clb_Unit_SupportedCommand_0ARRAY1VALS0getParams(int teamId,
                                                    int unitId,
                                                    int commandId,
                                                    String[] params,
                                                    int params_max)

Clb_Unit_getHealth

float Clb_Unit_getHealth(int teamId,
                         int unitId)

The unit's current health

Clb_Unit_getSpeed

float Clb_Unit_getSpeed(int teamId,
                        int unitId)

Clb_Unit_getPower

float Clb_Unit_getPower(int teamId,
                        int unitId)

Indicate the relative power of the unit, used for experience calulations etc. This is sort of the measure of the units overall power.

Clb_Unit_0MULTI1SIZE0ResourceInfo

int Clb_Unit_0MULTI1SIZE0ResourceInfo(int teamId,
                                      int unitId)

Clb_Unit_0REF1Resource2resourceId0getResourceUse

float Clb_Unit_0REF1Resource2resourceId0getResourceUse(int teamId,
                                                       int unitId,
                                                       int resourceId)

Clb_Unit_0REF1Resource2resourceId0getResourceMake

float Clb_Unit_0REF1Resource2resourceId0getResourceMake(int teamId,
                                                        int unitId,
                                                        int resourceId)

Clb_Unit_getPos

AIFloat3 Clb_Unit_getPos(int teamId,
                         int unitId)

Clb_Unit_isActivated

boolean Clb_Unit_isActivated(int teamId,
                             int unitId)

Clb_Unit_isBeingBuilt

boolean Clb_Unit_isBeingBuilt(int teamId,
                              int unitId)

Returns true if the unit is currently being built

Clb_Unit_isCloaked

boolean Clb_Unit_isCloaked(int teamId,
                           int unitId)

Clb_Unit_isParalyzed

boolean Clb_Unit_isParalyzed(int teamId,
                             int unitId)

Clb_Unit_isNeutral

boolean Clb_Unit_isNeutral(int teamId,
                           int unitId)

Clb_Unit_getBuildingFacing

int Clb_Unit_getBuildingFacing(int teamId,
                               int unitId)

Returns the unit's build facing (0-3)

Clb_Unit_getLastUserOrderFrame

int Clb_Unit_getLastUserOrderFrame(int teamId,
                                   int unitId)

Number of the last frame this unit received an order from a player.

Clb_0MULTI1SIZE0Group

int Clb_0MULTI1SIZE0Group(int teamId)

Clb_0MULTI1VALS0Group

int Clb_0MULTI1VALS0Group(int teamId,
                          int[] groupIds,
                          int groupIds_max)

Clb_Group_0MULTI1SIZE0SupportedCommand

int Clb_Group_0MULTI1SIZE0SupportedCommand(int teamId,
                                           int groupId)

Clb_Group_SupportedCommand_getId

int Clb_Group_SupportedCommand_getId(int teamId,
                                     int groupId,
                                     int commandId)

For the id, see CMD_xxx codes in Sim/Unit/CommandAI/Command.h (custom codes can also be used)

Clb_Group_SupportedCommand_getName

String Clb_Group_SupportedCommand_getName(int teamId,
                                          int groupId,
                                          int commandId)

Clb_Group_SupportedCommand_getToolTip

String Clb_Group_SupportedCommand_getToolTip(int teamId,
                                             int groupId,
                                             int commandId)

Clb_Group_SupportedCommand_isShowUnique

boolean Clb_Group_SupportedCommand_isShowUnique(int teamId,
                                                int groupId,
                                                int commandId)

Clb_Group_SupportedCommand_isDisabled

boolean Clb_Group_SupportedCommand_isDisabled(int teamId,
                                              int groupId,
                                              int commandId)

Clb_Group_SupportedCommand_0ARRAY1SIZE0getParams

int Clb_Group_SupportedCommand_0ARRAY1SIZE0getParams(int teamId,
                                                     int groupId,
                                                     int commandId)

Clb_Group_SupportedCommand_0ARRAY1VALS0getParams

int Clb_Group_SupportedCommand_0ARRAY1VALS0getParams(int teamId,
                                                     int groupId,
                                                     int commandId,
                                                     String[] params,
                                                     int params_max)

Clb_Group_OrderPreview_getId

int Clb_Group_OrderPreview_getId(int teamId,
                                 int groupId)

For the id, see CMD_xxx codes in Sim/Unit/CommandAI/Command.h (custom codes can also be used)

Clb_Group_OrderPreview_getOptions

byte Clb_Group_OrderPreview_getOptions(int teamId,
                                       int groupId)

Clb_Group_OrderPreview_getTag

int Clb_Group_OrderPreview_getTag(int teamId,
                                  int groupId)

Clb_Group_OrderPreview_getTimeOut

int Clb_Group_OrderPreview_getTimeOut(int teamId,
                                      int groupId)

Clb_Group_OrderPreview_0ARRAY1SIZE0getParams

int Clb_Group_OrderPreview_0ARRAY1SIZE0getParams(int teamId,
                                                 int groupId)

Clb_Group_OrderPreview_0ARRAY1VALS0getParams

int Clb_Group_OrderPreview_0ARRAY1VALS0getParams(int teamId,
                                                 int groupId,
                                                 float[] params,
                                                 int params_max)

Clb_Group_isSelected

boolean Clb_Group_isSelected(int teamId,
                             int groupId)

Clb_Mod_getFileName

String Clb_Mod_getFileName(int teamId)

archive filename

Clb_Mod_getHumanName

String Clb_Mod_getHumanName(int teamId)

archive filename

Clb_Mod_getShortName

String Clb_Mod_getShortName(int teamId)

Clb_Mod_getVersion

String Clb_Mod_getVersion(int teamId)

Clb_Mod_getMutator

String Clb_Mod_getMutator(int teamId)

Clb_Mod_getDescription

String Clb_Mod_getDescription(int teamId)

Clb_Mod_getAllowTeamColors

boolean Clb_Mod_getAllowTeamColors(int teamId)

Clb_Mod_getConstructionDecay

boolean Clb_Mod_getConstructionDecay(int teamId)

Should constructions without builders decay?

Clb_Mod_getConstructionDecayTime

int Clb_Mod_getConstructionDecayTime(int teamId)

How long until they start decaying?

Clb_Mod_getConstructionDecaySpeed

float Clb_Mod_getConstructionDecaySpeed(int teamId)

How fast do they decay?

Clb_Mod_getMultiReclaim

int Clb_Mod_getMultiReclaim(int teamId)

0 = 1 reclaimer per feature max, otherwise unlimited

Clb_Mod_getReclaimMethod

int Clb_Mod_getReclaimMethod(int teamId)

0 = gradual reclaim, 1 = all reclaimed at end, otherwise reclaim in reclaimMethod chunks

Clb_Mod_getReclaimUnitMethod

int Clb_Mod_getReclaimUnitMethod(int teamId)

0 = Revert to wireframe, gradual reclaim, 1 = Subtract HP, give full metal at end, default 1

Clb_Mod_getReclaimUnitEnergyCostFactor

float Clb_Mod_getReclaimUnitEnergyCostFactor(int teamId)

How much energy should reclaiming a unit cost, default 0.0

Clb_Mod_getReclaimUnitEfficiency

float Clb_Mod_getReclaimUnitEfficiency(int teamId)

How much metal should reclaim return, default 1.0

Clb_Mod_getReclaimFeatureEnergyCostFactor

float Clb_Mod_getReclaimFeatureEnergyCostFactor(int teamId)

How much should energy should reclaiming a feature cost, default 0.0

Clb_Mod_getReclaimAllowEnemies

boolean Clb_Mod_getReclaimAllowEnemies(int teamId)

Allow reclaiming enemies? default true

Clb_Mod_getReclaimAllowAllies

boolean Clb_Mod_getReclaimAllowAllies(int teamId)

Allow reclaiming allies? default true

Clb_Mod_getRepairEnergyCostFactor

float Clb_Mod_getRepairEnergyCostFactor(int teamId)

How much should energy should repair cost, default 0.0

Clb_Mod_getResurrectEnergyCostFactor

float Clb_Mod_getResurrectEnergyCostFactor(int teamId)

How much should energy should resurrect cost, default 0.5

Clb_Mod_getCaptureEnergyCostFactor

float Clb_Mod_getCaptureEnergyCostFactor(int teamId)

How much should energy should capture cost, default 0.0

Clb_Mod_getTransportGround

int Clb_Mod_getTransportGround(int teamId)

0 = all ground units cannot be transported, 1 = all ground units can be transported (mass and size restrictions still apply). Defaults to 1.

Clb_Mod_getTransportHover

int Clb_Mod_getTransportHover(int teamId)

0 = all hover units cannot be transported, 1 = all hover units can be transported (mass and size restrictions still apply). Defaults to 0.

Clb_Mod_getTransportShip

int Clb_Mod_getTransportShip(int teamId)

0 = all naval units cannot be transported, 1 = all naval units can be transported (mass and size restrictions still apply). Defaults to 0.

Clb_Mod_getTransportAir

int Clb_Mod_getTransportAir(int teamId)

0 = all air units cannot be transported, 1 = all air units can be transported (mass and size restrictions still apply). Defaults to 0.

Clb_Mod_getFireAtKilled

int Clb_Mod_getFireAtKilled(int teamId)

1 = units fire at enemies running Killed() script, 0 = units ignore such enemies

Clb_Mod_getFireAtCrashing

int Clb_Mod_getFireAtCrashing(int teamId)

1 = units fire at crashing aircrafts, 0 = units ignore crashing aircrafts

Clb_Mod_getFlankingBonusModeDefault

int Clb_Mod_getFlankingBonusModeDefault(int teamId)

0=no flanking bonus; 1=global coords, mobile; 2=unit coords, mobile; 3=unit coords, locked

Clb_Mod_getLosMipLevel

int Clb_Mod_getLosMipLevel(int teamId)

miplevel for los

Clb_Mod_getAirMipLevel

int Clb_Mod_getAirMipLevel(int teamId)

miplevel to use for airlos

Clb_Mod_getLosMul

float Clb_Mod_getLosMul(int teamId)

units sightdistance will be multiplied with this, for testing purposes

Clb_Mod_getAirLosMul

float Clb_Mod_getAirLosMul(int teamId)

units airsightdistance will be multiplied with this, for testing purposes

Clb_Mod_getRequireSonarUnderWater

boolean Clb_Mod_getRequireSonarUnderWater(int teamId)

when underwater, units are not in LOS unless also in sonar

Clb_Map_getChecksum

int Clb_Map_getChecksum(int teamId)

Clb_Map_getStartPos

AIFloat3 Clb_Map_getStartPos(int teamId)

Clb_Map_getMousePos

AIFloat3 Clb_Map_getMousePos(int teamId)

Clb_Map_isPosInCamera

boolean Clb_Map_isPosInCamera(int teamId,
                              AIFloat3 pos,
                              float radius)

Clb_Map_getWidth

int Clb_Map_getWidth(int teamId)

Returns the maps width in full resolution

Clb_Map_getHeight

int Clb_Map_getHeight(int teamId)

Returns the maps height in full resolution

Clb_Map_0ARRAY1SIZE0getHeightMap

int Clb_Map_0ARRAY1SIZE0getHeightMap(int teamId)

Returns the height for the center of the squares. This differs slightly from the drawn map, since that one uses the height at the corners. - do NOT modify or delete the height-map (native code relevant only) - index 0 is top left - each data position is 8*8 in size - the value for the full resolution position (x, z) is at index (x/8 * width + z/8) - the last value, bottom right, is at index (width/8 * height/8 - 1)

Clb_Map_0ARRAY1VALS0getHeightMap

int Clb_Map_0ARRAY1VALS0getHeightMap(int teamId,
                                     float[] heights,
                                     int heights_max)

Clb_Map_getMinHeight

float Clb_Map_getMinHeight(int teamId)

Clb_Map_getMaxHeight

float Clb_Map_getMaxHeight(int teamId)

Clb_Map_0ARRAY1SIZE0getSlopeMap

int Clb_Map_0ARRAY1SIZE0getSlopeMap(int teamId)

the slope map The values are 1 minus the y-component of the (average) facenormal of the square. - do NOT modify or delete the height-map (native code relevant only) - index 0 is top left - each data position is 2*2 in size - the value for the full resolution position (x, z) is at index (x/2 * width + z/2) - the last value, bottom right, is at index (width/2 * height/2 - 1)

Clb_Map_0ARRAY1VALS0getSlopeMap

int Clb_Map_0ARRAY1VALS0getSlopeMap(int teamId,
                                    float[] slopes,
                                    int slopes_max)

Clb_Map_0ARRAY1SIZE0getLosMap

int Clb_Map_0ARRAY1SIZE0getLosMap(int teamId)

the level of sight map gs->mapx >> losMipLevel A square with value zero means you do not have LOS coverage on it. Clb_Mod_getLosMipLevel - do NOT modify or delete the height-map (native code relevant only) - index 0 is top left - resolution factor (res) is min(1, 1 << Clb_Mod_getLosMipLevel()) examples: + losMipLevel(0) -> res(1) + losMipLevel(1) -> res(2) + losMipLevel(2) -> res(4) + losMipLevel(3) -> res(8) - each data position is res*res in size - the value for the full resolution position (x, z) is at index (x/res * width + z/res) - the last value, bottom right, is at index (width/res * height/res - 1)

Clb_Map_0ARRAY1VALS0getLosMap

int Clb_Map_0ARRAY1VALS0getLosMap(int teamId,
                                  short[] losValues,
                                  int losValues_max)

Clb_Map_0ARRAY1SIZE0getRadarMap

int Clb_Map_0ARRAY1SIZE0getRadarMap(int teamId)

the radar map A square with value 0 means you do not have radar coverage on it. - do NOT modify or delete the height-map (native code relevant only) - index 0 is top left - each data position is 8*8 in size - the value for the full resolution position (x, z) is at index (x/8 * width + z/8) - the last value, bottom right, is at index (width/8 * height/8 - 1)

Clb_Map_0ARRAY1VALS0getRadarMap

int Clb_Map_0ARRAY1VALS0getRadarMap(int teamId,
                                    short[] radarValues,
                                    int radarValues_max)

Clb_Map_0ARRAY1SIZE0getJammerMap

int Clb_Map_0ARRAY1SIZE0getJammerMap(int teamId)

the radar jammer map A square with value 0 means you do not have radar jamming coverage. - do NOT modify or delete the height-map (native code relevant only) - index 0 is top left - each data position is 8*8 in size - the value for the full resolution position (x, z) is at index (x/8 * width + z/8) - the last value, bottom right, is at index (width/8 * height/8 - 1)

Clb_Map_0ARRAY1VALS0getJammerMap

int Clb_Map_0ARRAY1VALS0getJammerMap(int teamId,
                                     short[] jammerValues,
                                     int jammerValues_max)

Clb_Map_0ARRAY1SIZE0REF1Resource2resourceId0getResourceMapRaw

int Clb_Map_0ARRAY1SIZE0REF1Resource2resourceId0getResourceMapRaw(int teamId,
                                                                  int resourceId)

resource maps This map shows the resource density on the map. - do NOT modify or delete the height-map (native code relevant only) - index 0 is top left - each data position is 2*2 in size - the value for the full resolution position (x, z) is at index (x/2 * width + z/2) - the last value, bottom right, is at index (width/2 * height/2 - 1)

Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0getResourceMapRaw

int Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0getResourceMapRaw(int teamId,
                                                                  int resourceId,
                                                                  byte[] resources,
                                                                  int resources_max)

Clb_Map_0ARRAY1SIZE0REF1Resource2resourceId0getResourceMapSpotsPositions

int Clb_Map_0ARRAY1SIZE0REF1Resource2resourceId0getResourceMapSpotsPositions(int teamId,
                                                                             int resourceId)

Returns positions indicating where to place resource extractors on the map. Only the x and z values give the location of the spots, while the y values represents the actual amount of resource an extractor placed there can make. You should only compare the y values to each other, and not try to estimate effective output from spots.

Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0getResourceMapSpotsPositions

int Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0getResourceMapSpotsPositions(int teamId,
                                                                             int resourceId,
                                                                             AIFloat3[] spots,
                                                                             int spots_max)

Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0initResourceMapSpotsAverageIncome

float Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0initResourceMapSpotsAverageIncome(int teamId,
                                                                                    int resourceId)

Returns the average resource income for an extractor on one of the evaluated positions.

Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0initResourceMapSpotsNearest

AIFloat3 Clb_Map_0ARRAY1VALS0REF1Resource2resourceId0initResourceMapSpotsNearest(int teamId,
                                                                                 int resourceId,
                                                                                 AIFloat3 pos)

Returns the nearest resource extractor spot to a specified position out of the evaluated list.

Clb_Map_getName

String Clb_Map_getName(int teamId)

Clb_Map_getElevationAt

float Clb_Map_getElevationAt(int teamId,
                             float x,
                             float z)

Gets the elevation of the map at position (x, z)

Clb_Map_0REF1Resource2resourceId0getMaxResource

float Clb_Map_0REF1Resource2resourceId0getMaxResource(int teamId,
                                                      int resourceId)

Returns what value 255 in the resource map is worth

Clb_Map_0REF1Resource2resourceId0getExtractorRadius

float Clb_Map_0REF1Resource2resourceId0getExtractorRadius(int teamId,
                                                          int resourceId)

Returns extraction radius for resource extractors

Clb_Map_getMinWind

float Clb_Map_getMinWind(int teamId)

Clb_Map_getMaxWind

float Clb_Map_getMaxWind(int teamId)

Clb_Map_getCurWind

float Clb_Map_getCurWind(int teamId)

Clb_Map_getTidalStrength

float Clb_Map_getTidalStrength(int teamId)

Clb_Map_getGravity

float Clb_Map_getGravity(int teamId)

Clb_Map_0MULTI1SIZE0Point

int Clb_Map_0MULTI1SIZE0Point(int teamId,
                              boolean includeAllies)

Returns all points drawn with this AIs team color, and additionally the ones drawn with allied team colors, if includeAllies is true.

Clb_Map_Point_getPosition

AIFloat3 Clb_Map_Point_getPosition(int teamId,
                                   int pointId)

Clb_Map_Point_getColor

AIFloat3 Clb_Map_Point_getColor(int teamId,
                                int pointId)

Clb_Map_Point_getLabel

String Clb_Map_Point_getLabel(int teamId,
                              int pointId)

Clb_Map_0MULTI1SIZE0Line

int Clb_Map_0MULTI1SIZE0Line(int teamId,
                             boolean includeAllies)

Returns all lines drawn with this AIs team color, and additionally the ones drawn with allied team colors, if includeAllies is true.

Clb_Map_Line_getFirstPosition

AIFloat3 Clb_Map_Line_getFirstPosition(int teamId,
                                       int lineId)

Clb_Map_Line_getSecondPosition

AIFloat3 Clb_Map_Line_getSecondPosition(int teamId,
                                        int lineId)

Clb_Map_Line_getColor

AIFloat3 Clb_Map_Line_getColor(int teamId,
                               int lineId)

Clb_Map_0REF1UnitDef2unitDefId0isPossibleToBuildAt

boolean Clb_Map_0REF1UnitDef2unitDefId0isPossibleToBuildAt(int teamId,
                                                           int unitDefId,
                                                           AIFloat3 pos,
                                                           int facing)

Clb_Map_0REF1UnitDef2unitDefId0findClosestBuildSite

AIFloat3 Clb_Map_0REF1UnitDef2unitDefId0findClosestBuildSite(int teamId,
                                                             int unitDefId,
                                                             AIFloat3 pos,
                                                             float searchRadius,
                                                             int minDist,
                                                             int facing)

Returns the closest position from a given position that a building can be built at.

Parameters:: minDist - the distance in squares that the building must keep to other buildings, to make it easier to keep free paths through a base

Clb_0MULTI1SIZE0FeatureDef

int Clb_0MULTI1SIZE0FeatureDef(int teamId)

Clb_0MULTI1VALS0FeatureDef

int Clb_0MULTI1VALS0FeatureDef(int teamId,
                               int[] featureDefIds,
                               int featureDefIds_max)

Clb_FeatureDef_getName

String Clb_FeatureDef_getName(int teamId,
                              int featureDefId)

Clb_FeatureDef_getDescription

String Clb_FeatureDef_getDescription(int teamId,
                                     int featureDefId)

Clb_FeatureDef_getFileName

String Clb_FeatureDef_getFileName(int teamId,
                                  int featureDefId)

Clb_FeatureDef_0REF1Resource2resourceId0getContainedResource

float Clb_FeatureDef_0REF1Resource2resourceId0getContainedResource(int teamId,
                                                                   int featureDefId,
                                                                   int resourceId)

Clb_FeatureDef_getMaxHealth

float Clb_FeatureDef_getMaxHealth(int teamId,
                                  int featureDefId)

Clb_FeatureDef_getReclaimTime

float Clb_FeatureDef_getReclaimTime(int teamId,
                                    int featureDefId)

Clb_FeatureDef_getMass

float Clb_FeatureDef_getMass(int teamId,
                             int featureDefId)

Used to see if the object can be overrun by units of a certain heavyness

Clb_FeatureDef_CollisionVolume_getType

String Clb_FeatureDef_CollisionVolume_getType(int teamId,
                                              int featureDefId)

The type of the collision volume's form.

Returns:: "Ell" "Cyl[T]" (where [T] is one of ['X', 'Y', 'Z']) "Box"

Clb_FeatureDef_CollisionVolume_getScales

AIFloat3 Clb_FeatureDef_CollisionVolume_getScales(int teamId,
                                                  int featureDefId)

The collision volume's full axis lengths.

Clb_FeatureDef_CollisionVolume_getOffsets

AIFloat3 Clb_FeatureDef_CollisionVolume_getOffsets(int teamId,
                                                   int featureDefId)

The collision volume's offset relative to the feature's center position

Clb_FeatureDef_CollisionVolume_getTest

int Clb_FeatureDef_CollisionVolume_getTest(int teamId,
                                           int featureDefId)

Collission test algorithm used.

Returns:: 0: discrete 1: continuous

Clb_FeatureDef_isUpright

boolean Clb_FeatureDef_isUpright(int teamId,
                                 int featureDefId)

Clb_FeatureDef_getDrawType

int Clb_FeatureDef_getDrawType(int teamId,
                               int featureDefId)

Clb_FeatureDef_getModelName

String Clb_FeatureDef_getModelName(int teamId,
                                   int featureDefId)

Clb_FeatureDef_getResurrectable

int Clb_FeatureDef_getResurrectable(int teamId,
                                    int featureDefId)

Used to determine whether the feature is resurrectable.

Returns:: -1: (default) only if it is the 1st wreckage of the UnitDef it originates from 0: no, never 1: yes, always

Clb_FeatureDef_getSmokeTime

int Clb_FeatureDef_getSmokeTime(int teamId,
                                int featureDefId)

Clb_FeatureDef_isDestructable

boolean Clb_FeatureDef_isDestructable(int teamId,
                                      int featureDefId)

Clb_FeatureDef_isReclaimable

boolean Clb_FeatureDef_isReclaimable(int teamId,
                                     int featureDefId)

Clb_FeatureDef_isBlocking

boolean Clb_FeatureDef_isBlocking(int teamId,
                                  int featureDefId)

Clb_FeatureDef_isBurnable

boolean Clb_FeatureDef_isBurnable(int teamId,
                                  int featureDefId)

Clb_FeatureDef_isFloating

boolean Clb_FeatureDef_isFloating(int teamId,
                                  int featureDefId)

Clb_FeatureDef_isNoSelect

boolean Clb_FeatureDef_isNoSelect(int teamId,
                                  int featureDefId)

Clb_FeatureDef_isGeoThermal

boolean Clb_FeatureDef_isGeoThermal(int teamId,
                                    int featureDefId)

Clb_FeatureDef_getDeathFeature

String Clb_FeatureDef_getDeathFeature(int teamId,
                                      int featureDefId)

Name of the FeatureDef that this turns into when killed (not reclaimed).

Clb_FeatureDef_getXSize

int Clb_FeatureDef_getXSize(int teamId,
                            int featureDefId)

Size of the feature along the X axis - in other words: height. each size is 8 units

Clb_FeatureDef_getZSize

int Clb_FeatureDef_getZSize(int teamId,
                            int featureDefId)

Size of the feature along the Z axis - in other words: width. each size is 8 units

Clb_FeatureDef_0MAP1SIZE0getCustomParams

int Clb_FeatureDef_0MAP1SIZE0getCustomParams(int teamId,
                                             int featureDefId)

Clb_FeatureDef_0MAP1KEYS0getCustomParams

void Clb_FeatureDef_0MAP1KEYS0getCustomParams(int teamId,
                                              int featureDefId,
                                              String[] keys)

Clb_FeatureDef_0MAP1VALS0getCustomParams

void Clb_FeatureDef_0MAP1VALS0getCustomParams(int teamId,
                                              int featureDefId,
                                              String[] values)

Clb_0MULTI1SIZE0Feature

int Clb_0MULTI1SIZE0Feature(int teamId)

Returns all features currently in LOS, or all features on the map if cheating is enabled.

Clb_0MULTI1VALS0Feature

int Clb_0MULTI1VALS0Feature(int teamId,
                            int[] featureIds,
                            int featureIds_max)

Clb_0MULTI1SIZE3FeaturesIn0Feature

int Clb_0MULTI1SIZE3FeaturesIn0Feature(int teamId,
                                       AIFloat3 pos,
                                       float radius)

Returns all features in a specified area that are currently in LOS, or all features in this area if cheating is enabled.

Clb_0MULTI1VALS3FeaturesIn0Feature

int Clb_0MULTI1VALS3FeaturesIn0Feature(int teamId,
                                       AIFloat3 pos,
                                       float radius,
                                       int[] featureIds,
                                       int featureIds_max)

Clb_Feature_0SINGLE1FETCH2FeatureDef0getDef

int Clb_Feature_0SINGLE1FETCH2FeatureDef0getDef(int teamId,
                                                int featureId)

Clb_Feature_getHealth

float Clb_Feature_getHealth(int teamId,
                            int featureId)

Clb_Feature_getReclaimLeft

float Clb_Feature_getReclaimLeft(int teamId,
                                 int featureId)

Clb_Feature_getPosition

AIFloat3 Clb_Feature_getPosition(int teamId,
                                 int featureId)

Clb_0MULTI1SIZE0WeaponDef

int Clb_0MULTI1SIZE0WeaponDef(int teamId)

Clb_0MULTI1FETCH3WeaponDefByName0WeaponDef

int Clb_0MULTI1FETCH3WeaponDefByName0WeaponDef(int teamId,
                                               String weaponDefName)

Clb_WeaponDef_getName

String Clb_WeaponDef_getName(int teamId,
                             int weaponDefId)

Clb_WeaponDef_getType

String Clb_WeaponDef_getType(int teamId,
                             int weaponDefId)

Clb_WeaponDef_getDescription

String Clb_WeaponDef_getDescription(int teamId,
                                    int weaponDefId)

Clb_WeaponDef_getFileName

String Clb_WeaponDef_getFileName(int teamId,
                                 int weaponDefId)

Clb_WeaponDef_getCegTag

String Clb_WeaponDef_getCegTag(int teamId,
                               int weaponDefId)

Clb_WeaponDef_getRange

float Clb_WeaponDef_getRange(int teamId,
                             int weaponDefId)

Clb_WeaponDef_getHeightMod

float Clb_WeaponDef_getHeightMod(int teamId,
                                 int weaponDefId)

Clb_WeaponDef_getAccuracy

float Clb_WeaponDef_getAccuracy(int teamId,
                                int weaponDefId)

Inaccuracy of whole burst

Clb_WeaponDef_getSprayAngle

float Clb_WeaponDef_getSprayAngle(int teamId,
                                  int weaponDefId)

Inaccuracy of individual shots inside burst

Clb_WeaponDef_getMovingAccuracy

float Clb_WeaponDef_getMovingAccuracy(int teamId,
                                      int weaponDefId)

Inaccuracy while owner moving

Clb_WeaponDef_getTargetMoveError

float Clb_WeaponDef_getTargetMoveError(int teamId,
                                       int weaponDefId)

Fraction of targets move speed that is used as error offset

Clb_WeaponDef_getLeadLimit

float Clb_WeaponDef_getLeadLimit(int teamId,
                                 int weaponDefId)

Maximum distance the weapon will lead the target

Clb_WeaponDef_getLeadBonus

float Clb_WeaponDef_getLeadBonus(int teamId,
                                 int weaponDefId)

Factor for increasing the leadLimit with experience

Clb_WeaponDef_getPredictBoost

float Clb_WeaponDef_getPredictBoost(int teamId,
                                    int weaponDefId)

Replaces hardcoded behaviour for burnblow cannons

Clb_WeaponDef_0STATIC0getNumDamageTypes

int Clb_WeaponDef_0STATIC0getNumDamageTypes(int teamId)

Clb_WeaponDef_Damage_getParalyzeDamageTime

int Clb_WeaponDef_Damage_getParalyzeDamageTime(int teamId,
                                               int weaponDefId)

Clb_WeaponDef_Damage_getImpulseFactor

float Clb_WeaponDef_Damage_getImpulseFactor(int teamId,
                                            int weaponDefId)

Clb_WeaponDef_Damage_getImpulseBoost

float Clb_WeaponDef_Damage_getImpulseBoost(int teamId,
                                           int weaponDefId)

Clb_WeaponDef_Damage_getCraterMult

float Clb_WeaponDef_Damage_getCraterMult(int teamId,
                                         int weaponDefId)

Clb_WeaponDef_Damage_getCraterBoost

float Clb_WeaponDef_Damage_getCraterBoost(int teamId,
                                          int weaponDefId)

Clb_WeaponDef_Damage_0ARRAY1SIZE0getTypes

int Clb_WeaponDef_Damage_0ARRAY1SIZE0getTypes(int teamId,
                                              int weaponDefId)

Clb_WeaponDef_Damage_0ARRAY1VALS0getTypes

int Clb_WeaponDef_Damage_0ARRAY1VALS0getTypes(int teamId,
                                              int weaponDefId,
                                              float[] types,
                                              int types_max)

Clb_WeaponDef_getAreaOfEffect

float Clb_WeaponDef_getAreaOfEffect(int teamId,
                                    int weaponDefId)

Clb_WeaponDef_isNoSelfDamage

boolean Clb_WeaponDef_isNoSelfDamage(int teamId,
                                     int weaponDefId)

Clb_WeaponDef_getFireStarter

float Clb_WeaponDef_getFireStarter(int teamId,
                                   int weaponDefId)

Clb_WeaponDef_getEdgeEffectiveness

float Clb_WeaponDef_getEdgeEffectiveness(int teamId,
                                         int weaponDefId)

Clb_WeaponDef_getSize

float Clb_WeaponDef_getSize(int teamId,
                            int weaponDefId)

Clb_WeaponDef_getSizeGrowth

float Clb_WeaponDef_getSizeGrowth(int teamId,
                                  int weaponDefId)

Clb_WeaponDef_getCollisionSize

float Clb_WeaponDef_getCollisionSize(int teamId,
                                     int weaponDefId)

Clb_WeaponDef_getSalvoSize

int Clb_WeaponDef_getSalvoSize(int teamId,
                               int weaponDefId)

Clb_WeaponDef_getSalvoDelay

float Clb_WeaponDef_getSalvoDelay(int teamId,
                                  int weaponDefId)

Clb_WeaponDef_getReload

float Clb_WeaponDef_getReload(int teamId,
                              int weaponDefId)

Clb_WeaponDef_getBeamTime

float Clb_WeaponDef_getBeamTime(int teamId,
                                int weaponDefId)

Clb_WeaponDef_isBeamBurst

boolean Clb_WeaponDef_isBeamBurst(int teamId,
                                  int weaponDefId)

Clb_WeaponDef_isWaterBounce

boolean Clb_WeaponDef_isWaterBounce(int teamId,
                                    int weaponDefId)

Clb_WeaponDef_isGroundBounce

boolean Clb_WeaponDef_isGroundBounce(int teamId,
                                     int weaponDefId)

Clb_WeaponDef_getBounceRebound

float Clb_WeaponDef_getBounceRebound(int teamId,
                                     int weaponDefId)

Clb_WeaponDef_getBounceSlip

float Clb_WeaponDef_getBounceSlip(int teamId,
                                  int weaponDefId)

Clb_WeaponDef_getNumBounce

int Clb_WeaponDef_getNumBounce(int teamId,
                               int weaponDefId)

Clb_WeaponDef_getMaxAngle

float Clb_WeaponDef_getMaxAngle(int teamId,
                                int weaponDefId)

Clb_WeaponDef_getRestTime

float Clb_WeaponDef_getRestTime(int teamId,
                                int weaponDefId)

Clb_WeaponDef_getUpTime

float Clb_WeaponDef_getUpTime(int teamId,
                              int weaponDefId)

Clb_WeaponDef_getFlightTime

int Clb_WeaponDef_getFlightTime(int teamId,
                                int weaponDefId)

Clb_WeaponDef_0REF1Resource2resourceId0getCost

float Clb_WeaponDef_0REF1Resource2resourceId0getCost(int teamId,
                                                     int weaponDefId,
                                                     int resourceId)

Clb_WeaponDef_getSupplyCost

float Clb_WeaponDef_getSupplyCost(int teamId,
                                  int weaponDefId)

Clb_WeaponDef_getProjectilesPerShot

int Clb_WeaponDef_getProjectilesPerShot(int teamId,
                                        int weaponDefId)

Clb_WeaponDef_isTurret

boolean Clb_WeaponDef_isTurret(int teamId,
                               int weaponDefId)

Clb_WeaponDef_isOnlyForward

boolean Clb_WeaponDef_isOnlyForward(int teamId,
                                    int weaponDefId)

Clb_WeaponDef_isFixedLauncher

boolean Clb_WeaponDef_isFixedLauncher(int teamId,
                                      int weaponDefId)

Clb_WeaponDef_isWaterWeapon

boolean Clb_WeaponDef_isWaterWeapon(int teamId,
                                    int weaponDefId)

Clb_WeaponDef_isFireSubmersed

boolean Clb_WeaponDef_isFireSubmersed(int teamId,
                                      int weaponDefId)

Clb_WeaponDef_isSubMissile

boolean Clb_WeaponDef_isSubMissile(int teamId,
                                   int weaponDefId)

Lets a torpedo travel above water like it does below water

Clb_WeaponDef_isTracks

boolean Clb_WeaponDef_isTracks(int teamId,
                               int weaponDefId)

Clb_WeaponDef_isDropped

boolean Clb_WeaponDef_isDropped(int teamId,
                                int weaponDefId)

Clb_WeaponDef_isParalyzer

boolean Clb_WeaponDef_isParalyzer(int teamId,
                                  int weaponDefId)

The weapon will only paralyze, not do real damage.

Clb_WeaponDef_isImpactOnly

boolean Clb_WeaponDef_isImpactOnly(int teamId,
                                   int weaponDefId)

The weapon damages by impacting, not by exploding.

Clb_WeaponDef_isNoAutoTarget

boolean Clb_WeaponDef_isNoAutoTarget(int teamId,
                                     int weaponDefId)

Can not target anything (for example: anti-nuke, D-Gun)

Clb_WeaponDef_isManualFire

boolean Clb_WeaponDef_isManualFire(int teamId,
                                   int weaponDefId)

Has to be fired manually (by the player or an AI, example: D-Gun)

Clb_WeaponDef_getInterceptor

int Clb_WeaponDef_getInterceptor(int teamId,
                                 int weaponDefId)

Can intercept targetable weapons shots. example: anti-nuke

See Also:: getTargetable()

Clb_WeaponDef_getTargetable

int Clb_WeaponDef_getTargetable(int teamId,
                                int weaponDefId)

Shoots interceptable projectiles. Shots can be intercepted by interceptors. example: nuke

See Also:: getInterceptor()

Clb_WeaponDef_isStockpileable

boolean Clb_WeaponDef_isStockpileable(int teamId,
                                      int weaponDefId)

Clb_WeaponDef_getCoverageRange

float Clb_WeaponDef_getCoverageRange(int teamId,
                                     int weaponDefId)

Range of interceptors. example: anti-nuke

See Also:: getInterceptor()

Clb_WeaponDef_getStockpileTime

float Clb_WeaponDef_getStockpileTime(int teamId,
                                     int weaponDefId)

Build time of a missile

Clb_WeaponDef_getIntensity

float Clb_WeaponDef_getIntensity(int teamId,
                                 int weaponDefId)

Clb_WeaponDef_getThickness

float Clb_WeaponDef_getThickness(int teamId,
                                 int weaponDefId)

Clb_WeaponDef_getLaserFlareSize

float Clb_WeaponDef_getLaserFlareSize(int teamId,
                                      int weaponDefId)

Clb_WeaponDef_getCoreThickness

float Clb_WeaponDef_getCoreThickness(int teamId,
                                     int weaponDefId)

Clb_WeaponDef_getDuration

float Clb_WeaponDef_getDuration(int teamId,
                                int weaponDefId)

Clb_WeaponDef_getLodDistance

int Clb_WeaponDef_getLodDistance(int teamId,
                                 int weaponDefId)

Clb_WeaponDef_getFalloffRate

float Clb_WeaponDef_getFalloffRate(int teamId,
                                   int weaponDefId)

Clb_WeaponDef_getGraphicsType

int Clb_WeaponDef_getGraphicsType(int teamId,
                                  int weaponDefId)

Clb_WeaponDef_isSoundTrigger

boolean Clb_WeaponDef_isSoundTrigger(int teamId,
                                     int weaponDefId)

Clb_WeaponDef_isSelfExplode

boolean Clb_WeaponDef_isSelfExplode(int teamId,
                                    int weaponDefId)

Clb_WeaponDef_isGravityAffected

boolean Clb_WeaponDef_isGravityAffected(int teamId,
                                        int weaponDefId)

Clb_WeaponDef_getHighTrajectory

int Clb_WeaponDef_getHighTrajectory(int teamId,
                                    int weaponDefId)

Per weapon high trajectory setting. UnitDef also has this property.

Returns:: 0: low 1: high 2: unit

Clb_WeaponDef_getMyGravity

float Clb_WeaponDef_getMyGravity(int teamId,
                                 int weaponDefId)

Clb_WeaponDef_isNoExplode

boolean Clb_WeaponDef_isNoExplode(int teamId,
                                  int weaponDefId)

Clb_WeaponDef_getStartVelocity

float Clb_WeaponDef_getStartVelocity(int teamId,
                                     int weaponDefId)

Clb_WeaponDef_getWeaponAcceleration

float Clb_WeaponDef_getWeaponAcceleration(int teamId,
                                          int weaponDefId)

Clb_WeaponDef_getTurnRate

float Clb_WeaponDef_getTurnRate(int teamId,
                                int weaponDefId)

Clb_WeaponDef_getMaxVelocity

float Clb_WeaponDef_getMaxVelocity(int teamId,
                                   int weaponDefId)

Clb_WeaponDef_getProjectileSpeed

float Clb_WeaponDef_getProjectileSpeed(int teamId,
                                       int weaponDefId)

Clb_WeaponDef_getExplosionSpeed

float Clb_WeaponDef_getExplosionSpeed(int teamId,
                                      int weaponDefId)

Clb_WeaponDef_getOnlyTargetCategory

int Clb_WeaponDef_getOnlyTargetCategory(int teamId,
                                        int weaponDefId)

Clb_WeaponDef_getWobble

float Clb_WeaponDef_getWobble(int teamId,
                              int weaponDefId)

How much the missile will wobble around its course.

Clb_WeaponDef_getDance

float Clb_WeaponDef_getDance(int teamId,
                             int weaponDefId)

How much the missile will dance.

Clb_WeaponDef_getTrajectoryHeight

float Clb_WeaponDef_getTrajectoryHeight(int teamId,
                                        int weaponDefId)

How high trajectory missiles will try to fly in.

Clb_WeaponDef_isLargeBeamLaser

boolean Clb_WeaponDef_isLargeBeamLaser(int teamId,
                                       int weaponDefId)

Clb_WeaponDef_isShield

boolean Clb_WeaponDef_isShield(int teamId,
                               int weaponDefId)

If the weapon is a shield rather than a weapon.

Clb_WeaponDef_isShieldRepulser

boolean Clb_WeaponDef_isShieldRepulser(int teamId,
                                       int weaponDefId)

If the weapon should be repulsed or absorbed.

Clb_WeaponDef_isSmartShield

boolean Clb_WeaponDef_isSmartShield(int teamId,
                                    int weaponDefId)

If the shield only affects enemy projectiles.

Clb_WeaponDef_isExteriorShield

boolean Clb_WeaponDef_isExteriorShield(int teamId,
                                       int weaponDefId)

If the shield only affects stuff coming from outside shield radius.

Clb_WeaponDef_isVisibleShield

boolean Clb_WeaponDef_isVisibleShield(int teamId,
                                      int weaponDefId)

If the shield should be graphically shown.

Clb_WeaponDef_isVisibleShieldRepulse

boolean Clb_WeaponDef_isVisibleShieldRepulse(int teamId,
                                             int weaponDefId)

If a small graphic should be shown at each repulse.

Clb_WeaponDef_getVisibleShieldHitFrames

int Clb_WeaponDef_getVisibleShieldHitFrames(int teamId,
                                            int weaponDefId)

The number of frames to draw the shield after it has been hit.

Clb_WeaponDef_Shield_0REF1Resource2resourceId0getResourceUse

float Clb_WeaponDef_Shield_0REF1Resource2resourceId0getResourceUse(int teamId,
                                                                   int weaponDefId,
                                                                   int resourceId)

Amount of the resource used per shot or per second, depending on the type of projectile.

Clb_WeaponDef_Shield_getRadius

float Clb_WeaponDef_Shield_getRadius(int teamId,
                                     int weaponDefId)

Size of shield covered area

Clb_WeaponDef_Shield_getForce

float Clb_WeaponDef_Shield_getForce(int teamId,
                                    int weaponDefId)

Shield acceleration on plasma stuff. How much will plasma be accelerated into the other direction when it hits the shield.

Clb_WeaponDef_Shield_getMaxSpeed

float Clb_WeaponDef_Shield_getMaxSpeed(int teamId,
                                       int weaponDefId)

Maximum speed to which the shield can repulse plasma.

Clb_WeaponDef_Shield_getPower

float Clb_WeaponDef_Shield_getPower(int teamId,
                                    int weaponDefId)

Amount of damage the shield can reflect. (0=infinite)

Clb_WeaponDef_Shield_getPowerRegen

float Clb_WeaponDef_Shield_getPowerRegen(int teamId,
                                         int weaponDefId)

Amount of power that is regenerated per second.

Clb_WeaponDef_Shield_0REF1Resource2resourceId0getPowerRegenResource

float Clb_WeaponDef_Shield_0REF1Resource2resourceId0getPowerRegenResource(int teamId,
                                                                          int weaponDefId,
                                                                          int resourceId)

How much of a given resource is needed to regenerate power with max speed per second.

Clb_WeaponDef_Shield_getStartingPower

float Clb_WeaponDef_Shield_getStartingPower(int teamId,
                                            int weaponDefId)

How much power the shield has when it is created.

Clb_WeaponDef_Shield_getRechargeDelay

int Clb_WeaponDef_Shield_getRechargeDelay(int teamId,
                                          int weaponDefId)

Number of frames to delay recharging by after each hit.

Clb_WeaponDef_Shield_getGoodColor

AIFloat3 Clb_WeaponDef_Shield_getGoodColor(int teamId,
                                           int weaponDefId)

The color of the shield when it is at full power.

Clb_WeaponDef_Shield_getBadColor

AIFloat3 Clb_WeaponDef_Shield_getBadColor(int teamId,
                                          int weaponDefId)

The color of the shield when it is empty.

Clb_WeaponDef_Shield_getAlpha

float Clb_WeaponDef_Shield_getAlpha(int teamId,
                                    int weaponDefId)

The shields alpha value.

Clb_WeaponDef_Shield_getInterceptType

int Clb_WeaponDef_Shield_getInterceptType(int teamId,
                                          int weaponDefId)

The type of the shield (bitfield). Defines what weapons can be intercepted by the shield.

See Also:: getInterceptedByShieldType()

Clb_WeaponDef_getInterceptedByShieldType

int Clb_WeaponDef_getInterceptedByShieldType(int teamId,
                                             int weaponDefId)

The type of shields that can intercept this weapon (bitfield). The weapon can be affected by shields if: (shield.getInterceptType() & weapon.getInterceptedByShieldType()) != 0

See Also:: getInterceptType()

Clb_WeaponDef_isAvoidFriendly

boolean Clb_WeaponDef_isAvoidFriendly(int teamId,
                                      int weaponDefId)

Tries to avoid friendly units while aiming?

Clb_WeaponDef_isAvoidFeature

boolean Clb_WeaponDef_isAvoidFeature(int teamId,
                                     int weaponDefId)

Tries to avoid features while aiming?

Clb_WeaponDef_isAvoidNeutral

boolean Clb_WeaponDef_isAvoidNeutral(int teamId,
                                     int weaponDefId)

Tries to avoid neutral units while aiming?

Clb_WeaponDef_getTargetBorder

float Clb_WeaponDef_getTargetBorder(int teamId,
                                    int weaponDefId)

If nonzero, targetting units will TryTarget at the edge of collision sphere (radius*tag value, [-1;1]) instead of its centre.

Clb_WeaponDef_getCylinderTargetting

float Clb_WeaponDef_getCylinderTargetting(int teamId,
                                          int weaponDefId)

If greater than 0, the range will be checked in a cylinder (height=range*cylinderTargetting) instead of a sphere.

Clb_WeaponDef_getMinIntensity

float Clb_WeaponDef_getMinIntensity(int teamId,
                                    int weaponDefId)

For beam-lasers only - always hit with some minimum intensity (a damage coeffcient normally dependent on distance). Do not confuse this with the intensity tag, it i completely unrelated.

Clb_WeaponDef_getHeightBoostFactor

float Clb_WeaponDef_getHeightBoostFactor(int teamId,
                                         int weaponDefId)

Controls cannon range height boost. default: -1: automatically calculate a more or less sane value

Clb_WeaponDef_getProximityPriority

float Clb_WeaponDef_getProximityPriority(int teamId,
                                         int weaponDefId)

Multiplier for the distance to the target for priority calculations.

Clb_WeaponDef_getCollisionFlags

int Clb_WeaponDef_getCollisionFlags(int teamId,
                                    int weaponDefId)

Clb_WeaponDef_isSweepFire

boolean Clb_WeaponDef_isSweepFire(int teamId,
                                  int weaponDefId)

Clb_WeaponDef_isAbleToAttackGround

boolean Clb_WeaponDef_isAbleToAttackGround(int teamId,
                                           int weaponDefId)

Clb_WeaponDef_getCameraShake

float Clb_WeaponDef_getCameraShake(int teamId,
                                   int weaponDefId)

Clb_WeaponDef_getDynDamageExp

float Clb_WeaponDef_getDynDamageExp(int teamId,
                                    int weaponDefId)

Clb_WeaponDef_getDynDamageMin

float Clb_WeaponDef_getDynDamageMin(int teamId,
                                    int weaponDefId)

Clb_WeaponDef_getDynDamageRange

float Clb_WeaponDef_getDynDamageRange(int teamId,
                                      int weaponDefId)

Clb_WeaponDef_isDynDamageInverted

boolean Clb_WeaponDef_isDynDamageInverted(int teamId,
                                          int weaponDefId)

Clb_WeaponDef_0MAP1SIZE0getCustomParams

int Clb_WeaponDef_0MAP1SIZE0getCustomParams(int teamId,
                                            int weaponDefId)

Clb_WeaponDef_0MAP1KEYS0getCustomParams

void Clb_WeaponDef_0MAP1KEYS0getCustomParams(int teamId,
                                             int weaponDefId,
                                             String[] keys)

Clb_WeaponDef_0MAP1VALS0getCustomParams

void Clb_WeaponDef_0MAP1VALS0getCustomParams(int teamId,
                                             int weaponDefId,
                                             String[] values)

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.springrts.ai Interface AICallback

Clb_Engine_handleCommand

Clb_Engine_Version_getMajor

Clb_Engine_Version_getMinor

Clb_Engine_Version_getPatchset

Clb_Engine_Version_getAdditional

Clb_Engine_Version_getBuildTime

Clb_Engine_Version_getNormal

Clb_Engine_Version_getFull

Clb_Teams_getSize

Clb_SkirmishAIs_getSize

Clb_SkirmishAIs_getMax

Clb_SkirmishAI_Info_getSize

Clb_SkirmishAI_Info_getKey

Clb_SkirmishAI_Info_getValue

Clb_SkirmishAI_Info_getDescription

Clb_SkirmishAI_Info_getValueByKey

Clb_SkirmishAI_OptionValues_getSize

Clb_SkirmishAI_OptionValues_getKey

Clb_SkirmishAI_OptionValues_getValue

Clb_SkirmishAI_OptionValues_getValueByKey

Clb_Log_log

Clb_Log_exception

Clb_DataDirs_getPathSeparator

Clb_DataDirs_getConfigDir

Clb_DataDirs_getWriteableDir

Clb_DataDirs_locatePath

Clb_DataDirs_allocatePath

Clb_DataDirs_Roots_getSize

Clb_DataDirs_Roots_getDir

Clb_DataDirs_Roots_locatePath

Clb_DataDirs_Roots_allocatePath

Clb_Game_getCurrentFrame

Clb_Game_getAiInterfaceVersion

Clb_Game_getMyTeam

Clb_Game_getMyAllyTeam

Clb_Game_getPlayerTeam

Clb_Game_getTeamSide

Clb_Game_isExceptionHandlingEnabled

Clb_Game_isDebugModeEnabled

Clb_Game_getMode

Clb_Game_isPaused

Clb_Game_getSpeedFactor

Clb_Game_getSetupScript

Clb_Gui_getViewRange

Clb_Gui_getScreenX

Clb_Gui_getScreenY

Clb_Gui_Camera_getDirection

Clb_Gui_Camera_getPosition

Clb_Cheats_isEnabled

Clb_Cheats_setEnabled

Clb_Cheats_setEventsEnabled

Clb_Cheats_isOnlyPassive

Clb_0MULTI1SIZE0Resource

Clb_0MULTI1FETCH3ResourceByName0Resource

Clb_Resource_getName

Clb_Resource_getOptimum

Clb_Economy_0REF1Resource2resourceId0getCurrent

Clb_Economy_0REF1Resource2resourceId0getIncome

Clb_Economy_0REF1Resource2resourceId0getUsage

Clb_Economy_0REF1Resource2resourceId0getStorage

Clb_File_getSize

Clb_File_getContent

Clb_0MULTI1SIZE0UnitDef

Clb_0MULTI1VALS0UnitDef

Clb_0MULTI1FETCH3UnitDefByName0UnitDef

Clb_UnitDef_getHeight

Clb_UnitDef_getRadius

Clb_UnitDef_isValid

Clb_UnitDef_getName

Clb_UnitDef_getHumanName

Clb_UnitDef_getFileName

Clb_UnitDef_getAiHint

Clb_UnitDef_getCobId

Clb_UnitDef_getTechLevel

Clb_UnitDef_getGaia

Clb_UnitDef_0REF1Resource2resourceId0getUpkeep

Clb_UnitDef_0REF1Resource2resourceId0getResourceMake

Clb_UnitDef_0REF1Resource2resourceId0getMakesResource

Clb_UnitDef_0REF1Resource2resourceId0getCost

com.springrts.ai
Interface AICallback