BF2 Console Commands

AnimationBundle

animationBundle.abruptPlayback bool -> bool: Unknown
animationBundle.addAnimation std::string -> void: Unknown
animationBundle.addEvent std::string -> void: Unknown
animationBundle.fadeInTime float -> float: Used in AnimationSystem1p and 3p .inc files; "Fade in: Animation Start. Allows a smooth transition between animations. The lower it is, the quicker it is. A high value makes the transition slower and longer. Fade in 0.01. Example: Idle/Walking to Sprinting"
animationBundle.fadeOutTime float -> float: Used in AnimationSystem1p and 3p .inc files; "Fade out: Animation End. Same as above, Fadeout 0.1. Fadeout 0.4 would make it take 0.4 seconds to finish an animation; example: From Sprinting to Walk/Idle"
animationBundle.getAnimationLength std::string -> float: Unknown
animationBundle.getAnimationStartTime std::string -> float: Unknown
animationBundle.getEventStartTime std::string -> float: Unknown
animationBundle.isLooping bool -> bool: Unknown
animationBundle.jumpToLastAnimationAtStop bool -> bool: Unknown
animationBundle.length float -> float: Unknown
animationBundle.listAnimations -> std::string: Unknown
animationBundle.listEvents -> std::string: Unknown
animationBundle.playBackward bool -> bool: Unknown
animationBundle.playForever bool -> bool: Unknown
animationBundle.removeAnimation std::string -> void: Unknown
animationBundle.removeEvent std::string -> void: Unknown
animationBundle.setAnimationLength std::string float -> void: Unknown
animationBundle.setAnimationStartTime std::string float -> void: Unknown
animationBundle.setEventStartTime std::string float -> void: Unknown
animationBundle.useSpeedAsTime bool -> bool: Unknown

AnimationManager

animationManager.fadeInTime float -> float: Unknown
animationManager.ignoreMotherOrientation int -> int: Unknown
animationManager.length float -> float: "AnimationSystem1p, AnimationSystem3p.inc"; "The length of the animation. Must match up with ObjectTemplate.ammo.reloadTime to sync. If it's a lower value, animation will be sped up. If it's a higher value, animation will be slowed down."
animationManager.looping bool -> bool: "AnimationSystem1p, AnimationSystem3p.inc"
animationManager.noiceAmplitude float -> float: Unknown
animationManager.noiceFreq int -> int: Unknown
animationManager.originalLength -> float: Unknown

AnimationSystem

animationSystem.activestd::string -> std::string: Unknown
animationSystem.activeAnimation std::string -> std::string: Unknown
animationSystem.activeBundle std::string -> std::string: Unknown
animationSystem.activeTrigger std::string -> std::string: Unknown
animationSystem.activeValueHolder std::string -> std::string: Unknown
animationSystem.cameraSpring.amplitude Vec3 -> Vec3: Unknown
animationSystem.cameraSpring.fire Vec3 -> Vec3: Unknown
animationSystem.cameraSpring.hit Vec3 -> Vec3: Unknown
animationSystem.cameraSpring.look Vec2 -> Vec2: Unknown
animationSystem.cameraSpring.move Vec3 -> Vec3: Unknown
animationSystem.cameraSpring.stiffness Vec3 -> Vec3: Unknown
animationSystem.cameraSpring.use bool -> bool: Unknown
animationSystem.cameraSpring.zoomDamping Vec3 -> Vec3: Unknown
animationSystem.create std::string -> void: Unknown
animationSystem.createAnimation std::string -> anim.BoneAnimation*: Unknown
animationSystem.createBundle std::string -> anim.Bundle*: Unknown
animationSystem.createTrigger std::string std::string -> anim.Trigger*: Unknown
animationSystem.createValueHolder std::string -> void: Unknown
animationSystem.deleteActiveBundle -> void: Unknown
animationSystem.deleteActiveTrigger -> void: Unknown
animationSystem.hide -> void: Unknown
animationSystem.list -> std::string: Unknown
animationSystem.listAnimations -> std::string: Unknown
animationSystem.listBundles -> std::string: Unknown
animationSystem.listTriggers -> std::string: Unknown
AnimationSystem.listTriggerTypes -> std::string: Unknown
animationSystem.listValueHolders -> std::string: Unknown
animationSystem.playbackModifier float -> float: Unknown
animationSystem.reloadScript -> void: Unknown
animationSystem.save std::string -> void: Unknown
animationSystem.saveActive -> void: Unknown
animationSystem.saveValueHolders -> void: Unknown

animationTrigger

animationTrigger.addBundle std::string -> void: Unknown
animationTrigger.addChild std::string -> void: Unknown
animationTrigger.clearValueHolder -> void: Unknown
animationTrigger.fadeInTime float -> float: Unknown
animationTrigger.getTypeName -> std::string: Unknown
animationTrigger.idleTime Vec2 -> Vec2: Unknown
animationTrigger.listBundles -> std::string: Unknown
animationTrigger.message int -> int: Unknown
animationTrigger.removeBundle std::string -> void: Unknown
animationTrigger.removeChild std::string -> void: Unknown
animationTrigger.triggerOnAcceleration bool -> bool: Unknown
animationTrigger.useDirection bool -> bool: Unknown
animationTrigger.valueHolder std::string -> std::string: Unknown

animationValueHolder

animationValueHolder.getFilename -> std::string: Unknown
animationValueHolder.max float -> float: Unknown
animationValueHolder.min float -> float: Unknown
animationValueHolder.normal float -> float: Unknown
animationValueHolder.passOnMessage unsigned int -> unsigned int: Unknown
animationValueHolder.stopOnMessage unsigned int -> unsigned int: Unknown
animationValueHolder.values float float float -> void: Unknown

audioSettings

audioSettings.alwaysAllowSystemOpenAL bool -> bool: Unknown
audioSettings.effectsVolume float -> float: Unknown
audioSettings.enableEAX bool -> bool: Unknown
audioSettings.englishOnlyVoices bool -> bool: Unknown
audioSettings.forceNumberOfVoices int -> int: Unknown
audioSettings.helpVoiceVolume float -> float: Unknown
audioSettings.musicVolume float -> float: Unknown
audioSettings.provider std::string -> std::string: Unknown
audioSettings.soundQuality std::string -> std::string: Unknown
audioSettings.voipBoostEnabled bool -> bool: Unknown
audioSettings.voipCaptureThreshold float -> float: Unknown
audioSettings.voipCaptureVolume float -> float: Unknown
audioSettings.voipEnabled bool -> bool: Unknown
audioSettings.voipPlaybackVolume float -> float: Unknown
audioSettings.voipUsePushToTalk bool -> bool: Unknown
bf2Engine.playMovie std::string int -> void: Unknown
chat.sayAll std::string -> void: Menu (Hud Elements Chat.con); All Chat. Used in HudElementsChat.con
chat.sayTeam std::string -> void: Menu (Hud Elements Chat.con); Team Chat. Used in HudElementsChat.con
CollisionCheck.checkStaticCollisionMeshes int -> void: Unknown

collisionManager

collisionManager.buildDebugCollisionMeshes -> void: Unknown
collisionManager.create std::string -> void: Unknown
collisionManager.createTemplate std::string -> void: Used in .con files for collision meshes; Creates a Collision Mesh template from the collision mesh name so it can be used in other files without creating a duplicate mesh
collisionManager.drawBoundingBoxes bool -> void: Unknown
collisionManager.drawForces bool -> void: Unknown
collisionManager.drawIntersectFaces bool -> void: Unknown
collisionManager.drawMeshes bool -> void: Unknown
collisionManager.drawNormals bool -> void: Unknown
collisionManager.drawOnlyRoot float -> void: Unknown
collisionManager.drawPivots bool -> void: Unknown
collisionManager.drawPrimitives bool -> void: Unknown
collisionManager.drawSoldierMesh bool -> void: Unknown
collisionManager.drawTestedFaces bool -> void: Unknown
collisionManager.getNameOfObjectInFocus -> void: Unknown
collisionManager.identityRotateObjectInFocus -> void: Unknown
collisionManager.rotateObjectInFocusAroundAxis uint float -> void: Unknown
collisionManager.rotateObjectInFocusAroundVector Vec3 float -> void: Unknown
collisionManager.setActiveLod int -> void: Unknown
collisionManager.setDrawDistance float -> void: Unknown
collisionManager.setGeometry bool -> void: Unknown
collisionManager.setSleepinessOfObjectInFocus int -> void: .con presumably; Effect Unknown. Causes a game crash during loading when using collisionManager.setSleepinessOfObjectInFocus 0 in a .con of a GenericFirearm
collisionManager.updateFlagsOfObjectInFocus U32 U32 -> void: Unknown
collisionManager.useDeferredLoading bool -> bool: Unknown

combatArea

combatArea.active std::string -> void: Unknown
combatArea.addAreaPoint Vec2 -> void: Unknown
combatArea.create std::string -> void: Unknown
combatArea.deleteActiveCombatArea -> void: Unknown
combatArea.getActiveCombatAreaName -> std::string: Unknown
combatArea.inverted bool -> bool: Unknown
combatArea.layer int -> int: Unknown
combatAreaManager.addVehicleDamage world: :VehicleCategory float -> void; Unknown
combatAreaManager.addVehicleTimer world: :VehicleCategory float -> void; Unknown
combatAreaManager.damage float -> float: Unknown
combatAreaManager.timeAllowedOutside float -> float: Unknown
combatAreaManager.use bool -> void: Unknown
combatArea.max Vec2 -> Vec2: Unknown
combatArea.min Vec2 -> Vec2: Unknown
combatArea.team int -> int: Unknown
combatArea.usedByPathFinding bool -> bool: Unknown
combatArea.vehicles int -> int: Controls what kind of vehicle is effected by the combat zone. This can be used for crating an extra large, separate combat zone around the base combat zone only for jets, to give them a much larger area to fly in and when you hop into a jet, you can still see the base combat zone, but the area between the base and the jet combat zone will be 1/2 transparent. When hand coding this the values are:; VehicleType "0" = Land; VehicleType "1" = Sea; VehicleType "2" = Planes; VehicleType "3" = Choppers; VehicleType "4" = All; VehicleType "5" = Planes & Choppers

commander

commander.accept bool -> void: Unknown
commander.artillery -> void: Unknown
commander.commanderApply -> void: Unknown
commander.commanderMutiny -> void: Unknown
commander.commanderResign -> void: Unknown
commander.satellite -> bool: Unknown
commander.sendOrder int bool -> void: Unknown
commander.supplies -> bool: Unknown
commander.toggleArtilleryState -> void: Unknown
commander.toggleSupplyState -> void: Unknown
commander.toggleUAVState -> void: Unknown
commander.toggleVehicleDropState -> void: Unknown
commander.uav -> bool: Unknown
commander.vehicleDrop -> bool: Unknown
commander.zoomCommander -> bool: Unknown

commanderInterface

commanderInterface.selectOrder std::string -> bool: Unknown
commanderInterface.setstd::stringMap std::string std::string std::string -> void: Unknown

commanderMenu

commanderMenu.deselect -> void: Unknown
commanderMenu.doubleClick -> void: Unknown
commanderMenu.rightClick -> void: Unknown
commanderMenu.sendRadioMessage std::string TargetChannel -> void: Unknown
commanderMenu.singleClick -> void: Unknown
commanderMenu.vehicleDropReloadTime float -> float: Unknown

Console

Console.allowMultipleFileLoad bool -> bool: Unknown
Console.bindKeyToConsoleScript int std::string -> bool: Unknown
Console.echo bool -> bool: Unknown
Console.echoErrors bool -> bool: Unknown
Console.getActiveMethods std::string -> std::string: Unknown
Console.getArgumentTypes std::string std::string -> std::string: Unknown
Console.getCategory std::string std::string -> std::string: Unknown
Console.getDelta std::string std::string -> std::string: Unknown
Console.getEnumName std::string std::string int -> std::string: Unknown
Console.getRange std::string std::string -> std::string: Unknown
Console.getReturnType std::string std::string -> std::string: Unknown
Console.getTypeDescription std::string std::string -> std::string: Unknown
Console.hasBundledType std::string std::string -> std::string: Unknown
Console.hasRange std::string std::string -> std::string: Unknown
Console.isDynamic std::string std::string -> std::string: Unknown
Console.isSetGet std::string std::string -> std::string: Unknown
Console.listConstants std::string -> std::string: Unknown
Console.listVariables std::string -> std::string: Unknown
Console.maxCommandHistorySize int -> int: Unknown
Console.maxHistorySize int -> int: Unknown
Console.maxLineSize int -> int: Unknown
Console.run std::string std::string std::string -> std::string: Unknown
Console.useRelativePaths bool -> bool: Unknown
Console.workingPath std::string -> std::string: Unknown

controlMap

controlMap.addAxisToAxisMapping int InputDeviceFlags InputDeviceAxes -> void: Unknown
controlMap.addAxisToTriggerMapping int int InputDeviceFlags -> void: Unknown
controlMap.addButtonAndKeyToAxisMapping int InputDeviceFlags InputDeviceButtons -> void: Unknown
controlMap.addButtonsToAxisMapping int InputDeviceFlags InputDeviceButtons -> void: Unknown
controlMap.addButtonToTriggerMapping int InputDeviceFlags InputDeviceButtons -> void: Unknown
controlMap.addKeyAndButtonToAxisMapping int InputDeviceFlags InputDeviceKeys -> void: Unknown
controlMap.addKeysToAxisMapping int InputDeviceFlags InputDeviceKeys -> void: Unknown
controlMap.AddKeyToTriggerMapping int InputDeviceFlags InputDeviceKeys -> void: Unknown
controlMap.create std::string -> void: Unknown
controlMap.deleteControlMap std::string -> void: Unknown
controlMap.dump -> void: Unknown
controlMap.InvertMouse bool -> bool: Unknown
controlMap.keyboardSensitivity float -> float: Unknown
controlMap.mouseSensitivity float -> float: Unknown
controlMap.setActive std::string -> void: Unknown
controlMap.setAxisScale io: :InputDeviceAxes float -> void; Unknown
controlMap.setButtonFallTime float -> void: Unknown
controlMap.setButtonRiseTime float -> void: Unknown
controlMap.setDoubleTapTime float -> void: Unknown
controlMap.setPitchFactor float -> void: Unknown
controlMap.setYawFactor float -> void: Unknown

DecalManager

decalManager.decalGeomClipAngle float -> float: Unknown
decalManager.decalNormalOffset float -> float: Unknown
decalManager.drawStats bool -> bool: Unknown
decalManager.fadeDistance float -> float: Set the View Distance of the Decals to start to fade. Works in level .con files
decalManager.fadeOutAtPercentageOfTimeToLive float -> float: Unknown
decalManager.generateTexture -> bool: Unknown
decalManager.startFadePercentageOfFadeDistancel float -> float: Unknown
decalManager.timeToLive float -> float: "Time in seconds of how long will a vehicle, effect or projectile will last. For vehicles, if it has been exited for a time, it will blow up. Uses CRD Arguments. More info: http://bfmods.com/mdt/scripting/ObjectTemplate/Properties/TimeToLive.html"
demo.recordDemo std::string -> void: "Starts the Battlerecorder Recording. Needs to specify a name. File is saved in mods/(mod)/Demos. In My Documents/Project Reality/Profile/001 (i.e 002, 003, default) create a demos folder and place both files there."

demo

demo.restartDemo -> void: Unknown
demo.shutdownDemo -> void: Unknown
demo.stopRecording -> void: Console ~ Command; Stops the Battlerecorder Recording. File is saved in mods/(mod)/Demos. In My Documents/Battlefield 2/Profile/001 etc create a demos folder and place both files there.
demo.toggleCameraDemo -> void: Unknown
demo.toggleDemoPauseOrPlay -> void: Unknown
demo.togglePlayerDemo bool -> void: Unknown

Editor

Editor.createNewLayer std::string -> void: Unknown
Editor.deleteAllLayers -> void: Unknown
Editor.deleteAllObjects -> std::string: Unknown
Editor.deleteObject world: :IObject_ptrproxy -> void; Unknown
Editor.deleteTemplate world: :IObjectTemplate_ptrproxy -> void; Unknown
Editor.getActiveLayer -> std::string: Unknown
Editor.getActiveLayerId -> int: Unknown
Editor.getActiveObject -> world: :IObject_ptrproxy; Unknown
Editor.getActiveObjectTemplate -> world: :IObjectTemplate_ptrproxy; Unknown
Editor.hideLayer std::string -> void: Unknown
Editor.listAllVehicles -> std::string: Unknown
Editor.listLayers -> std::string: Unknown
Editor.listMeshes -> std::string: Unknown
Editor.listObjects -> std::string: Unknown
Editor.listObjectsOfTemplate world: :IObjectTemplate_ptrproxy -> std::string; Unknown
Editor.listTemplates std::string -> std::string: Unknown
Editor.listTextures -> std::string: Unknown
Editor.loadAllObjects std::string -> bool: Unknown
Editor.loadAllTemplatesAndObjects -> bool: Unknown
Editor.printObjectCreationScript world: :IObject_ptrproxy -> std::string; Unknown
Editor.printTemplateCreationScript world: :IObjectTemplate_ptrproxy -> std::string; Unknown
Editor.quickReloadActiveTemplate -> void: Unknown
Editor.quickReloadTemplate world: :IObjectTemplate_ptrproxy -> void; Unknown
Editor.removeLayer std::string -> void: Unknown
Editor.renameLayer std::string std::string -> void: Unknown
Editor.saveAllEffects -> void: Unknown
Editor.saveAllObjects std::string -> bool: Unknown
Editor.saveAllSpawners -> bool: Unknown
Editor.saveAllTemplates -> bool: Unknown
Editor.saveAllTemplatesAndObjects -> bool: Unknown
Editor.saveAllUsedTemplates std::string -> bool: Unknown
Editor.saveFolderToArchive std::string bool bool -> int: Unknown
Editor.saveSpawners bool bool bool -> void: Unknown
Editor.saveTemplateToFile std::string std::string -> bool: Unknown
Editor.saveTemplateTreeStructure std::string std::string -> int: Unknown
Editor.saveVehicles bool -> bool: Unknown
Editor.setActiveLayer std::string -> void: Unknown
Editor.setActiveLayerId int -> void: Unknown
Editor.setActiveObject world: :IObject_ptrproxy -> world::IObject_ptrproxy; Unknown
Editor.setActiveObjectTemplate world: :IObjectTemplate_ptrproxy -> world::IObjectTemplate_ptrproxy; Unknown
Editor.ShowEntryPoints bool -> bool: Unknown
Editor.showLayer std::string -> void: Unknown
Editor.start world: :IObject_ptrproxy -> void; Unknown
Editor.stop world: :IObject_ptrproxy -> void; Unknown
Editor.updateAllTemplates -> void: Unknown
Editor.updateTemplate world: :IObjectTemplate_ptrproxy -> void; Unknown

effectTweak

effectTweak.setAgeScaleFactorForAllEffects float -> void: Unknown
effectTweak.setAlphaIntensityForAllEffects float -> void: Unknown
effectTweak.setEmitScaleFactorForAllEffects float -> void: Unknown
effectTweak.setEmitSpeedScaleFactorForAllEffects float -> void: Unknown
effectTweak.setSoundIntensity float -> void: Unknown
effectTweak.setStartAgeForAllEffects float -> void: Unknown
envmapManager.generateEnvMaps -> void: Unknown
envmapManager.loadEMIFile std::string -> void: Unknown
envmapManager.perPixelEnvironmentMappingEnabled bool -> bool: Unknown
envmapManager.save -> void: Unknown
fileManager.addPath std::string -> void: Unknown
fileManager.copyFile std::string std::string -> bool: Unknown
fileManager.deleteFile std::string -> bool: Unknown
fileManager.fileExists std::string -> bool: Unknown
fileManager.mountArchive std::string std::string bool -> void: Unknown
fileManager.moveFile std::string std::string -> bool: Unknown
game.allowToggleFullscreen bool -> bool: Unknown
game.lockFps int -> int: Sets a fps cap, makes it so that the fps can't go higher than the given number.

gameLogic

gameLogic.AddInvalidDropVehicleObject std::string bool -> void: Unknown
gameLogic.becomeSquadLeader bool -> bool: Unknown
gameLogic.createObject std::string -> void: Unknown
gameLogic.damageForBeingOutSideWorld float -> float: Unknown
gameLogic.defaultLevel std::string -> std::string: Unknown
gameLogic.defaultTimeToNextAIWave float -> float: Unknown
gameLogic.enableVoHelp bool -> bool

: :"Enables the Voice Over Tips feature from vBF2. Uses prhelp.utxt in localization for std::strings/anything with HUD_HELP definitions : HudElementsHelp.con in Menu for the size : color : fade in time : create more messages and VoiceMessages_Help.con for voiceovers"

gameLogic.extraUAVVehicleFlightHeight float -> float: Unknown
gameLogic.feslEnvironment int -> int: Unknown
gameLogic.getBeforeSpawnCameraDirection -> Vec3: Unknown
gameLogic.getBeforeSpawnCameraPosition -> Vec3: Unknown
gameLogic.getDefaultNumberOfTickets U32 -> U32: Unknown
gameLogic.getDefaultNumberOfTicketsEx U32 U32 -> U32: Unknown
gameLogic.getNumberOfTickets U32 -> U32: Unknown
gameLogic.getTeamDropVehicle int -> std::string: Unknown
gameLogic.getTeamLanguage int -> std::string: Unknown
gameLogic.getTeamName int -> std::string: Unknown
gameLogic.getTicketLossAtEndPerMin -> float: Unknown
gameLogic.getTicketLossPerMin U32 -> float: Unknown
gameLogic.hitIndicationThreshold float -> float: Unknown
gameLogic.maximumLevelViewDistance float -> float: Unknown
gameLogic.messages.addHelpMessage std::string std::string -> int: Unknown
gameLogic.messages.addMessage std::string -> int: Unknown
gameLogic.messages.addRadioFilter std::string std::string -> int: Unknown
gameLogic.messages.addRadioVoice std::string std::string std::string -> int: Unknown
gameLogic.messages.playHelpMessage std::string -> int: Unknown
gameLogic.messages.playRadioMessage int std::string std::string -> int: Unknown
gameLogic.messages.setVolumes float float -> void: Unknown
gameLogic.noVehiclesOmit std::string -> void: Unknown
gameLogic.outputPlayerStats bool -> bool: Unknown
gameLogic.printCameraCoordToConsole -> void: Unknown
gameLogic.refreshTriggerables -> void: Unknown
gameLogic.remoteCommand int int int -> bool: Unknown
gameLogic.reset -> void: Unknown
gameLogic.roundNr int -> int: Unknown
gameLogic.setAirMouseInverted bool -> void: Unknown
gameLogic.setAirMouseSensitivity float -> float: Unknown
gameLogic.setBeforeSpawnCamera Vec3 Vec3 -> void: Unknown
gameLogic.setDefaultNumberOfTickets U32 U32 -> void: Unknown
gameLogic.setDefaultNumberOfTicketsEx U32 U32 U32 -> void: Unknown
gameLogic.setDropVehicleDeviationRadius int int -> void: Unknown
gameLogic.setKit int KitType std::string -> void: Unknown
gameLogic.setNumberOfTickets U32 U32 -> void: Unknown
gameLogic.setNumDropVehiclesForTeam int int -> void: Unknown
gameLogic.setTeamDropVehicle int std::string -> void: Unknown
gameLogic.setTeamFlag int std::string -> void: Unknown
gameLogic.setTeamLanguage int std::string -> void: Unknown
gameLogic.setTeamName int std::string -> void: Unknown
gameLogic.setTicketLossAtEndPerMin float -> void: Unknown
gameLogic.setTicketLossPerMin U32 float -> void: Unknown
gameLogic.spawnAtCameraPosition bool -> bool: Unknown
gameLogic.spawnObjectSpeed float -> float: Unknown
gameLogic.spawnPlayers bool -> bool: Unknown
gameLogic.supplyDropHeight float -> float: Unknown
gameLogic.supplyDropNumSecsToLive float -> float: Unknown
gameLogic.teleport -> void: Unknown
gameLogic.teleportCameraTo Vec3 -> void: Unknown
gameLogic.teleportTo Vec3 -> void: Unknown
gameLogic.timeAllowedOutSideWorld float -> float: Unknown
gameLogic.timeToNextAIWave float -> float: Unknown
gameLogic.togglePause -> void

:Console ~ Command :Pauses the game. Pressing 'P' in COOP and Local does the same thing.

gameLogic.vehicleDropHeight float -> float: Unknown
Game.radioMessage TargetChannel std::string -> void: Unknown
game.sayAll std::string -> void: Unknown
game.sayTeam int std::string -> void: Unknown

gameServerSettings

gameServerSettings.setAdminScript std::string -> void: Unknown
gameServerSettings.setAllowNATNegotation bool -> void: Unknown
gameServerSettings.setAutoBalanceTeam bool -> void: Unknown
gameServerSettings.setAutoRecord bool -> void: Unknown
gameServerSettings.setAutoRecordRounds int -> void: Unknown
gameServerSettings.setCommunityLogoURL std::string -> void: Unknown
gameServerSettings.setCoopBotCount int -> void: Unknown
gameServerSettings.setCoopBotDifficulty float -> void: Unknown
gameServerSettings.setCoopBotRatio float -> void: Unknown
gameServerSettings.setDemoDownloadURL std::string -> void: Unknown
gameServerSettings.setDemoHook std::string -> void: Unknown
gameServerSettings.setDemoIndexURL std::string -> void: Unknown
gameServerSettings.setEndDelay int -> void: Unknown
gameServerSettings.setFriendlyFireWithMines bool -> void: Unknown
gameServerSettings.setGameMode std::string -> void: Unknown
gameServerSettings.setGameSpyPort int -> void: Unknown
gameServerSettings.setInterfaceIP std::string -> void: Unknown
gameServerSettings.setInternet bool -> void: Unknown
gameServerSettings.setManDownTime float -> void: Unknown
gameServerSettings.setMaxPlayers int -> void: Unknown
gameServerSettings.setMinPlayersForVoting int -> void: Unknown
gameServerSettings.setNoVehicles float -> void: Unknown
gameServerSettings.setPassword std::string -> void: Unknown
gameServerSettings.setPunishTeamKills bool -> void: Unknown
gameServerSettings.setRoundsPerMap int -> void: Unknown
gameServerSettings.setScoreLimit int -> void: Unknown
gameServerSettings.setServerName std::string -> void: Unknown
gameServerSettings.setSoldierFF int -> void: Unknown
gameServerSettings.setSoldierSplashFF int -> void: Unknown
gameServerSettings.setSpawnTime float -> void: Unknown
gameServerSettings.setSponsorLogoURL std::string -> void: Unknown
gameServerSettings.setSponsorText std::string -> void: Unknown
gameServerSettings.setStartDelay int -> void: Unknown
gameServerSettings.setSvPunkBuster bool -> void: Unknown
gameServerSettings.setTeamRatio float -> void: Unknown
gameServerSettings.setTeamVoteOnly bool -> void: Unknown
gameServerSettings.setTicketRatio int -> void: Unknown
gameServerSettings.setTimeBeforeRestartMap float -> void: Unknown
gameServerSettings.setTimeLimit int -> void: Unknown
gameServerSettings.setVehicleFF int -> void: Unknown
gameServerSettings.setVehicleSplashFF int -> void: Unknown
gameServerSettings.setVoipBFClientPort int -> void: Unknown
gameServerSettings.setVoipBFServerPort int -> void: Unknown
gameServerSettings.setVoipEnabled bool -> void: Unknown
gameServerSettings.setVoipQuality int -> void: Unknown
gameServerSettings.setVoipServerPort int -> void: Unknown
gameServerSettings.setVoipServerRemote bool -> void: Unknown
gameServerSettings.setVoipServerRemoteIP std::string -> void: Unknown
gameServerSettings.setVoipSharedPassword std::string -> void: Unknown
gameServerSettings.setVoteTime int -> void: Unknown
game.simulationRate int -> int

:HudElementsDemoRecComm.con :"In Battlerecorder : it sets the speed for the decrease speed and increase speed buttons. Can be increased : though some users report no difference as it is dependent on the Demo FPS (Default is 30 : settings must be recorded higher : something like 60) and Game FPS"

game.toggleFullscreen -> void

:~ Console :"Toggles Full-Screen and Windowed mode : though it will give you the nasty side-effect of seethrough terrain that would need the client to disconnect and reconnect to fix."

game.unload -> bool: Unknown

generalSettings

generalSettings.addFavouriteServer std::string int std::string -> void: Unknown
generalSettings.addServerHistory std::string int std::string -> void: Unknown
generalSettings.setAllowPunkBuster bool -> void: Unknown
generalSettings.setAutoReady bool -> void: Unknown
generalSettings.setAutoReload bool -> void: Unknown
generalSettings.setBFTVSaveDirectory std::string -> void: Unknown
generalSettings.setBotSkill float -> void: Unknown
generalSettings.setBuddytagColor int int int -> void: Unknown
generalSettings.setConfirmQuit bool -> void: Unknown
generalSettings.setConnectionType int -> void: Unknown
generalSettings.setCrosshairColor int int int -> void: Unknown
generalSettings.setHUDTransparency float -> void: Unknown
generalSettings.setItemSelectionReverseItems bool -> void: Unknown
generalSettings.setLCDDisplayModes bool -> void: Unknown
generalSettings.setMapIconAlphaTransparency float -> void: Unknown
generalSettings.setMaxBots int -> void: Unknown
generalSettings.setMaxBotsIncludeHumans bool -> void: Unknown
generalSettings.setMinimapRotate bool -> void: Unknown
generalSettings.setMinimapTransparency float -> void: Unknown
generalSettings.setNumRoundsPlayed int -> void: Unknown
generalSettings.setOutOfVoting bool -> void: Unknown
generalSettings.setPlayedVOHelp std::string -> void: Unknown
generalSettings.setServerFilter std::string -> void: Unknown
generalSettings.setSortKey std::string -> void: Unknown
generalSettings.setSortOrder int -> void: Unknown
generalSettings.setSquadtagColor int int int -> void: Unknown
generalSettings.setToggleFilters int -> void: Unknown
generalSettings.setUseAdvancedServerBrowser bool -> void: Unknown
generalSettings.setUseBots bool -> void: Unknown
generalSettings.setViewIntroMovie bool -> void: Unknown

geometryTemplate

geometryTemplate.active IGeometryTemplate* -> IGeometryTemplate*: Unknown
geometryTemplate.color Vec3 -> Vec3: Unknown
geometryTemplate.compressVertexData bool -> bool: Unknown
GeometryTemplate.create std::string std::string -> IGeometryTemplate*

:Used in .con files :Creates a Geometry Mesh template from the geometry mesh name so it can be used in other files without creating a duplicate mesh

geometryTemplate.depth float -> float: Unknown
geometryTemplate.doNotGenerateLightmaps bool -> bool: Unknown
geometryTemplate.dumpInstances -> void: Unknown
geometryTemplate.glowFadeOutDistEnd float -> float: Unknown
geometryTemplate.glowFadeOutDistStart float -> float: Unknown
geometryTemplate.glowing bool -> bool: Unknown
geometryTemplate.height float -> float: Unknown
geometryTemplate.ignoreLeafLighting bool -> bool: Unknown
geometryTemplate.innerRadius float -> float: Unknown
geometryTemplate.lenght float -> float: Unknown
geometryTemplate.length float -> float: Unknown
geometryTemplate.lightmapOverride bool -> bool: Unknown
geometryTemplate.maxSkip3pLods uint -> uint: Unknown
geometryTemplate.maxSkipWreckLods uint -> uint: Unknown
geometryTemplate.maxTextureRepeat int -> int: Unknown
geometryTemplate.meshDetailLevel int -> int: Unknown
geometryTemplate.name -> std::string: Unknown
geometryTemplate.noLighting bool -> bool: Unknown
geometryTemplate.nrOfAnimatedUVMatrix int -> int: Unknown
geometryTemplate.outerRadius float -> float: Unknown
GeometryTemplate.printInfo bool -> std::string: Unknown
geometryTemplate.radius1 float -> float: Unknown
geometryTemplate.radius2 float -> float: Unknown
geometryTemplate.rings uint -> uint: Unknown
geometryTemplate.setLightmapSizeAll int int int -> void: Unknown
geometryTemplate.setMaterialParallaxHeightScale int int int -> void: Unknown
geometryTemplate.setMaterialReflectionScale int int int -> void: Unknown
geometryTemplate.setSpecularStaticGloss int int int -> void: Unknown
geometryTemplate.setSubGeometryLodDistance int int float -> void: Unknown
geometryTemplate.shader std::string -> std::string: Unknown
geometryTemplate.shadowDetailLevel int -> int: Unknown
geometryTemplate.sides uint -> uint: Unknown
geometryTemplate.slices uint -> uint: Unknown
geometryTemplate.stacks uint -> uint: Unknown
geometryTemplate.tesselation BaseVector2<uint> -> BaseVector2<uint>: Unknown
geometryTemplate.texture std::string -> std::string: Unknown
geometryTemplate.useRadiusForShadowDepth bool -> bool: Unknown
geometryTemplate.useRadiusForShadowSpatial bool -> bool: Unknown
geometryTemplate.width float -> float: Unknown

globalSettings

globalSettings.setDefaultUser std::string -> void: Unknown
globalSettings.setNamePrefix std::string -> void: Unknown

hapticSettings

hapticSettings.addWeaponClassMap std::string int -> void: Unknown
hapticSettings.load -> bool: Unknown
hapticSettings.setAimSensitivity float float float -> void: Unknown
hapticSettings.setAimSensitivityAIR float float float -> void: Unknown
hapticSettings.setAimSensitivityHELI float float float -> void: Unknown
hapticSettings.setAimSensitivityLAND float float float -> void: Unknown
hapticSettings.setAimSensitivityLength float float float -> void: Unknown
hapticSettings.setAimSensitivityLengthAIR float float float -> void: Unknown
hapticSettings.setAimSensitivityLengthHELI float float float -> void: Unknown
hapticSettings.setAimSensitivityLengthLAND float float float -> void: Unknown
hapticSettings.setAimSensitivityLengthSEA float float float -> void: Unknown
hapticSettings.setAimSensitivityLengthSOLDIER float float float -> void: Unknown
hapticSettings.setAimSensitivitySEA float float float -> void: Unknown
hapticSettings.setAimSensitivitySOLDIER float float float -> void: Unknown
hapticSettings.setControlBoxLength float float float -> void: Unknown
hapticSettings.setControlBoxLengthAIR float float float -> void: Unknown
hapticSettings.setControlBoxLengthHELI float float float -> void: Unknown
hapticSettings.setControlBoxLengthLAND float float float -> void: Unknown
hapticSettings.setControlBoxLengthSEA float float float -> void: Unknown
hapticSettings.setControlBoxLengthSOLDIER float float float -> void: Unknown
hapticSettings.setControlBoxStiffness float float float -> void: Unknown
hapticSettings.setControlBoxStiffnessAIR float float float -> void: Unknown
hapticSettings.setControlBoxStiffnessHELI float float float -> void: Unknown
hapticSettings.setControlBoxStiffnessLAND float float float -> void: Unknown
hapticSettings.setControlBoxStiffnessSEA float float float -> void: Unknown
hapticSettings.setControlBoxStiffnessSOLDIER float float float -> void: Unknown
hapticSettings.setDamageScale float -> void: Unknown
hapticSettings.setExplosionShakeScale float -> void: Unknown
hapticSettings.setForceCapX float -> void: Unknown
hapticSettings.setForceCapY float -> void: Unknown
hapticSettings.setForceCapZ float -> void: Unknown
hapticSettings.setGeneralShakeScale float -> void: Unknown
hapticSettings.setPhysicsAIRScale float float float -> void: Unknown
hapticSettings.setPhysicsAIRScaleXHigh float -> void: Unknown
hapticSettings.setPhysicsAIRScaleXLow float -> void: Unknown
hapticSettings.setPhysicsAIRScaleXMed float -> void: Unknown
hapticSettings.setPhysicsAIRScaleYHigh float -> void: Unknown
hapticSettings.setPhysicsAIRScaleYLow float -> void: Unknown
hapticSettings.setPhysicsAIRScaleYMed float -> void: Unknown
hapticSettings.setPhysicsAIRScaleZHigh float -> void: Unknown
hapticSettings.setPhysicsAIRScaleZLow float -> void: Unknown
hapticSettings.setPhysicsAIRScaleZMed float -> void: Unknown
hapticSettings.setPhysicsAIRSmoothTimeXHigh int -> void: Unknown
hapticSettings.setPhysicsAIRSmoothTimeXLow int -> void: Unknown
hapticSettings.setPhysicsAIRSmoothTimeXMed int -> void: Unknown
hapticSettings.setPhysicsAIRSmoothTimeYHigh int -> void: Unknown
hapticSettings.setPhysicsAIRSmoothTimeYLow int -> void: Unknown
hapticSettings.setPhysicsAIRSmoothTimeYMed int -> void: Unknown
hapticSettings.setPhysicsAIRSmoothTimeZHigh int -> void: Unknown
hapticSettings.setPhysicsAIRSmoothTimeZLow int -> void: Unknown
hapticSettings.setPhysicsAIRSmoothTimeZMed int -> void: Unknown
hapticSettings.setPhysicsAIRTransitionValueHigh float -> void: Unknown
hapticSettings.setPhysicsAIRTransitionValueMed float -> void: Unknown
hapticSettings.setPhysicsHELIScale float float float -> void: Unknown
hapticSettings.setPhysicsHELIScaleXHigh float -> void: Unknown
hapticSettings.setPhysicsHELIScaleXLow float -> void: Unknown
hapticSettings.setPhysicsHELIScaleXMed float -> void: Unknown
hapticSettings.setPhysicsHELIScaleYHigh float -> void: Unknown
hapticSettings.setPhysicsHELIScaleYLow float -> void: Unknown
hapticSettings.setPhysicsHELIScaleYMed float -> void: Unknown
hapticSettings.setPhysicsHELIScaleZHigh float -> void: Unknown
hapticSettings.setPhysicsHELIScaleZLow float -> void: Unknown
hapticSettings.setPhysicsHELIScaleZMed float -> void: Unknown
hapticSettings.setPhysicsHELISmoothTimeXHigh int -> void: Unknown
hapticSettings.setPhysicsHELISmoothTimeXLow int -> void: Unknown
hapticSettings.setPhysicsHELISmoothTimeXMed int -> void: Unknown
hapticSettings.setPhysicsHELISmoothTimeYHigh int -> void: Unknown
hapticSettings.setPhysicsHELISmoothTimeYLow int -> void: Unknown
hapticSettings.setPhysicsHELISmoothTimeYMed int -> void: Unknown
hapticSettings.setPhysicsHELISmoothTimeZHigh int -> void: Unknown
hapticSettings.setPhysicsHELISmoothTimeZLow int -> void: Unknown
hapticSettings.setPhysicsHELISmoothTimeZMed int -> void: Unknown
hapticSettings.setPhysicsHELITransitionValueHigh float -> void: Unknown
hapticSettings.setPhysicsHELITransitionValueMed float -> void: Unknown
hapticSettings.setPhysicsLANDScale float float float -> void: Unknown
hapticSettings.setPhysicsLANDScaleXHigh float -> void: Unknown
hapticSettings.setPhysicsLANDScaleXLow float -> void: Unknown
hapticSettings.setPhysicsLANDScaleXMed float -> void: Unknown
hapticSettings.setPhysicsLANDScaleYHigh float -> void: Unknown
hapticSettings.setPhysicsLANDScaleYLow float -> void: Unknown
hapticSettings.setPhysicsLANDScaleYMed float -> void: Unknown
hapticSettings.setPhysicsLANDScaleZHigh float -> void: Unknown
hapticSettings.setPhysicsLANDScaleZLow float -> void: Unknown
hapticSettings.setPhysicsLANDScaleZMed float -> void: Unknown
hapticSettings.setPhysicsLANDSmoothTimeXHigh int -> void: Unknown
hapticSettings.setPhysicsLANDSmoothTimeXLow int -> void: Unknown
hapticSettings.setPhysicsLANDSmoothTimeXMed int -> void: Unknown
hapticSettings.setPhysicsLANDSmoothTimeYHigh int -> void: Unknown
hapticSettings.setPhysicsLANDSmoothTimeYLow int -> void: Unknown
hapticSettings.setPhysicsLANDSmoothTimeYMed int -> void: Unknown
hapticSettings.setPhysicsLANDSmoothTimeZHigh int -> void: Unknown
hapticSettings.setPhysicsLANDSmoothTimeZLow int -> void: Unknown
hapticSettings.setPhysicsLANDSmoothTimeZMed int -> void: Unknown
hapticSettings.setPhysicsLANDTransitionValueHigh float -> void: Unknown
hapticSettings.setPhysicsLANDTransitionValueMed float -> void: Unknown
hapticSettings.setPhysicsSEAScale float float float -> void: Unknown
hapticSettings.setPhysicsSEAScaleXHigh float -> void: Unknown
hapticSettings.setPhysicsSEAScaleXLow float -> void: Unknown
hapticSettings.setPhysicsSEAScaleXMed float -> void: Unknown
hapticSettings.setPhysicsSEAScaleYHigh float -> void: Unknown
hapticSettings.setPhysicsSEAScaleYLow float -> void: Unknown
hapticSettings.setPhysicsSEAScaleYMed float -> void: Unknown
hapticSettings.setPhysicsSEAScaleZHigh float -> void: Unknown
hapticSettings.setPhysicsSEAScaleZLow float -> void: Unknown
hapticSettings.setPhysicsSEAScaleZMed float -> void: Unknown
hapticSettings.setPhysicsSEASmoothTimeXHigh int -> void: Unknown
hapticSettings.setPhysicsSEASmoothTimeXLow int -> void: Unknown
hapticSettings.setPhysicsSEASmoothTimeXMed int -> void: Unknown
hapticSettings.setPhysicsSEASmoothTimeYHigh int -> void: Unknown
hapticSettings.setPhysicsSEASmoothTimeYLow int -> void: Unknown
hapticSettings.setPhysicsSEASmoothTimeYMed int -> void: Unknown
hapticSettings.setPhysicsSEASmoothTimeZHigh int -> void: Unknown
hapticSettings.setPhysicsSEASmoothTimeZLow int -> void: Unknown
hapticSettings.setPhysicsSEASmoothTimeZMed int -> void: Unknown
hapticSettings.setPhysicsSEATransitionValueHigh float -> void: Unknown
hapticSettings.setPhysicsSEATransitionValueMed float -> void: Unknown
hapticSettings.setPhysicsSOLDIERScale float float float -> void: Unknown
hapticSettings.setPhysicsSOLDIERScaleXHigh float -> void: Unknown
hapticSettings.setPhysicsSOLDIERScaleXLow float -> void: Unknown
hapticSettings.setPhysicsSOLDIERScaleXMed float -> void: Unknown
hapticSettings.setPhysicsSOLDIERScaleYHigh float -> void: Unknown
hapticSettings.setPhysicsSOLDIERScaleYLow float -> void: Unknown
hapticSettings.setPhysicsSOLDIERScaleYMed float -> void: Unknown
hapticSettings.setPhysicsSOLDIERScaleZHigh float -> void: Unknown
hapticSettings.setPhysicsSOLDIERScaleZLow float -> void: Unknown
hapticSettings.setPhysicsSOLDIERScaleZMed float -> void: Unknown
hapticSettings.setPhysicsSOLDIERSmoothTimeXHigh int -> void: Unknown
hapticSettings.setPhysicsSOLDIERSmoothTimeXLow int -> void: Unknown
hapticSettings.setPhysicsSOLDIERSmoothTimeXMed int -> void: Unknown
hapticSettings.setPhysicsSOLDIERSmoothTimeYHigh int -> void: Unknown
hapticSettings.setPhysicsSOLDIERSmoothTimeYLow int -> void: Unknown
hapticSettings.setPhysicsSOLDIERSmoothTimeYMed int -> void: Unknown
hapticSettings.setPhysicsSOLDIERSmoothTimeZHigh int -> void: Unknown
hapticSettings.setPhysicsSOLDIERSmoothTimeZLow int -> void: Unknown
hapticSettings.setPhysicsSOLDIERSmoothTimeZMed int -> void: Unknown
hapticSettings.setPhysicsSOLDIERTransitionValueHigh float -> void: Unknown
hapticSettings.setPhysicsSOLDIERTransitionValueMed float -> void: Unknown
hapticSettings.setRecoilPitchScaleCARBINE float -> void: Unknown
hapticSettings.setRecoilPitchScaleDEFIB float -> void: Unknown
hapticSettings.setRecoilPitchScaleDROP float -> void: Unknown
hapticSettings.setRecoilPitchScaleKNIFE float -> void: Unknown
hapticSettings.setRecoilPitchScaleLAUNCHER float -> void: Unknown
hapticSettings.setRecoilPitchScaleLMG float -> void: Unknown
hapticSettings.setRecoilPitchScalePISTOL float -> void: Unknown
hapticSettings.setRecoilPitchScaleRIFLE float -> void: Unknown
hapticSettings.setRecoilPitchScaleRIFLELAUNCHER float -> void: Unknown
hapticSettings.setRecoilPitchScaleSHOTGUN float -> void: Unknown
hapticSettings.setRecoilPitchScaleSMG float -> void: Unknown
hapticSettings.setRecoilPitchScaleSNIPER float -> void: Unknown
hapticSettings.setRecoilPitchScaleTHROWN float -> void: Unknown
hapticSettings.setRecoilPitchScaleV_AIRGUN float -> void: Unknown
hapticSettings.setRecoilPitchScaleV_ARMORCANNON float -> void: Unknown
hapticSettings.setRecoilPitchScaleV_COAXIALGUN float -> void: Unknown
hapticSettings.setRecoilPitchScaleV_HELIGUN float -> void: Unknown
hapticSettings.setRecoilPitchScaleV_HMG float -> void: Unknown
hapticSettings.setRecoilPitchScaleV_LMG float -> void: Unknown
hapticSettings.setRecoilPitchScaleV_MISSILE float -> void: Unknown
hapticSettings.setRecoilPunchScaleCARBINE float -> void: Unknown
hapticSettings.setRecoilPunchScaleDEFIB float -> void: Unknown
hapticSettings.setRecoilPunchScaleDROP float -> void: Unknown
hapticSettings.setRecoilPunchScaleKNIFE float -> void: Unknown
hapticSettings.setRecoilPunchScaleLAUNCHER float -> void: Unknown
hapticSettings.setRecoilPunchScaleLMG float -> void: Unknown
hapticSettings.setRecoilPunchScalePISTOL float -> void: Unknown
hapticSettings.setRecoilPunchScaleRIFLE float -> void: Unknown
hapticSettings.setRecoilPunchScaleRIFLELAUNCHER float -> void: Unknown
hapticSettings.setRecoilPunchScaleSHOTGUN float -> void: Unknown
hapticSettings.setRecoilPunchScaleSMG float -> void: Unknown
hapticSettings.setRecoilPunchScaleSNIPER float -> void: Unknown
hapticSettings.setRecoilPunchScaleTHROWN float -> void: Unknown
hapticSettings.setRecoilPunchScaleV_AIRGUN float -> void: Unknown
hapticSettings.setRecoilPunchScaleV_ARMORCANNON float -> void: Unknown
hapticSettings.setRecoilPunchScaleV_COAXIALGUN float -> void: Unknown
hapticSettings.setRecoilPunchScaleV_HELIGUN float -> void: Unknown
hapticSettings.setRecoilPunchScaleV_HMG float -> void: Unknown
hapticSettings.setRecoilPunchScaleV_LMG float -> void: Unknown
hapticSettings.setRecoilPunchScaleV_MISSILE float -> void: Unknown
hapticSettings.setRecoilPunchTimeCARBINE float -> void: Unknown
hapticSettings.setRecoilPunchTimeDEFIB float -> void: Unknown
hapticSettings.setRecoilPunchTimeDROP float -> void: Unknown
hapticSettings.setRecoilPunchTimeKNIFE float -> void: Unknown
hapticSettings.setRecoilPunchTimeLAUNCHER float -> void: Unknown
hapticSettings.setRecoilPunchTimeLMG float -> void: Unknown
hapticSettings.setRecoilPunchTimePISTOL float -> void: Unknown
hapticSettings.setRecoilPunchTimeRIFLE float -> void: Unknown
hapticSettings.setRecoilPunchTimeRIFLELAUNCHER float -> void: Unknown
hapticSettings.setRecoilPunchTimeSHOTGUN float -> void: Unknown
hapticSettings.setRecoilPunchTimeSMG float -> void: Unknown
hapticSettings.setRecoilPunchTimeSNIPER float -> void: Unknown
hapticSettings.setRecoilPunchTimeTHROWN float -> void: Unknown
hapticSettings.setRecoilPunchTimeV_AIRGUN float -> void: Unknown
hapticSettings.setRecoilPunchTimeV_ARMORCANNON float -> void: Unknown
hapticSettings.setRecoilPunchTimeV_COAXIALGUN float -> void: Unknown
hapticSettings.setRecoilPunchTimeV_HELIGUN float -> void: Unknown
hapticSettings.setRecoilPunchTimeV_HMG float -> void: Unknown
hapticSettings.setRecoilPunchTimeV_LMG float -> void: Unknown
hapticSettings.setRecoilPunchTimeV_MISSILE float -> void: Unknown
hapticSettings.setRecoilYawScaleCARBINE float -> void: Unknown
hapticSettings.setRecoilYawScaleDEFIB float -> void: Unknown
hapticSettings.setRecoilYawScaleDROP float -> void: Unknown
hapticSettings.setRecoilYawScaleKNIFE float -> void: Unknown
hapticSettings.setRecoilYawScaleLAUNCHER float -> void: Unknown
hapticSettings.setRecoilYawScaleLMG float -> void: Unknown
hapticSettings.setRecoilYawScalePISTOL float -> void: Unknown
hapticSettings.setRecoilYawScaleRIFLE float -> void: Unknown
hapticSettings.setRecoilYawScaleRIFLELAUNCHER float -> void: Unknown
hapticSettings.setRecoilYawScaleSHOTGUN float -> void: Unknown
hapticSettings.setRecoilYawScaleSMG float -> void: Unknown
hapticSettings.setRecoilYawScaleSNIPER float -> void: Unknown
hapticSettings.setRecoilYawScaleTHROWN float -> void: Unknown
hapticSettings.setRecoilYawScaleV_AIRGUN float -> void: Unknown
hapticSettings.setRecoilYawScaleV_ARMORCANNON float -> void: Unknown
hapticSettings.setRecoilYawScaleV_COAXIALGUN float -> void: Unknown
hapticSettings.setRecoilYawScaleV_HELIGUN float -> void: Unknown
hapticSettings.setRecoilYawScaleV_HMG float -> void: Unknown
hapticSettings.setRecoilYawScaleV_LMG float -> void: Unknown
hapticSettings.setRecoilYawScaleV_MISSILE float -> void: Unknown
hapticSettings.setSpeedShakeScale float -> void: Unknown
hapticSettings.setTurnSensitivity float float float -> void: Unknown
hapticSettings.setTurnSensitivityAIR float float float -> void: Unknown
hapticSettings.setTurnSensitivityHELI float float float -> void: Unknown
hapticSettings.setTurnSensitivityLAND float float float -> void: Unknown
hapticSettings.setTurnSensitivitySEA float float float -> void: Unknown
hapticSettings.setTurnSensitivitySOLDIER float float float -> void: Unknown

heightmapcluster

heightmapcluster.addHeightmap std::string int int -> void: Unknown
heightmapcluster.compileWaterMeshesIntoHeightmap -> void: Unknown
heightmapcluster.create std::string -> void: Unknown
heightmapcluster.importSurroundingRawHeightMap std::string -> bool: Unknown
heightmapcluster.intersectCameraRay -> void: Unknown
heightmapcluster.setClusterSize int -> void: Unknown
heightmapcluster.setHeightmapSize int -> void: Unknown
heightmapcluster.setSeaWaterLevel float -> void: Unknown
heightmapcluster.smoothEdges int float float -> void: Unknown
heightmapcluster.stitchEdges -> void: Unknown
heightmap.loadHeightData std::string -> void: Unknown
heightmap.loadMaterialData std::string -> void: Unknown
heightmap.setBitResolution int -> void: Unknown
heightmap.setMaterialScale int -> void: Unknown
heightmap.setModified bool -> void: Unknown
heightmap.setScale Vec3 -> void: Unknown
heightmap.setSize int int -> void: Unknown
hemiMapManager.hemiLerpBias float -> float: Unknown
hemiMapManager.makeHemiMap unsigned long std::string Vec3 -> bool: Unknown
hemiMapManager.setBaseHemiMap std::string Vec3 float -> bool: Unknown

hudBuilder

hudBuilder.addNodeAlphaShowEffect -> bool: Unknown
hudBuilder.addNodeBlendEffect int int -> bool: Unknown
hudBuilder.addNodeMoveShowEffect float int -> bool: Unknown
hudBuilder.addNodeVariableMoveShowEffect std::string std::string -> bool: Unknown
hudBuilder.addObjectMarkerNodeLockTextNode std::string -> bool: Unknown
hudBuilder.addTransformListNode std::string -> bool: Unknown
hudBuilder.createBarNode std::string std::string int -> bool: Unknown
hudBuilder.createButtonNode std::string std::string int -> bool: Unknown
hudBuilder.createCompassNode std::string std::string int -> bool: Unknown
hudBuilder.createEditNode std::string std::string int -> bool: Unknown
hudBuilder.createHoverNode std::string std::string int -> bool: Unknown
hudBuilder.createListNode std::string std::string int -> bool: Unknown
hudBuilder.createMapNode std::string std::string -> bool: Unknown
hudBuilder.createMiniMapNode std::string std::string int -> bool: Unknown
hudBuilder.createObjectMarkerNode std::string std::string int -> bool: Unknown
hudBuilder.createObjectSelectionNode std::string std::string int -> bool: Unknown
hudBuilder.createOccupiedNode std::string std::string int -> bool: Unknown
hudBuilder.createPictureNode std::string std::string int -> bool: Unknown
hudBuilder.createSliderNode std::string std::string float -> bool: Unknown
hudBuilder.createSplitNode std::string std::string -> bool: Unknown
hudBuilder.createTextNode std::string std::string int -> bool: Unknown
hudBuilder.createTileNode std::string std::string int -> bool: Unknown
hudBuilder.createTransformListNode std::string std::string int -> bool: Unknown
hudBuilder.createTransformNode std::string std::string int -> int: Unknown
hudBuilder.deleteNode -> bool: Unknown
hudBuilder.newLayer -> bool: Unknown
hudBuilder.searchNodes std::string std::string -> meme: :Node*; Unknown
hudBuilder.setActiveObject std::string std::string -> bool: Unknown
hudBuilder.setBarNodeBorder int int int -> bool: Unknown
hudBuilder.setBarNodeSnap int -> bool: Unknown
hudBuilder.setBarNodeSnapDir bool -> bool: Unknown
hudBuilder.setBarNodeTexture int std::string -> bool: Unknown
hudBuilder.setBarNodeValueVariable std::string -> bool: Unknown
hudBuilder.setBarNodeVariableTexture int std::string -> bool: Unknown
hudBuilder.setButtonNodeAltConCmd std::string int -> bool: Unknown
hudBuilder.setButtonNodeConCmd std::string int -> bool: Unknown
hudBuilder.setButtonNodeDebug bool -> bool: Unknown
hudBuilder.setButtonNodeFunction std::string int -> bool: Unknown
hudBuilder.setButtonNodeMouseArea int int int -> bool: Unknown
hudBuilder.setButtonNodeMouseOverColor float float float -> bool: Unknown
hudBuilder.setButtonNodeTexture int std::string -> bool: Unknown
hudBuilder.setCommanderPos Vec2 -> bool: Unknown
hudBuilder.setCommanderSize Vec2 -> bool: Unknown
hudBuilder.setCompassNodeBorder int int int -> bool: Unknown
hudBuilder.setCompassNodeOffset int -> bool: Unknown
hudBuilder.setCompassNodeSnapOffset int int int -> bool: Unknown
hudBuilder.setCompassNodeSnapTexture bool std::string -> bool: Unknown
hudBuilder.setCompassNodeTexture int std::string -> bool: Unknown
hudBuilder.setCompassNodeTextureSize int int -> bool: Unknown
hudBuilder.setCompassNodeValueVariable std::string -> bool: Unknown
hudBuilder.setCompassNodeVariableTexture int std::string -> bool: Unknown
hudBuilder.setCPFont std::string -> void: Unknown
hudBuilder.setCPFontColor float float float -> void: Unknown
hudBuilder.setEditNodeColor float float float -> bool: Unknown
hudBuilder.setEditNodeData int -> bool: Unknown
hudBuilder.setEditNodeFont std::string bool -> bool: Unknown
hudBuilder.setEditNodeMaxLength int -> bool: Unknown
hudBuilder.setEditNodestd::string int -> bool: Unknown
hudBuilder.setHoverInMiddlePos int int -> bool: Unknown
hudBuilder.setHoverMaxValue float -> bool: Unknown
hudBuilder.setHoverWidthLength float float -> bool: Unknown
hudBuilder.setListNodeBackgroundColor float float float -> bool: Unknown
hudBuilder.setListNodeBorder int int int -> bool: Unknown
hudBuilder.setListNodeBorderColor float float float -> bool: Unknown
hudBuilder.setListNodeConCmd int std::string -> bool: Unknown
hudBuilder.setListNodeData int -> bool: Unknown
hudBuilder.setListNodeFont std::string int -> bool: Unknown
hudBuilder.setListNodeOutline bool -> bool: Unknown
hudBuilder.setListNodeRowSpacing int -> bool: Unknown
hudBuilder.setListNodeScrollbar int int -> bool: Unknown
hudBuilder.setListNodeScrollbarBackgroundColor float float float -> bool: Unknown
hudBuilder.setListNodeScrollbarColor float float float -> bool: Unknown
hudBuilder.setListNodeSelectColor float float float -> bool: Unknown
hudBuilder.setMaxiPos Vec2 -> bool: Unknown
hudBuilder.setMaxiSize Vec2 -> bool: Unknown
hudBuilder.setMiniPos Vec2 -> bool: Unknown
hudBuilder.setMiniSize Vec2 -> bool: Unknown
hudBuilder.setModifyer float -> void: Unknown
hudBuilder.setNodeAlphaVariable std::string -> bool: Unknown
hudBuilder.setNodeColor float float float -> bool: Unknown
hudBuilder.setNodeInTime float -> bool: Unknown
hudBuilder.setNodeLogicShowVariable std::string std::string int -> bool: Unknown
hudBuilder.setNodeOffset int int -> bool: Unknown
hudBuilder.setNodeOutTime float -> bool: Unknown
hudBuilder.setNodePos int int -> bool: Unknown
hudBuilder.setNodePosVariable int std::string -> bool: Unknown
hudBuilder.setNodeRGBVariables std::string std::string std::string -> bool: Unknown
hudBuilder.setNodeShowVariable std::string -> bool: Unknown
hudBuilder.setNodeSize int int -> bool: Unknown
hudBuilder.setObjectMarkerNodeLockOnType int -> bool: Unknown
hudBuilder.setObjectMarkerNodeLockText bool std::string -> bool: Unknown
hudBuilder.setObjectMarkerNodeLockTextOffset int int -> bool: Unknown
hudBuilder.setObjectMarkerNodeObjects int -> bool: Unknown
hudBuilder.setObjectMarkerNodeTexture int std::string -> bool: Unknown
hudBuilder.setObjectMarkerNodeTextureSize int int int -> bool: Unknown
hudBuilder.setObjectMarkerNodeWeapon int -> bool: Unknown
hudBuilder.setObjectSelectionNodePointerSize int int -> bool: Unknown
hudBuilder.setOccupiedNodeData int -> bool: Unknown
hudBuilder.setOccupiedNodePosVariable int std::string -> bool: Unknown
hudBuilder.setPictureNodeAlphaMask std::string -> bool: Unknown
hudBuilder.setPictureNodeBorder int int int -> bool: Unknown
hudBuilder.setPictureNodeBorderColor float float float -> bool: Unknown
hudBuilder.setPictureNodeCenterPoint int int -> bool: Unknown
hudBuilder.setPictureNodeRotateVariable std::string -> bool: Unknown
hudBuilder.setPictureNodeRotation int -> bool: Unknown
hudBuilder.setPictureNodeTexture std::string -> bool: Unknown
hudBuilder.setPictureNodeVariableTexture std::string -> bool: Unknown
hudBuilder.setSliderNodeChild std::string -> bool: Unknown
hudBuilder.setSliderNodeData std::string -> bool: Unknown
hudBuilder.setTextNodeOutLine std::string -> bool: Unknown
hudBuilder.setTextNodeOutLineOffset float float -> bool: Unknown
hudBuilder.setTextNodestd::string std::string -> bool: Unknown
hudBuilder.setTextNodestd::stringVariable std::string -> bool: Unknown
hudBuilder.setTextNodeStyle std::string int -> bool: Unknown
hudBuilder.setTileNodeOptions int int int -> bool: Unknown
hudBuilder.setTranformListNodeOffset int int -> bool: Unknown
hudBuilder.setTranformListNodePosVariable int std::string -> bool: Unknown
hudBuilder.setZoomIcons bool -> bool: Unknown
hudItems.setBool std::string bool -> void: Unknown
hudItems.setFloat std::string float -> void: Unknown
hudItems.setstd::string std::string std::string -> void: Unknown
hudManager.addFavouriteServer bool -> void: Unknown
hudManager.addTextureAtlas std::string -> void: Unknown
hudManager.enableSayAllChatBox bool -> void: Unknown
hudManager.enableSaySquadChatBox bool -> void: Unknown
hudManager.enableSayTeamChatBox bool -> void: Unknown
hudManager.refresh -> bool: Unknown
hudManager.setCommMousePos int int -> bool: Unknown
hudManager.setCommMouseSensitivity int -> bool: Unknown
hudManager.setCommPos int int -> bool: Unknown
hudManager.setCommSize int int -> bool: Unknown
hudManager.setDisplayControlpoints bool -> void: Unknown
hudManager.setDisplayTickets bool -> void: Unknown
hudManager.setDone bool -> void: Unknown
hudManager.setMapStatic bool -> void: Unknown
hudManager.setMaximumNrOfCPs int -> void: Unknown
hudManager.setMouseTextureArtillery std::string -> bool: Unknown
hudManager.setMouseTextureCancel std::string -> bool: Unknown
hudManager.setMouseTextureEmpty std::string -> bool: Unknown
hudManager.setMouseTextureFull std::string -> bool: Unknown
hudManager.setMouseTextureSupply std::string -> bool: Unknown
hudManager.setMouseTextureUAV std::string -> bool: Unknown
hudManager.setPaint bool -> void: Unknown
hudManager.setPointerMouseSensitivity int -> bool: Unknown
hudManager.setPointerSize int int -> bool: Unknown
hudManager.setSpottedAngle float -> void: Unknown
hudManager.setSpottedMenuPos int int -> bool: Unknown
hudManager.setSpottedMenuSize int int -> bool: Unknown
hudManager.setSpottedMousePos int int -> bool: Unknown
hudManager.setTargetTop float -> void: Unknown
hudManager.setUpdate bool -> void: Unknown
ingameHelp.showIngameHelp std::string float -> void: Unknown
InputDevices.setAxisScale InputDeviceFlags InputDeviceAxes float -> bool: Unknown
InputDevices.setInvertAxis InputDeviceFlags InputDeviceAxes bool -> bool: Unknown
itemSelection.setReverseItems bool -> void: Unknown
levelsList.setVoteMapShow int -> void: Unknown
levelsList.singleClick int -> void: Unknown
lightManager.ambientColor Vec3 -> Vec3: Unknown

lightManager

lightManager.defaultEffectLightAffectionFactor float -> float: Unknown
lightManager.dynamicPointColor Vec3 -> Vec3: Unknown
lightManager.dynamicPointColorHigh Vec3 -> Vec3: Unknown
lightManager.dynamicPointColorLow Vec3 -> Vec3: Unknown
lightManager.dynamicPointScale float -> float: Unknown
lightManager.effectShadowColor Vec3 -> Vec3: Unknown
lightManager.effectSunColor Vec3 -> Vec3: Unknown
lightManager.enableStencilCullerReset bool -> bool: Unknown
lightManager.enableSun bool -> bool: Unknown
lightManager.groundHemi std::string -> std::string: Unknown
lightManager.hemiLerpBias float -> float: Unknown
lightManager.init -> void: Unknown
lightManager.lightCullDistance float -> float

:Used in sky.con :Raises the default limit of the culling of lightsources from a distance. Example: lightManager.lightCullDistance 2000 which extends the rendering of the lightsource.

lightManager.lightMapAmbientAlphaCutoffRange Vec2 -> Vec2: Unknown
lightManager.maxLightsPerBundledMesh int -> int: Unknown
lightManager.maxLightsPerSkinnedMesh int -> int: Unknown
lightManager.maxLightsPerStaticMesh int -> int: Unknown
lightManager.maxLightsPerTerrainPatch int -> int: Unknown
lightManager.maxLodForMaterialBatching int -> int: Unknown
lightManager.singlePointColor Vec3 -> Vec3: Unknown
lightManager.singlePointColorHigh Vec3 -> Vec3: Unknown
lightManager.singlePointColorLow Vec3 -> Vec3: Unknown
lightManager.skinnedMeshShaderLodDistance float -> float: Unknown
lightManager.skyColor Vec3 -> Vec3: Unknown
lightManager.skyColorHigh Vec3 -> Vec3: Unknown
lightManager.skyColorLow Vec3 -> Vec3: Unknown
lightManager.staticLightBlendingTime double -> double: Unknown
lightManager.staticSkyColor Vec3 -> Vec3: Unknown
lightManager.staticSkyColorHigh Vec3 -> Vec3: Unknown
lightManager.staticSkyColorLow Vec3 -> Vec3: Unknown
lightManager.staticSpecularColor Vec3 -> Vec3: Unknown
lightManager.staticSunColor Vec3 -> Vec3: Unknown
lightManager.sunColor Vec3 -> Vec3: Unknown
lightManager.sunColorHigh Vec3 -> Vec3: Unknown
lightManager.sunColorLow Vec3 -> Vec3: Unknown
lightManager.sunDirection Vec3 -> Vec3: Unknown
lightManager.sunSpecColor Vec3 -> Vec3: Unknown
lightManager.sunSpecColorHigh Vec3 -> Vec3: Unknown
lightManager.sunSpecColorLow Vec3 -> Vec3: Unknown
lightManager.treeAmbientColor Vec3 -> Vec3: Unknown
lightManager.treeSkyColor Vec3 -> Vec3: Unknown
lightManager.treeSunColor Vec3 -> Vec3: Unknown

localPlayer

localPlayer.commanderSelectDelay float -> float: Unknown
localPlayer.firstCommanderSelectDelay float -> float: Unknown

localProfile

localProfile.addDemoBookmark std::string std::string std::string -> void: Adds a bookmark to a battlerecorder demo
localProfile.save -> bool: Unknown
localProfile.setEmail std::string -> std::string: Sets or shows the email adress of the current profile
localProfile.setGamespyNick std::string -> std::string: Sets or shows the gamespy login name of the current profile
localProfile.setName std::string -> std::string: Sets or shows the name for the current profile
localProfile.setNick std::string -> std::string: Sets or shows the nickname for the current profile
localProfile.setNumTimesLoggedIn int -> int: Unknown
localProfile.setPassword std::string -> std::string: Sets or shows the password for the current profile
localProfile.setTotalPlayedTime float -> void: Unknown

maplist

maplist.append std::string std::string int -> bool: Unknown
maplist.clear -> bool: Unknown
maplist.configFile std::string -> std::string: Unknown
maplist.currentMap -> int: Unknown
maplist.insert int std::string std::string -> bool: Unknown
maplist.list -> std::string: Unknown
maplist.load -> bool: Unknown
maplist.mapCount -> int: Unknown
maplist.remove int -> int: Unknown
maplist.save -> bool: Unknown

material

material.active unsigned int -> unsigned int: Unknown
material.damageLoss float -> float: Unknown
material.elasticity float -> float: Unknown
material.friction float -> float: Unknown
material.hasWaterPhysics bool -> bool: Unknown
material.isBarbwire bool -> bool: Unknown
material.isOneSided bool -> bool: Unknown
material.isSeeThrough bool -> bool: Unknown
materialManager.attMaterial unsigned int -> void: Unknown
materialManager.createCell unsigned int unsigned int -> void: Unknown
materialManager.damageMod float -> float: Unknown
materialManager.defMaterial unsigned int -> void: Unknown
materialManager.setDecalTemplate unsigned int IObjectTemplate_ptrproxy -> void: Unknown
materialManager.setEffectTemplate unsigned int IObjectTemplate_ptrproxy -> void: Unknown
materialManager.setSoundTemplate unsigned int IObjectTemplate_ptrproxy -> void: Unknown
material.maxDamageLoss float -> float: Unknown
material.minDamageLoss float -> float: Unknown
material.name std::string -> std::string: Unknown
material.overrideNeverPenetrate bool -> bool: Unknown
material.penetrationDeviation float -> float: Unknown
material.projectileCollisionHardness float -> float: Unknown
material.resistance float -> float: Unknown
material.type int -> int: Unknown

menuTeamManager

menuTeamManager.addKit std::string -> void: Unknown
menuTeamManager.addTeam std::string std::string -> void: Unknown
menuTeamManager.addWeapon std::string int int -> void: Unknown
menuTeamManager.setTeamId int -> void: Unknown

minimap

minimap.setCommanderOffset Vec2 -> void: Unknown
minimap.setCurrOrderList int -> void: Unknown
minimap.setDestinationBlend int -> void: Unknown
minimap.setFilterColor float float float -> void: Unknown
minimap.setFullScreenZoom int -> void: Unknown
minimap.setPaintAllKits -> void: Unknown
minimap.setPaintAllVehicles -> void: Unknown
minimap.setPaintKit int -> void: Unknown
minimap.setPaintVehicle int -> void: Unknown
minimap.setSourceBlend int -> void: Unknown
minimap.setZoom -> void: Unknown
minimap.toggleShowKits -> void: Unknown

nametags

nametags.createBar NametagItemIDs int int -> void: Unknown
nametags.createIcon NametagItemIDs -> void: Unknown
nametags.deathFadeOutTime float -> float: Unknown
nametags.deployableDistance double -> double: Unknown
nametags.enemyDotLimit float -> float: Unknown
nametags.enemyTagDelayTime double -> double: Unknown
nametags.enemyTagFadeInTime double -> double: Unknown
nametags.enemyTagFadeOutTime double -> double: Unknown
nametags.getCullDistance TagType -> Vec2: Unknown
nametags.manDownFadeOutTime float -> float: Unknown
nametags.maxCallDistance float -> float: Unknown
nametags.maxFriendlyDistance float -> float: Unknown
nametags.setCullDistance TagType Vec2 -> void: Unknown
nametags.setTexture int std::string int -> void: Unknown
nametags.vehicleNametagOffset float -> float: Unknown
nametags.vehicleNametagOffsetFactor float -> float: Unknown

networkableInfo

networkableInfo.createNewInfo std::string -> void

:Used in objects\common\Networkables.con :Creates a custom NetworkableInfo. Use with NetworkableInfo.setPredictionMode etc

networkableInfo.deleteInfo std::string -> void: Unknown
networkableInfo.setBasePriority float -> void: Unknown
networkableInfo.setForceNetworkableId bool -> void: Unknown
networkableInfo.setIsUnique bool -> void: Unknown
networkableInfo.setPredictionMode PredictionMode -> void

: :NetworkableInfo.setPredictionMode

network.globalPredictionMode PredictionMode -> PredictionMode: Unknown

object

object.absolutePosition Vec3 -> Vec3: Unknown
object.absolutePositionSecondary Vec3 -> Vec3: Unknown
object.absoluteTransformation Mat4 -> Mat4: Unknown
Object.active world: :IObject_ptrproxy -> world::IObject_ptrproxy; Unknown
object.addAbsolutePoint -> void: Unknown
object.attenuationRange1 float -> float: Unknown
object.attenuationRange2 float -> float: Unknown
object.color Vec3 -> Vec3: Unknown
object.coneAngle1 float -> float: Unknown
object.coneAngle2 float -> float: Unknown
Object.create world: :IObjectTemplate_ptrproxy Vec3 Vec3 -> world::IObject_ptrproxy; Unknown
Object.delete world: :IObject_ptrproxy -> void; Unknown
Object.deleteAll -> std::string: Unknown
object.direction Vec3 -> Vec3: Unknown
object.disableChildren bool -> bool: Unknown
objectDrawer.collectPlanesDistance float -> float: Unknown
objectDrawer.drawDebugPlanes bool -> bool: Unknown
objectDrawer.faceForwardThreshold float -> float: Unknown
objectDrawer.showCullStats bool -> bool: Unknown
objectDrawer.useExactTest bool -> bool: Unknown
objectDrawer.useOcclusion bool -> bool: Unknown
Object.forceStart world: :IObject_ptrproxy -> void; Unknown
Object.forceStop world: :IObject_ptrproxy -> void; Unknown
object.fov float -> float: Unknown
object.geometry.color Vec4 -> Vec4: Unknown
object.geometry.GenerateLightmapForThisInstance bool -> bool: Unknown
object.geometry.loadMesh std::string -> void: Unknown
object.geometry.subGeometry int -> int: Unknown
object.geometry.subGeometryCount -> int: Unknown
object.geometry.technique std::string -> std::string: Unknown
object.geometry.template -> IGeometryTemplate*: Unknown
object.getControlPointId -> int: Unknown
Object.getGroundPos Vec3 -> Vec3: Unknown
object.getLightSourceMask -> int: Unknown
object.getVisibleTeam -> int: Unknown
object.group int -> int: Unknown
object.hasCollision bool -> bool: Unknown
object.hasUpdate bool -> bool: Unknown
object.HDRIntensity float -> float: Unknown
Object.info world: :IObject_ptrproxy -> std::string; Unknown
object.initGrid Vec2 Vec2 int -> void: Unknown
object.isInGrid bool -> bool: Unknown
object.isOvergrowth bool -> bool: Unknown
object.isSaveable bool -> bool: Unknown
object.isVisible bool -> bool: Unknown
object.layer int -> int: Unknown
Object.list -> std::string: Unknown
Object.listObjectsOfTemplate world: :IObjectTemplate_ptrproxy -> std::string; Unknown
Object.loadAll std::string -> bool: Unknown
objectManager.drawStats int -> int: Unknown
object.name std::string -> std::string: Unknown
object.notInAI bool -> bool: Unknown
Object.printScript world: :IObject_ptrproxy -> std::string; Unknown
object.rotation Vec3 -> Vec3: Unknown
object.rotationSecondary Vec3 -> Vec3: Unknown
Object.saveAll std::string -> bool: Unknown
object.scale Vec3 -> Vec3: Unknown
object.setActive bool -> void: Unknown
object.setAsSkyLight -> void: Unknown
object.setControlPointId int -> void: Unknown
object.setIsDisabledRecursive bool -> void: Unknown
object.setIsInTweakModeRecursive bool -> void: Unknown
object.setIsSaveableRecursive bool -> void: Unknown
object.setIsVisibleRecursive bool -> void: Unknown
object.setLightSourceMask int -> void: Unknown
Object.setObjectToGround world: :IObject_ptrproxy -> Vec3; Unknown
object.setTeam int -> void: Unknown
object.setVisibleTeam int -> void: Unknown
object.spawnOffset Vec3 -> Vec3: Unknown
Object.start world: :IObject_ptrproxy -> void; Unknown
Object.stop world: :IObject_ptrproxy -> void; Unknown
object.team int -> int: Unknown
object.template -> const IObjectTemplate*: Unknown

objectTemplate

objectTemplate.3dMapIcon int -> int

:Used in GenericFirearms (Mine etc) .tweak :"The image number sequence referenced in \menu\nametag\Objects.dds. Use the vBF2 file and count the images. 9 is the mine icon. Using this system : you could have custom 3D Mine Icons as long as they are the same size as the original."

objectTemplate.ability.hasAmmoAbility bool -> bool: Unknown
objectTemplate.ability.hasHealingAbility bool -> bool: Unknown
objectTemplate.ability.hasRepairingAbility bool -> bool: Unknown
objectTemplate.ability.radarRadius int -> int: Unknown
objectTemplate.abilityHud.ammoSound std::string -> std::string: Unknown
objectTemplate.abilityHud.healingSound std::string -> std::string: Unknown
objectTemplate.abilityHud.repairingSound std::string -> std::string: Unknown
objectTemplate.abilityInVehicleMaterial int -> int: Unknown
objectTemplate.abilityInVehicleRadius float -> float: Unknown
objectTemplate.abilityInVehicleStrength float -> float: Unknown
objectTemplate.abilityRestoreRate float -> float: Unknown
objectTemplate.acceleration Math: :Vec3 -> Math::Vec3; Unknown
objectTemplate.acceleration float -> float: Unknown
objectTemplate.accumulate bool -> bool: Unknown
ObjectTemplate.active world: :IObjectTemplate_ptrproxy -> world::IObjectTemplate_ptrproxy; Unknown
ObjectTemplate.activeSafe std::string world: :IObjectTemplate_ptrproxy -> void; Unknown
objectTemplate.addAmmoType int int float -> void: Unknown
objectTemplate.addChild bool -> bool: Unknown
objectTemplate.addEmitterSpeed bool -> bool: Unknown
objectTemplate.addKitVehicleMod std::string int -> void: Unknown
objectTemplate.addLinePoint Vec2 -> void: Unknown
objectTemplate.addPcoPosId int -> void: Unknown
objectTemplate.addTargetObjectTypeToWatch int -> void: Unknown
objectTemplate.addTemplate std::string -> void: Unknown
objectTemplate.addToCollisionGroup U32 -> void: Unknown
objectTemplate.addToProjectileList bool -> bool: Unknown
objectTemplate.addTriggerableTarget std::string -> void: Unknown
objectTemplate.addVehicleType std::string int float -> void: Unknown
objectTemplate.addVehicleType VehicleCategory -> void: Unknown
objectTemplate.addWorkOnMaterial int -> void: Unknown
objectTemplate.affectingType int -> int: Unknown
objectTemplate.affectLightmappedObjects bool -> bool: Unknown
objectTemplate.AgeScaleFactorFromAcceleration Vec2 -> Vec2: Unknown
objectTemplate.AgeScaleFactorFromAltitude Vec2 -> Vec2: Unknown
objectTemplate.AgeScaleFactorFromEngine Vec2 -> Vec2: Unknown
objectTemplate.AgeScaleFactorFromRotationalSpeed Vec2 -> Vec2: Unknown
objectTemplate.AgeScaleFactorFromSpeed Vec2 -> Vec2: Unknown
objectTemplate.AgeScaleFactorFromSpeedInDof Vec2 -> Vec2: Unknown
objectTemplate.AgeScaleFactorRange Vec2 -> Vec2: Unknown
objectTemplate.AgeScaleFactorUsed bool -> bool: Unknown
objectTemplate.airFlowAffect float -> float: Unknown
objectTemplate.airFriction float -> float: Unknown
objectTemplate.airResistance float -> float: Unknown
objectTemplate.airResistanceGraph Vec4 -> Vec4: Unknown
objectTemplate.aiTemplate std::string -> std::string: Unknown
objectTemplate.alignEffectTransformation bool -> bool: Unknown
objectTemplate.alignRotationToSpeed bool -> bool: Unknown
objectTemplate.allowDucking bool -> bool: Unknown
objectTemplate.allowInsideDynamicLights bool -> bool: Unknown
objectTemplate.allowInsideStaticSun bool -> bool: Unknown
objectTemplate.alphaCull float -> float: Unknown
objectTemplate.alphaIntensityFromAcceleration Vec2 -> Vec2: Unknown
objectTemplate.alphaIntensityFromAltitude Vec2 -> Vec2: Unknown
objectTemplate.alphaIntensityFromEngine Vec2 -> Vec2: Unknown
objectTemplate.alphaIntensityFromRotationalSpeed Vec2 -> Vec2: Unknown
objectTemplate.alphaIntensityFromSpeed Vec2 -> Vec2: Unknown
objectTemplate.alphaIntensityFromSpeedInDof Vec2 -> Vec2: Unknown
objectTemplate.alphaIntensityRange Vec2 -> Vec2: Unknown
objectTemplate.alphaIntensityUsed bool -> bool: Unknown
objectTemplate.alphaOverTime OverTimeDistribution -> OverTimeDistribution: Unknown
objectTemplate.alternateTemplate0 std::string -> std::string: Unknown
objectTemplate.alternateTemplate1 std::string -> std::string: Unknown
objectTemplate.alternateTemplate2 std::string -> std::string: Unknown
objectTemplate.alternateTemplate3 std::string -> std::string: Unknown
objectTemplate.alternateTemplate4 std::string -> std::string: Unknown
objectTemplate.altSoldierExitPosition Vec3 -> Vec3: Unknown
objectTemplate.ammo.abilityCost float -> float: Unknown
objectTemplate.ammo.abilityDrain float -> float: Unknown
objectTemplate.ammo.abilityMaterial int -> int: Unknown
objectTemplate.ammo.abilityRadius float -> float: Unknown
objectTemplate.ammo.abilityStrength float -> float: Unknown
objectTemplate.ammo.ammoType int -> int: Unknown
objectTemplate.ammo.autoReload bool -> bool: Unknown
objectTemplate.ammo.changeMagAt float -> float: Unknown
objectTemplate.ammo.firstShotExtraTime float -> float: Unknown
objectTemplate.ammo.instantReloadOnEnable bool -> bool: Unknown
objectTemplate.ammo.lastShotExtraTime float -> float: Unknown
objectTemplate.ammo.magLinkWeapon std::string -> std::string: "Weapons, Vehicles .tweak"; Allows two weapons to share the same amount of bullets and magazines. Enter the weapon name to maglink. The weapon that's referenced must also have the same code. Weapons with fire selector code causes it to not work properly (citation needed)
objectTemplate.ammo.magSize int -> int: Weapons .tweak; "Number of bullets in a magazine. -1 for Infinity, maximum non-infinity allowed is 1023, any more will cause a crash. Bug: In the Battlerecorder, it doesn't pickup a gun that fires for 10 seconds on with 1000 bullets for some reason. Tested with the L4Bren on Auto."
objectTemplate.ammo.minimumTimeUntilReload float -> float: Unknown
objectTemplate.ammo.nrOfMags int -> int: Number of magazines allowed for a weapon.
objectTemplate.ammo.onlyActiveWhileFiring bool -> bool: Prevents the Medibag and Ammo Bag from being thrown when firing. Used in PR's Medikit and Repair Bag
objectTemplate.ammo.reloadAmount int -> int: Unknown
objectTemplate.ammo.reloadTime float -> float: Time in seconds of how long it takes to reload. Must be the same number as the reload animation time from AnimationSystem1p.inc to sync properly.
objectTemplate.ammo.reloadWithoutPlayer bool -> bool: "If enabled, weapon will autoreload regardless client settings for autoreload. 1(Enabled), 0(Disabled)"
objectTemplate.ammo.replenishingType ReplenishingType -> ReplenishingType: Unknown
objectTemplate.ammo.toggleWhenNoAmmo bool -> bool: Weapons .tweak; "When no ammo, switch to previous selected weapon."
objectTemplate.ammoStorageSize float -> float: Unknown
objectTemplate.anchor Vec3 -> Vec3: Unknown
objectTemplate.anchorOffset Vec3 -> Vec3: Unknown
objectTemplate.animatedUVRotation int -> int: Unknown
objectTemplate.animatedUVRotationIndex int -> int: Unknown
objectTemplate.animatedUVRotationRadius float -> float: Unknown
objectTemplate.animatedUVRotationReverse bool -> bool: Unknown
objectTemplate.animatedUVRotationScale Vec2 -> Vec2: Unknown
objectTemplate.animatedUVTranslation bool -> bool: Unknown
objectTemplate.animatedUVTranslationIndex int -> int: Unknown
objectTemplate.animatedUVTranslationMax Vec2 -> Vec2: Unknown
objectTemplate.animatedUVTranslationReverse bool -> bool: Unknown
objectTemplate.animatedUVTranslationSize Vec2 -> Vec2: Unknown
objectTemplate.animatedUVTranslationSpeed Vec2 -> Vec2: Unknown
objectTemplate.animation.animateOnZoom bool -> bool: Unknown
objectTemplate.animation.loopingFire float -> float: Unknown
objectTemplate.animation.shiftDelay float -> float: Unknown
objectTemplate.animation.useShiftAnimation bool -> bool: Unknown
objectTemplate.animationEnable bool -> bool: Unknown
objectTemplate.animationFrameCount int -> int: Unknown
objectTemplate.animationFrameCountX int -> int: Unknown
objectTemplate.animationFrameHeight int -> int: Unknown
objectTemplate.animationFrameWidth int -> int: Unknown
objectTemplate.animationPlayOnce bool -> bool: Unknown
objectTemplate.animationRandomizedStartFrame bool -> bool: Unknown
objectTemplate.animationSpeed float -> float: Unknown
objectTemplate.animationSystem1P std::string -> void: Unknown
objectTemplate.animationSystem3P std::string -> void: Unknown
objectTemplate.antenna.accelerationFactor float -> float: Unknown
objectTemplate.antenna.damping float -> float: Unknown
objectTemplate.antenna.maxSwayAngle Vec2 -> Vec2: Unknown
objectTemplate.antenna.skeleton std::string -> std::string: Unknown
objectTemplate.antenna.speedFactor float -> float: Unknown
objectTemplate.antenna.stiffness float -> float: Unknown
objectTemplate.areaValueTeam1 U32 -> U32: Unknown
objectTemplate.areaValueTeam2 U32 -> U32: Unknown
objectTemplate.armingDelay float -> float: Weapons .tweak; Delay in seconds until the collision event is active. Used in the tripflares which has a 15 second delay before passing through it will trigger the collision. Also could just be the seconds before the grenade explodes though not sure
objectTemplate.armor.addArmorEffect int std::string Vec3 -> void: Unknown
objectTemplate.armor.addArmorEffectSpectacular int std::string Vec3 -> void: Unknown
objectTemplate.armor.addWreckArmorEffect int std::string Vec3 -> void: Unknown
objectTemplate.armor.alignLastEffectToHitDirection bool -> bool: Unknown
objectTemplate.armor.angleMod float -> float: Unknown
objectTemplate.armor.attackDamage float -> float: Unknown
objectTemplate.armor.canBeDestroyed bool -> bool: Unknown
objectTemplate.armor.canBeRepairedWhenWreck bool -> bool: "Vehicles .tweak, Weapons .tweak"; "Used in the AA Ship Boats. Basically, when it's a wreck, it can be repaired back to life."
objectTemplate.armor.criticalDamage float -> float: Unknown
objectTemplate.armor.deepWaterDamageDelay float -> float: Unknown
objectTemplate.armor.deepWaterLevel float -> float: Unknown
objectTemplate.armor.defaultMaterial int -> int: Unknown
objectTemplate.armor.destroyOnSpectacularDeath bool -> bool: Unknown
objectTemplate.armor.explosionDamage float -> float: Unknown
objectTemplate.armor.explosionForce float -> float: Unknown
objectTemplate.armor.explosionForceMax float -> float: Unknown
objectTemplate.armor.explosionForceMod float -> float: Unknown
objectTemplate.armor.explosionMaterial int -> int: Unknown
objectTemplate.armor.explosionRadius float -> float: Unknown
objectTemplate.armor.hideChildrenOnSpectacularDeath bool -> bool: Unknown
objectTemplate.armor.hitPoints float -> float: Vehicles .tweak; The health of the vehicle. 0 = Dead.
objectTemplate.armor.hpLostWhileCriticalDamage float -> float: Unknown
objectTemplate.armor.hpLostWhileInDeepWater float -> float: Unknown
objectTemplate.armor.hpLostWhileInWater float -> float: Unknown
objectTemplate.armor.hpLostWhileUpSideDown float -> float: Unknown
objectTemplate.armor.maxHitPoints float -> float: Unknown
objectTemplate.armor.showDamageAsDirt float -> float: Unknown
objectTemplate.armor.speedMod float -> float: Unknown
objectTemplate.armor.timeToStayAfterDestroyed float -> float: Vehicles .tweak; "Interesting code. If set to PR's Jets and Helis, when they explode from wreck, the non-flaming wreck model stays though it shows in the minimap as an occupied vehicle."
objectTemplate.armor.timeToStayAsWreck float -> float: Unknown
objectTemplate.armor.useMMOnDeath bool -> bool: Use the Material Manager on Death. Not too sure about this one
objectTemplate.armor.waterDamageDelay float -> float: Unknown
objectTemplate.armor.waterLevel float -> float: Unknown
objectTemplate.armor.wreckDelay float -> float: Unknown
objectTemplate.armor.wreckExplosionDamage float -> float: Unknown
objectTemplate.armor.wreckExplosionForce float -> float: Unknown
objectTemplate.armor.wreckExplosionForceMax float -> float: Unknown
objectTemplate.armor.wreckExplosionForceMod float -> float: Unknown
objectTemplate.armor.wreckExplosionMaterial int -> int: Unknown
objectTemplate.armor.wreckExplosionRadius float -> float: Unknown
objectTemplate.armor.wreckHitPoints float -> float: Unknown
objectTemplate.artPos bool -> bool: Unknown
objectTemplate.attachClimberRadius float -> float: Unknown
objectTemplate.attachToEventObject bool -> bool: Unknown
objectTemplate.attackSpeed float -> float: Unknown
objectTemplate.attenuationRange1 float -> float: Used in .tweak Effect Files for Lightsource Templates; "How wide you want the lightsource effect to be, used with ObjectTemplate.isDynamic 1. Range1 = X, which is the horizontal range. Max is 100, more than that will trigger an error message"
objectTemplate.attenuationRange2 float -> float: Used in .tweak Effect Files for Lightsource Templates; "The height at which the lightsource will begin to drop. Range2 = Y, which is the vertical range. Max is 100 like above. To know the difference, set one to 50 and one to 100 and count the number of seconds the lightsource effect will last and compare."
objectTemplate.audio.newStyleAudio bool -> bool: Unknown
objectTemplate.audio.transformationRelativeRoot bool -> bool: Unknown
objectTemplate.audioReset -> void: Unknown
objectTemplate.automaticPitchStabilization bool -> bool: Unknown
objectTemplate.automaticReset bool -> bool: Unknown
objectTemplate.automaticYawStabilization bool -> bool: Unknown
objectTemplate.autoUseAbility int -> int: Unknown
objectTemplate.averageTimeBetweenTests float -> float: Unknown
objectTemplate.awakeTime float -> float: Unknown
objectTemplate.blendMode std::string -> std::string: Unknown
objectTemplate.blockInputOnRotBundle std::string -> std::string: Unknown
objectTemplate.blurryVisionHoldTime float -> float: Unknown
objectTemplate.blurryVisionTime float -> float: Unknown
objectTemplate.boneName std::string -> std::string: Unknown
objectTemplate.bounceDamping float -> float: Unknown
objectTemplate.bounceLength float -> float: Unknown
objectTemplate.bounceSensitivity float -> float: Unknown
objectTemplate.bounceStrength float -> float: Unknown
objectTemplate.boundingRadiusModifierWhenOccupied float -> float: Unknown
objectTemplate.cameraId int -> int: Unknown
objectTemplate.cameraShakeMaxSpeed float -> float: Unknown
objectTemplate.cameraShakeSensitivity float -> float: Unknown
objectTemplate.cameraShakeStartSpeed float -> float: Unknown
objectTemplate.cameraSwayDofMax float -> float: Unknown
objectTemplate.cameraSwayDofMin float -> float: Unknown
objectTemplate.cameraSwayRightMax float -> float: Unknown
objectTemplate.cameraSwayRightMin float -> float: Unknown
objectTemplate.cameraSwayRodLength float -> float: Unknown
objectTemplate.cameraSwaySensitivity float -> float: Unknown
objectTemplate.cameraSwaySpringDamping float -> float: Unknown
objectTemplate.cameraSwaySpringStrength float -> float: Unknown
objectTemplate.canFireGuiIndex int -> int: Unknown
objectTemplate.cannotFireGuiIndex int -> int: Unknown
objectTemplate.cannotFireTimer float -> float: Unknown
objectTemplate.canPickup bool -> bool: Weapons; "Allows explosives to be picked up using the wrench/repair object, example: at_mine"
objectTemplate.canReverse bool -> bool: Unknown
objectTemplate.capMaxSpeed bool -> bool: Unknown
objectTemplate.castsDynamicShadow bool -> bool: "Vehicles, Weapons and Soldiers"; Enables the rendering of shadows.
objectTemplate.castsStaticShadow bool -> bool: Unknown
objectTemplate.centerOfCollisionOffset Vec3 -> Vec3: Unknown
objectTemplate.centerOfMassOffset Vec3 -> Vec3

To offset the center of mass using 0/0/0 - X/Y/Z. Setting it to X/0.5/Z will make a Logistics Truck survive a direct ram to a Van while setting to 0 makes the truck crash. Tested while holding shift.

objectTemplate.chance float -> float: AmbientObjects.con; "Chance that the triggerable effect may play when the player steps inside the radius. 1 means it will always play, while 0 means it will never play."
objectTemplate.changeLodAt float -> float: Unknown
objectTemplate.chaseAngle float -> float: Unknown
objectTemplate.chaseDistance float -> float: Unknown
objectTemplate.chaseOffset Vec3 -> Vec3: Unknown
objectTemplate.clearTemplateList -> void: Unknown
objectTemplate.clientHitDetection bool -> bool: Unknown
objectTemplate.climbableAngle float -> float: Unknown
objectTemplate.climbersAttachForce float -> float: Unknown
objectTemplate.climbingSpeed float -> float: Unknown
objectTemplate.clockwise bool -> bool: Unknown
objectTemplate.cockpitLod int -> int: Unknown
objectTemplate.cockpitLod U32 -> U32: Unknown
objectTemplate.cockpitSubGeom int -> int: Unknown
objectTemplate.cockpitSubGeom U32 -> U32: Unknown
objectTemplate.collision.bouncing bool -> bool: Unknown
objectTemplate.collision.hasCollisionEffect bool -> bool: Unknown
objectTemplate.collision.maxStickAngle float -> float: Unknown
objectTemplate.collision.replenishingStrength float -> float: Unknown
objectTemplate.collision.replenishingType ReplenishingType -> ReplenishingType: Unknown
objectTemplate.collision.restoreHP float -> float: Unknown
objectTemplate.collision.resurrectDamage float -> float: Unknown
objectTemplate.collision.stickToStaticObjects bool -> bool: Unknown
objectTemplate.collision.stickToTerrain bool -> bool: Unknown
objectTemplate.collision.stickToVehicles bool -> bool: Unknown
objectTemplate.collisionEffectName std::string -> std::string: Unknown
objectTemplate.collisionEnable bool -> bool: Unknown
objectTemplate.collisionGroups U32 -> U32: Unknown
objectTemplate.collisionMesh std::string -> void: Unknown
objectTemplate.collisionMesh std::string -> std::string: Unknown
objectTemplate.collisionPart int -> int: Unknown
objectTemplate.collisionSpeedAlongNormal float -> float: Unknown
objectTemplate.collisionSpeedAlongPlane float -> float: Unknown
objectTemplate.collisionStartRadius float -> float: Unknown
objectTemplate.color Vec3ColorFloatIntensity -> Vec3ColorFloatIntensity: Unknown
objectTemplate.color Vec3ColorFloat -> Vec3ColorFloat: Unknown
objectTemplate.color1 Vec3ColorFloatIntensity -> Vec3ColorFloatIntensity: Unknown
objectTemplate.color2 Vec3ColorFloatIntensity -> Vec3ColorFloatIntensity: Unknown
objectTemplate.colorBlendGraph Vec4 -> Vec4: Unknown
objectTemplate.coneAngle1 float -> float: Unknown
objectTemplate.coneAngle2 float -> float: Unknown
objectTemplate.coneDirection Vec3 -> Vec3: Unknown
objectTemplate.coneInnerAngle float -> float: Unknown
objectTemplate.coneOuterAngle float -> float: Unknown
objectTemplate.coneOuterVolume float -> float: Unknown
objectTemplate.constantForce float -> float: Unknown
objectTemplate.constantRpm bool -> bool: Unknown
objectTemplate.continousRotationSpeed Math: :Vec3 -> Math::Vec3; Unknown
objectTemplate.controlPointId int -> int: Unknown
objectTemplate.ControlPointId U32 -> U32: Unknown
objectTemplate.controlPointName std::string -> std::string: Unknown
objectTemplate.controlsCategory dice: :hfe::world::VehicleCategory -> dice::hfe::world::VehicleCategory; Unknown
objectTemplate.coolDownPerSec float -> float: Unknown
objectTemplate.coolingFactor float -> float: Unknown
objectTemplate.copyLinksCount int -> int: Unknown
ObjectTemplate.create std::string std::string -> IObjectTemplate*: Unknown
objectTemplate.createComponent std::string -> void: Unknown
objectTemplate.createdInEditor bool -> bool: Unknown
objectTemplate.createInvisible bool -> bool

: :Creates the object as invisible. Collisions and Functions still work. Tested on the at_mine

objectTemplate.createNotInGrid bool -> bool: Unknown
objectTemplate.createVisibleInEditor bool -> bool: Unknown
objectTemplate.crewKitIndex int -> int

:kits.con (example: gb82_pilot.con) :"Defines what Geom to use for the kit. Looks up the Geom1 etc in the .skinnedmesh which is located in the Meshes folder. For example : arg82/Meshes/arg82_kits1.skinnedmeshes. Open with BfMeshViewer to know what each number looks like."

objectTemplate.crosshairFireTime float -> float: Unknown
objectTemplate.cullRadiusScale float -> float

:"Weapons : Vehicle : Statics etc" :

objectTemplate.CVMChase bool -> bool

:Vehicles .tweak files :Used to set at what distance the object is culled from display. Each number represents a distance of 25m. For example: ObjectTemplate.cullRadiusScale 6 = VD of 150m

objectTemplate.CVMExternTrace bool -> bool

:Vehicles .tweak files :

objectTemplate.CVMFlyBy bool -> bool

:Vehicles .tweak files :

objectTemplate.CVMFrontChase bool -> bool

:Vehicles .tweak files :

objectTemplate.CVMInside bool -> bool

:Vehicles .tweak files :

objectTemplate.CVMNose bool -> bool

:Vehicles .tweak files :

objectTemplate.CVMTrace bool -> bool

:Vehicles .tweak files :

objectTemplate.cycles int -> int: Unknown
objectTemplate.damage float -> float: Unknown
objectTemplate.damagedAmbientSoundLimit float -> float: Unknown
objectTemplate.damageForBeingOutSideWorld float -> float: Unknown
objectTemplate.damageMandownSoldiers bool -> bool: Unknown
objectTemplate.damageOwner bool -> bool: Unknown
objectTemplate.damageSpeed float -> float: Unknown
objectTemplate.damageWhenLost float -> float: Unknown
objectTemplate.dampenSprintRotationalForceInAirMod float -> float: Unknown
objectTemplate.dampHorizontalVel float -> float: Unknown
objectTemplate.dampHorizontalVelFactor float -> float: Unknown
objectTemplate.damping float -> float: Unknown
objectTemplate.deAcceleration Math: :Vec3 -> Math::Vec3; Unknown
objectTemplate.debugAutoRotate bool -> bool: Unknown
objectTemplate.debugForceGearUp bool -> bool: Unknown
objectTemplate.decalTextureName std::string -> std::string: Unknown
objectTemplate.decreaseAngleToZero bool -> bool: Unknown
objectTemplate.decreaseAngleToZeroSpeed float -> float: Unknown
objectTemplate.decreaseAngleToZeroVerticalVel float -> float: Unknown
objectTemplate.defaultAngleOfAttack float -> float: Unknown
objectTemplate.defaultWeaponIndex int -> int: Unknown
objectTemplate.degradeDropStrength float -> float: Unknown
objectTemplate.degradeThrowStrength float -> float: Unknown
objectTemplate.degradeThrowStrength2 float -> float: Unknown
objectTemplate.delay RandomDistribution -> RandomDistribution: Unknown
objectTemplate.delayBeforeCycle float -> float: Unknown
objectTemplate.delayBeforeEnd float -> float: Unknown
objectTemplate.delayBeforeStart float -> float: Unknown
objectTemplate.delayToUse float -> float: Unknown
ObjectTemplate.delete world: :IObjectTemplate_ptrproxy -> void; Unknown
objectTemplate.deleteComponent std::string -> void: Unknown
objectTemplate.deployAnimationTime float -> float: Unknown
objectTemplate.destroyableWindowsTemplate std::string -> std::string: Unknown
objectTemplate.destroyOnExit bool -> bool: Unknown
objectTemplate.destroyWhenEmptyStorage bool -> bool: Unknown
objectTemplate.detonateAfterProjectileStopped bool -> bool: Unknown
objectTemplate.detonateAfterProjectileStoppedMinSpeed float -> float: Unknown
objectTemplate.detonation.allowFriendlyFireDetonation bool -> bool: Unknown
objectTemplate.detonation.detectionRadius float -> float: Unknown
objectTemplate.detonation.detonateDistanceToTarget float -> float: Unknown
objectTemplate.detonation.detonateOnWaterCollision bool -> bool: Unknown
objectTemplate.detonation.effectRotation Vec3 -> Vec3: Unknown
objectTemplate.detonation.endEffectTemplate std::string -> std::string: Unknown
objectTemplate.detonation.explosionConeAngle float -> float: Unknown
objectTemplate.detonation.explosionDamage float -> float: Unknown
objectTemplate.detonation.explosionForce float -> float: Unknown
objectTemplate.detonation.explosionInnerConeRadius float -> float: Unknown
objectTemplate.detonation.explosionLineOfSightMinimumDamage float -> float: Unknown
objectTemplate.detonation.explosionMaterial int -> int: Unknown
objectTemplate.detonation.explosionRadius float -> float: Unknown
objectTemplate.detonation.explosionSoldierLineOfSight float -> float: Unknown
objectTemplate.detonation.explosionSoldierLineOfSightHealRate float -> float: Unknown
objectTemplate.detonation.explosionSoldierLineOfSightTimer float -> float: Unknown
objectTemplate.detonation.explosionYMod float -> float: Unknown
objectTemplate.detonation.flashbangAdditiveGlowMaxAlpha float -> float: Unknown
objectTemplate.detonation.flashbangAdditiveGlowMaxHealTime float -> float: Unknown
objectTemplate.detonation.flashbangAdditiveGlowMaxHoldTime float -> float: Unknown
objectTemplate.detonation.flashbangAdditiveGlowMaxRampTime float -> float: Unknown
objectTemplate.detonation.flashbangAdditiveGlowMinAlpha float -> float: Unknown
objectTemplate.detonation.flashbangAdditiveGlowMinHealTime float -> float: Unknown
objectTemplate.detonation.flashbangAdditiveGlowMinHoldTime float -> float: Unknown
objectTemplate.detonation.flashbangBillboardMaxAlpha float -> float: Unknown
objectTemplate.detonation.flashbangBillboardMaxHealTime float -> float: Unknown
objectTemplate.detonation.flashbangBillboardMaxHoldTime float -> float: Unknown
objectTemplate.detonation.flashbangBillboardMaxRampTime float -> float: Unknown
objectTemplate.detonation.flashbangBillboardMinAlpha float -> float: Unknown
objectTemplate.detonation.flashbangBillboardMinHealTime float -> float: Unknown
objectTemplate.detonation.flashbangBillboardMinHoldTime float -> float: Unknown
objectTemplate.detonation.flashbangMotionBlurMaxAlpha float -> float: Unknown
objectTemplate.detonation.flashbangMotionBlurMaxHealTime float -> float: Unknown
objectTemplate.detonation.flashbangMotionBlurMaxHoldTime float -> float: Unknown
objectTemplate.detonation.flashbangMotionBlurMaxRampTime float -> float: Unknown
objectTemplate.detonation.flashbangMotionBlurMinAlpha float -> float: Unknown
objectTemplate.detonation.flashbangMotionBlurMinHealTime float -> float: Unknown
objectTemplate.detonation.flashbangMotionBlurMinHoldTime float -> float: Unknown
objectTemplate.detonation.flashbangRadiusWithNightVision float -> float: Unknown
objectTemplate.detonation.invisibleAtEndEffect bool -> bool: Unknown
objectTemplate.detonation.maxDepthForExplosion float -> float: Unknown
objectTemplate.detonation.minDetonationSpeed float -> float: Unknown
objectTemplate.detonation.playMaterialEffectAtSurface bool -> bool: Unknown
objectTemplate.detonation.radiusDetonateWithAirVehicles bool -> bool: Unknown
objectTemplate.detonation.replenishingStrength float -> float: Unknown
objectTemplate.detonation.replenishingType ReplenishingType -> ReplenishingType: Unknown
objectTemplate.detonation.showMineIndicationIcon bool -> bool: Unknown
objectTemplate.detonation.stopAtEndEffect bool -> bool: Unknown
objectTemplate.detonation.timeUntilCanDetonate float -> float: Unknown
objectTemplate.detonation.triggerAngle float -> float: Unknown
objectTemplate.detonation.triggerRadius float -> float: Unknown
objectTemplate.detonation.triggerTime float -> float: Unknown
objectTemplate.detonation.triggerType RadiusTriggerType -> RadiusTriggerType: Unknown
objectTemplate.detonation.triggerVictimMinSpeed float -> float: Unknown
objectTemplate.detonation.useCollisionNormal bool -> bool: Unknown
objectTemplate.detonation.useMMOnEndEffect bool -> bool: Unknown
objectTemplate.deviation.devModCrouch float -> float: Unknown
objectTemplate.deviation.devModLie float -> float: Unknown
objectTemplate.deviation.devModStand float -> float: Unknown
objectTemplate.deviation.devModZoom float -> float: Unknown
objectTemplate.deviation.fireDevAdd float -> float: Unknown
objectTemplate.deviation.fireDevMax float -> float: Unknown
objectTemplate.deviation.fireDevSub float -> float: Unknown
objectTemplate.deviation.minDev float -> float: Unknown
objectTemplate.deviation.miscDevAddJump float -> float: Unknown
objectTemplate.deviation.miscDevMax float -> float: Unknown
objectTemplate.deviation.miscDevSub float -> float: Unknown
objectTemplate.deviation.radius float -> float: Unknown
objectTemplate.deviation.setFireDev float float float -> void: Unknown
objectTemplate.deviation.setMiscDev float float float -> void: Unknown
objectTemplate.deviation.setSpeedDev float float float -> void: Unknown
objectTemplate.deviation.setTurnDev float float float -> void: Unknown
objectTemplate.deviation.speedDevAddForward float -> float: Unknown
objectTemplate.deviation.speedDevAddStrafe float -> float: Unknown
objectTemplate.deviation.speedDevMax float -> float: Unknown
objectTemplate.deviation.speedDevSub float -> float: Unknown
objectTemplate.deviation.subProjectileDev float -> float: Unknown
objectTemplate.deviation.turnDevAddPitch float -> float: Unknown
objectTemplate.deviation.turnDevAddYaw float -> float: Unknown
objectTemplate.deviation.turnDevMax float -> float: Unknown
objectTemplate.deviation.turnDevSub float -> float: Unknown
objectTemplate.differential float -> float: Unknown
objectTemplate.direction Vec3 -> Vec3: Unknown
objectTemplate.directionalScale float -> float: Unknown
objectTemplate.disableIfEnemyInsideRadius bool -> bool: Unknown
objectTemplate.disableInputWhileDucking bool -> bool: Unknown
objectTemplate.disableSpawnPointsOnEnter bool -> bool: Unknown
objectTemplate.disableWhenEmptyVehicle bool -> bool: Unknown
objectTemplate.disableWhenEmptyVehicleDelay float -> float: Unknown
objectTemplate.disableWhenLosingControl bool -> bool: Unknown
objectTemplate.disableWhenWreck bool -> bool: Unknown
objectTemplate.dismountAngle float -> float: Unknown
objectTemplate.dismountCheckOffset float -> float: Unknown
objectTemplate.distance float -> float: Unknown
objectTemplate.distanceCannotEnter float -> float: Unknown
objectTemplate.distToMinDamage float -> float: Unknown
objectTemplate.distToStartLoseDamage float -> float: Unknown
objectTemplate.dontAllowExit bool -> bool: Unknown
objectTemplate.dontClearTeamOnExit bool -> bool: Unknown
objectTemplate.drag float -> float

: :"How much the drag from the body of a vehicle affects its speed. Without it : a vehicle will have an infinite top speed."

objectTemplate.drag RandomDistribution -> RandomDistribution: Unknown
objectTemplate.dragModifier Vec3 -> Vec3: Unknown
objectTemplate.dragModifier float -> float: Unknown
objectTemplate.dragOffset Vec3 -> Vec3

: :To offset the drag using 0/0/0 - X/Y/Z

objectTemplate.dragOverTime OverTimeDistribution -> OverTimeDistribution: Unknown
objectTemplate.drawOrder std::string -> std::string: Unknown
objectTemplate.dropHeadwear std::string -> std::string: Unknown
objectTemplate.dropStrength float -> float: Unknown
objectTemplate.effectChangeWaterHeight float -> float: Unknown
objectTemplate.effectOnSpawn std::string -> std::string: Unknown
objectTemplate.effectTemplateBaseName std::string -> std::string: Unknown
objectTemplate.elasticity float -> float: Unknown
objectTemplate.emitDelay float -> float: Unknown
objectTemplate.emitDirection Vec3 -> Vec3: Unknown
objectTemplate.emitDirectionZFromSpeedDof bool -> bool: Unknown
objectTemplate.emitFrequency float -> float: Unknown
objectTemplate.emitFrequencyScaleFactorLowerBound float -> float: Unknown
objectTemplate.emitPrio std::string -> std::string: Unknown
objectTemplate.emitRadius Vec3 -> Vec3: Unknown
objectTemplate.emitRangeX RandomDistribution -> RandomDistribution: Unknown
objectTemplate.emitRangeY RandomDistribution -> RandomDistribution: Unknown
objectTemplate.emitRangeZ RandomDistribution -> RandomDistribution: Unknown
objectTemplate.emitScaleFactorFromAcceleration Vec2 -> Vec2: Unknown
objectTemplate.emitScaleFactorFromAltitude Vec2 -> Vec2: Unknown
objectTemplate.emitScaleFactorFromEngine Vec2 -> Vec2: Unknown
objectTemplate.emitScaleFactorFromRotationalSpeed Vec2 -> Vec2: Unknown
objectTemplate.emitScaleFactorFromSpeed Vec2 -> Vec2: Unknown
objectTemplate.emitScaleFactorFromSpeedInDof Vec2 -> Vec2: Unknown
objectTemplate.emitScaleFactorRange Vec2 -> Vec2: Unknown
objectTemplate.emitScaleFactorUsed bool -> bool: Unknown
objectTemplate.emitSpeed float -> float: Unknown
objectTemplate.emitSpeedGraph Vec4 -> Vec4: Unknown
objectTemplate.emitSpeedScaleFromAcceleration Vec2 -> Vec2: Unknown
objectTemplate.emitSpeedScaleFromAltitude Vec2 -> Vec2: Unknown
objectTemplate.emitSpeedScaleFromEngine Vec2 -> Vec2: Unknown
objectTemplate.emitSpeedScaleFromRotationalSpeed Vec2 -> Vec2: Unknown
objectTemplate.emitSpeedScaleFromSpeed Vec2 -> Vec2: Unknown
objectTemplate.emitSpeedScaleFromSpeedInDof Vec2 -> Vec2: Unknown
objectTemplate.emitSpeedScaleRange Vec2 -> Vec2: Unknown
objectTemplate.emitSpeedScaleUsed bool -> bool: Unknown
objectTemplate.emitterSpeedScale float -> float: Unknown
objectTemplate.emitterType std::string -> std::string: Unknown
objectTemplate.emitTime float -> float: Unknown
objectTemplate.enabled bool -> bool: Unknown
objectTemplate.enemyTicketLossWhenCaptured int -> int: Unknown
objectTemplate.engineInfluence float -> float: Unknown
objectTemplate.engineName std::string -> std::string: Unknown
objectTemplate.engineType int -> int

: :"What kind of vehicle the engine is for. Car : tank : plane ship or helicopter."

objectTemplate.entryRadius float -> float: Unknown
objectTemplate.events int -> int: Unknown
objectTemplate.exitSpeedMod float -> float: Unknown
objectTemplate.fadeInFactor float -> float: Unknown
objectTemplate.fadeOutFactor float -> float: Unknown
objectTemplate.fire.addBarrelName std::string -> void: Unknown
objectTemplate.fire.addFireRate int -> void

:"Weapons : Vehicles .tweak" :"Defines the fire mode selector. You can add three lines max of each one. 0 = Single : 1 = Burst : 2 = Auto"

objectTemplate.fire.addTimeEvent WeaponTrigger WeaponAction float -> void: Unknown
objectTemplate.fire.altFireInput io: :PlayerInputMap -> io::PlayerInputMap

: :Which PlayerInput map to use for the right-click function. Usually PIAlt

objectTemplate.fire.batchSize int -> int: Unknown
objectTemplate.fire.burstSize int -> int: Unknown
objectTemplate.fire.busyUntilButtonRelease bool -> bool: Unknown
objectTemplate.fire.detonatorObject std::string -> std::string: Unknown
objectTemplate.fire.dropLod int -> int: Unknown
objectTemplate.fire.dropWeaponAfterFiringDelay float -> float: Unknown
objectTemplate.fire.dropWeaponAfterReloadDelay float -> float: Unknown
objectTemplate.fire.fireInCameraDof bool -> bool: Unknown
objectTemplate.fire.fireInCameraDofLocked bool -> bool: Unknown
objectTemplate.fire.fireInput io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.fire.fireLaunchDelay float -> float: Unknown
objectTemplate.fire.fireLaunchDelaySoft float -> float: Unknown
objectTemplate.fire.fireStartDelay RandomDistribution -> RandomDistribution: Unknown
objectTemplate.fire.hideLod int -> int: Unknown
objectTemplate.fire.hideWeaponAfterFiringDelay float -> float: Unknown
objectTemplate.fire.hideWeaponAfterReloadDelay float -> float: Unknown
objectTemplate.fire.ignoreFireButton io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.fire.isBarrel std::string -> bool: Unknown
objectTemplate.fire.maxProjectilesInWorld int -> int

: :"The max amount of projectiles in the weapon that can be set before the engine cleans up each one. If the limit is 10 : deploying one any further will delete an existing projectile. Used for explosives : mines and maybe bullets."

objectTemplate.fire.onlyFireWhenProne bool -> bool

: :"Restricts the weapon to fire only when prone. Though when firing during prone : a player can then stand and run to deploy an explosive for example. FH2 uses these for the machine gunner kits"

objectTemplate.fire.projectileStartPosition Vec3 -> Vec3

: :Position in X/Y/Z from the crosshair or PCO from where the projectile will launch.

objectTemplate.fire.projectileStartRotation Vec3 -> Vec3: Unknown
objectTemplate.fire.pullbackTime float -> float: Unknown
objectTemplate.fire.radioMessageDelay float -> float: Unknown
objectTemplate.fire.randomRotationSpeed float -> float: Unknown
objectTemplate.fire.removeBarrelName std::string -> void: Unknown
objectTemplate.fire.roundsPerMinute int -> int: "Used in GenericFirearms (Weapons, Projectiles)"; "The rate of fire, measured in Rounds Per Minute (RPM). Must be dividable by 1800. Check: http://researchmaniacs.com/Math/Divisible-By/What-is-1800-divisible-by.html"
objectTemplate.fire.showWeaponAfterReloadDelay float -> float: Unknown
objectTemplate.fire.timeToReachMaxStrengthSlow float -> float: Unknown
objectTemplate.fire.toggleWeaponTime float -> float: Unknown
objectTemplate.fire.triggerChargesTime float -> float: Unknown
objectTemplate.fire.useDummyProjectiles bool -> bool: Unknown
objectTemplate.fixAxisSpring bool -> bool: Unknown
objectTemplate.flagTemplateTeam0 std::string -> std::string: Unknown
objectTemplate.flagTemplateTeam1 std::string -> std::string: Unknown
objectTemplate.flagTemplateTeam2 std::string -> std::string: Unknown
objectTemplate.flapLift float -> float: Unknown
objectTemplate.flicker float -> float: Unknown
objectTemplate.floaterMod float -> float: Unknown
objectTemplate.floatMaxLift float -> float: Unknown
objectTemplate.floatMinLift float -> float: Unknown
objectTemplate.follow.changePitch float -> float: Unknown
objectTemplate.follow.changeYaw float -> float: Unknown
objectTemplate.follow.maxPitch float -> float: Unknown
objectTemplate.follow.maxYaw float -> float: Unknown
objectTemplate.follow.minDist float -> float: Unknown
objectTemplate.followStiffness float -> float: Unknown
objectTemplate.force float -> float: Unknown
objectTemplate.forceSustainedFire bool -> bool: Unknown
objectTemplate.forceToWaterSurface bool -> bool: Unknown
objectTemplate.ForSoldierOnly bool -> bool: Unknown
objectTemplate.fov float -> float: Unknown
objectTemplate.gasCloudDamage float -> float: Unknown
objectTemplate.gasCloudRadiusTime float -> float: Unknown
objectTemplate.gasCloudType geom: :GasCloudType -> geom::GasCloudType; Unknown
objectTemplate.gasMaskSprintFactor float -> float: Unknown
objectTemplate.gearChangeTime float -> float: Unknown
objectTemplate.gearDown float -> float: Unknown
objectTemplate.gearDownDelay float -> float: Unknown
objectTemplate.gearDownHeight float -> float: Unknown
objectTemplate.gearDownSpeed float -> float: Unknown
objectTemplate.gearUp float -> float: Unknown
objectTemplate.gearUpDelay float -> float: Unknown
objectTemplate.gearUpHeight float -> float: Unknown
objectTemplate.gearUpSpeed float -> float: Unknown
objectTemplate.geometry std::string -> std::string: Unknown
objectTemplate.geometry.dropGeom int -> int: Unknown
objectTemplate.geometry.kit int -> int: Unknown
objectTemplate.geometry1P std::string -> void: Unknown
objectTemplate.geometry3P std::string -> void: Unknown
objectTemplate.geometryPart int -> int: Unknown
objectTemplate.getHeatBarType -> int: Unknown
objectTemplate.getPosition int -> Math: :Vec3; Unknown
objectTemplate.getRotation int -> Math: :Vec3; Unknown
objectTemplate.getTemplate int -> std::string: Unknown
objectTemplate.globalEffectLevel float -> float: Unknown
objectTemplate.gravity float -> float

: :Sets the gravity for the map. Can use minus values as well

objectTemplate.gravityGraph Vec4 -> Vec4: Unknown
objectTemplate.gravityModifier float -> float

: :Sets the gravity for the vehicle. Can use minus values as well which makes the projectile go upwards

objectTemplate.gravityModifier RandomDistribution -> RandomDistribution: Unknown
objectTemplate.gravityModifierOverTime OverTimeDistribution -> OverTimeDistribution: Unknown
objectTemplate.grip PhysicsGripFlags -> PhysicsGripFlags

: :"Set only for wheels.

- Roll grip for wheels that are not powered.
- Engine grip for wheels that are powered.
- Engine dummy grip for wheel you want to make looking like they are powered

: but actually aren't."

objectTemplate.groundContactVolume float -> float: Unknown
objectTemplate.group U32 -> U32: Unknown
objectTemplate.halfVolumeDistance float -> float: Unknown
objectTemplate.handleCollisionSpeed float -> float: Unknown
objectTemplate.hasAltEffect bool -> bool: Unknown
objectTemplate.hasCollisionPhysics bool -> bool

: :"Check for all objects that has a collision mesh. Allows it to be hit by both bullets : players and vehicles"

objectTemplate.HasGreyCapturingState bool -> bool: Unknown
objectTemplate.hasMobilePhysics bool -> bool

: :Check for objects and parts that can move.

objectTemplate.hasOnTimeEffect bool -> bool: Unknown
objectTemplate.hasOverDamage bool -> bool: Unknown
objectTemplate.hasPartner bool -> bool: Unknown
objectTemplate.hasPointPhysics bool -> void: Unknown
objectTemplate.hasRelativeOffset bool -> bool: Unknown
objectTemplate.hasResponsePhysics bool -> void: Unknown
objectTemplate.hasRestrictedExit bool -> bool: Unknown
objectTemplate.hasRotationalPointPhysics bool -> void: Unknown
objectTemplate.HDRIntensity float -> float: Unknown
objectTemplate.healSpeed float -> float: Unknown
objectTemplate.healStorageSize float -> float: Unknown
objectTemplate.heatAddWhenFire float -> float: Unknown
objectTemplate.heatIncrement float -> float: Unknown
objectTemplate.height float -> float: Unknown
objectTemplate.heightOffset float -> float: Unknown
objectTemplate.helpHud.altHelpSoundKey std::string -> std::string: Unknown
objectTemplate.helpHud.altHelpstd::stringKey std::string -> std::string: Unknown
objectTemplate.helpHud.closeToDistance int -> int: Unknown
objectTemplate.helpHud.closeToHelpSoundKeyEnemy std::string -> std::string: Unknown
objectTemplate.helpHud.closeToHelpSoundKeyFriendly std::string -> std::string: Unknown
objectTemplate.helpHud.closeToHelpSoundKeyNeutral std::string -> std::string: Unknown
objectTemplate.helpHud.closeToHelpstd::stringKeyEnemy std::string -> std::string: Unknown
objectTemplate.helpHud.closeToHelpstd::stringKeyFriendly std::string -> std::string: Unknown
objectTemplate.helpHud.closeToHelpstd::stringKeyNeutral std::string -> std::string: Unknown
objectTemplate.helpHud.helpSoundKey std::string -> std::string: Unknown
objectTemplate.helpHud.helpstd::stringKey std::string -> std::string: Unknown
objectTemplate.helpHud.lowAmmoHelpSoundKey std::string -> std::string: Unknown
objectTemplate.helpHud.lowAmmoHelpstd::stringKey std::string -> std::string: Unknown
objectTemplate.helpHud.lowArmorHelpSoundKey std::string -> std::string: Unknown
objectTemplate.helpHud.lowArmorHelpstd::stringKey std::string -> std::string: Unknown
objectTemplate.hideFirstPerson bool -> bool: Unknown
objectTemplate.hoistFlag bool -> bool: Unknown
objectTemplate.hoistMinMax Vec2 -> Vec2: Unknown
objectTemplate.holdObject bool -> bool: Unknown
objectTemplate.horizontalDampAngle float -> float: Unknown
objectTemplate.horizontalDampAngleFactor float -> float: Unknown
objectTemplate.horizontalSpeedMagnifier float -> float: Unknown
objectTemplate.hullHeight float -> float: Unknown
objectTemplate.ik.poleVectorLeft Vec3 -> Vec3: Unknown
objectTemplate.ik.poleVectorRight Vec3 -> Vec3: Unknown
objectTemplate.ik.positionLeft Vec3 -> Vec3: Unknown
objectTemplate.ik.positionRight Vec3 -> Vec3: Unknown
objectTemplate.ik.rotationLeft Vec3 -> Vec3: Unknown
objectTemplate.ik.rotationRight Vec3 -> Vec3: Unknown
objectTemplate.inertiaModifier Vec3 -> Vec3: Unknown
ObjectTemplate.info world: :IObjectTemplate_ptrproxy -> std::string; Unknown
objectTemplate.inheritHeatFromPrimary bool -> bool: Unknown
objectTemplate.initiallyWalkable bool -> bool: Unknown
objectTemplate.input io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.inputToPitch io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.inputToRoll io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.inputToYaw io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.insideDamageFrequency float -> float: Unknown
objectTemplate.insideDamageThreshold float -> float: Unknown
objectTemplate.insideFOV float -> float: Unknown
objectTemplate.insideStaticSunAmbientColor Vec3ColorFloatIntensity -> Vec3ColorFloatIntensity: Unknown
objectTemplate.insideStaticSunColor Vec3ColorFloatIntensity -> Vec3ColorFloatIntensity: Unknown
objectTemplate.insideStaticSunDamageColor Vec3ColorFloatIntensity -> Vec3ColorFloatIntensity: Unknown
objectTemplate.insideStaticSunDirection Vec3 -> Vec3: Unknown
objectTemplate.intensity float -> float: Unknown
objectTemplate.intensity RandomDistribution -> RandomDistribution: Unknown
objectTemplate.intensityAtSpeed float -> float: Unknown
objectTemplate.intensityOverTime OverTimeDistribution -> OverTimeDistribution: Unknown
objectTemplate.inventorySize U32 -> U32: Unknown
objectTemplate.inverseHeatBar bool -> bool: Unknown
objectTemplate.invertGear bool -> bool: Unknown
objectTemplate.invisible bool -> bool: Unknown
objectTemplate.is3dSound bool -> bool

: :"If the .wav file is Mono : setting it to 1 will tell the engine to play it on both channels. If applied to a .wav that is Stereo : it will play on the entire map. Same with .ogg files though it's usually experiementation."

objectTemplate.isCounterForce bool -> bool: Unknown
objectTemplate.isDestructable bool -> bool

: :Check only if object is a destroyable static object.

objectTemplate.isDynamic bool -> bool: Unknown
objectTemplate.isGasMask bool -> bool: Unknown
objectTemplate.isHemisphere bool -> bool: Unknown
objectTemplate.isLocalSystem bool -> bool

: :"Makes the effect follow the projectile and allows it to arch. Used for the M67 ""Zippo"" Tank Flamethrower Effect. Without it : the flame effect just shoots straight but not following the projectile"

objectTemplate.isLooping bool -> bool: Unknown
objectTemplate.isNightVision bool -> bool: Unknown
objectTemplate.isNotSaveable bool -> bool: Unknown
objectTemplate.isOpenVehicle bool -> bool

: :"Allows the ragdoll to slide off when killed from a vehicle position. Used in Technicals. If this is option : the passenger animation must have a die animation specified otherwise the ragdolls will float in the air."

objectTemplate.isOvergrowth bool -> bool: Unknown
objectTemplate.isPortalPassing bool -> bool: Unknown
objectTemplate.isSelectable bool -> bool: Unknown
objectTemplate.isSleeping bool -> bool: Unknown
objectTemplate.isStatic bool -> bool: Unknown
objectTemplate.isStaticSystem bool -> bool: Unknown
objectTemplate.isUnderwaterEffect bool -> bool: Unknown
objectTemplate.isUnstrategicControlPoint bool -> bool: Unknown
objectTemplate.itemIndex int -> int

: :"What number in the keyboard is mapped to what weapon/tool. Max is 9 : not sure about 0. Also positions the weapon icon square."

objectTemplate.itemType int -> int: Unknown
objectTemplate.keepProjectiles float -> float

:Weapons :Time to keep the projectile in the world in seconds after you or the weapon dies

objectTemplate.killHeatSeekingMissile bool -> bool: Unknown
objectTemplate.kitTeam int -> int: Unknown
objectTemplate.kitType hfe: :KitType -> hfe::KitType; Unknown
objectTemplate.lesserYawAtSpeed float -> float: Unknown
objectTemplate.liftRegulated bool -> bool: Unknown
objectTemplate.LightAffectionFactor float -> float: Unknown
objectTemplate.lightMapIntensityOffset float -> float: Unknown
objectTemplate.lightType std::string -> std::string: Unknown
objectTemplate.linkAttachMovement float -> float: Unknown
objectTemplate.linkAttachTime float -> float: Unknown
objectTemplate.linkedEffectContainer std::string -> std::string: Unknown
ObjectTemplate.list std::string -> std::string: Unknown
objectTemplate.listenerObstruction float -> float

:Vehicles .tweak :How muffled is the sound. Lower value is least muffled.

ObjectTemplate.listTemplateClasses -> std::string: Unknown
objectTemplate.listTemplates -> std::string: Unknown
ObjectTemplate.loadAll -> bool: Unknown
objectTemplate.localPredictOnClient bool -> bool

: :"Used with Grenades and if there's any effect : projectiles. Seems like it tells the server to predict what's going to happen. Maybe used with the Networkable Setting?"

objectTemplate.lodDistance float -> float: Unknown
objectTemplate.LodDistance std::string -> std::string: Unknown
objectTemplate.loopCount int -> int: Unknown
objectTemplate.looping bool -> bool: Unknown
objectTemplate.loseControlWhenEnemyClose bool -> bool: Unknown
objectTemplate.loseControlWhenNotClose bool -> bool: Unknown
objectTemplate.lowSamples int -> int: Unknown
objectTemplate.maintainCameraOnEnter bool -> bool: Unknown
objectTemplate.maintainCameraOnExit bool -> bool: Unknown
objectTemplate.manDownCameraOffsetInDof float -> float: Unknown
objectTemplate.manDownCameraOffsetInUp float -> float: Unknown
objectTemplate.mapMaterial uint std::string uint -> void: Unknown
objectTemplate.maskOffset Vec3 -> Vec3: Unknown
objectTemplate.maskType hfe: :MaskObjectType -> hfe::MaskObjectType; Unknown
objectTemplate.mass float -> float

:"Used in Vehicles : Deployables etc" :Mass is the weight of the vehicle in KG and also taking into account the GravityModifier value

objectTemplate.material int -> int: Unknown
objectTemplate.maxAngleOfAttack float -> float: Unknown
objectTemplate.maxCorner Vec3 -> Vec3: Unknown
objectTemplate.maxDistance float -> float: Unknown
objectTemplate.maxDistanceUnderWaterSurface float -> float: Unknown
objectTemplate.maxGasCloudRadius float -> float: Unknown
objectTemplate.maxNrOfObjectSpawned U32 -> U32: Unknown
objectTemplate.maxResetSpeed Math: :Vec3 -> Math::Vec3; Unknown
objectTemplate.MaxRopeLength float -> float

: :Fastropes confirmed ?!?!?!?!

objectTemplate.maxRotation Math: :Vec3 -> Math::Vec3; Unknown
objectTemplate.maxSpawnDelay float -> float: Unknown
objectTemplate.maxSpeed Math: :Vec3 -> Math::Vec3; Unknown
objectTemplate.maxSpeed float -> float: Unknown
objectTemplate.maxTracerScaler float -> float

:Used in Projectiles (Weapons) :How long the tracer effect can be depending on projectile speed. Refs: http://www.battlefieldsingleplayer.com/forum/index.php?showtopic=8592&mode=threaded&pid=84936

objectTemplate.maxTriggerDistance float -> float: Unknown
objectTemplate.maxVertRegAngle float -> float: Unknown
objectTemplate.MaxZiplineLength float -> float: Unknown
objectTemplate.mediumSamples int -> int: Unknown
objectTemplate.minCorner Vec3 -> Vec3: Unknown
objectTemplate.minDamage float -> float: Unknown
objectTemplate.minDistance float -> float: Unknown
objectTemplate.minDistanceUnderWaterSurface float -> float: Unknown
objectTemplate.minGasCloudRadius float -> float: Unknown
objectTemplate.minimapNameOffset Vec2 -> Vec2: Unknown
objectTemplate.minimumTimeBetweenTriggering float -> float

:AmbientObjects.con (Map) :The time when the trigger will repeat again after entering the trigger radius. Happens after the effect plays. In seconds. Depends also on ObjectTemplate.chance

objectTemplate.minNrToTakeControl U32 -> U32: Unknown
objectTemplate.minRotation Math: :Vec3 -> Math::Vec3; Unknown
objectTemplate.minSpawnDelay float -> float: Unknown
objectTemplate.minTimeBetweenActivation float -> float: Unknown
objectTemplate.minTracerScaler float -> float: Unknown
objectTemplate.minTrailVelocity float -> float: Unknown
objectTemplate.minYNormal float -> float: Unknown
objectTemplate.movementSpeed float -> float: Unknown
objectTemplate.movementType int -> int: Unknown
objectTemplate.moveToWaterSurface bool -> bool: Unknown
objectTemplate.name -> std::string: Unknown
objectTemplate.nameTagOffset Vec3 -> Vec3: Unknown
objectTemplate.nearCullingEnable bool -> bool: Unknown
objectTemplate.networkableInfo std::string -> std::string

:Networkables.con :"Needs to be set for objects that won't work online without them. Depends on the way it's set and if it crashes immediately : is laggy : or crashes unexpectantly"

objectTemplate.neverDrawAs1p bool -> bool

:"Vehicle : Weapons : Effects" :Makes the effect not draw in front of you when in 1p mode. Link: http://www.realitymod.com/forum/f388-pr-bf2-community-modding/113277-1p-animations-pcos-3.html

objectTemplate.newCar2.brakeTorque float -> float: Unknown
objectTemplate.newCar2.engineBrakeTorque float -> float: Unknown
objectTemplate.newCar2.engineFeedbackMod float -> float: Unknown
objectTemplate.newCar2.frictionMod float -> float: Unknown
objectTemplate.newCar2.frictionTorque float -> float: Unknown
objectTemplate.newCar2.maxRpm float -> float: Unknown
objectTemplate.newCar2.minRpm float -> float: Unknown
objectTemplate.newCar2.slopeTorqueMod float -> float: Unknown
objectTemplate.newCar2.useClutchedTorque bool -> bool: Unknown
objectTemplate.newCar2.wheelInertia float -> float: Unknown
objectTemplate.newCar2.wheelLatDriveFrictionMod float -> float: Unknown
objectTemplate.newCar2.wheelLatFrictionMod float -> float: Unknown
objectTemplate.newCar2.wheelLatMinDynamicFriction float -> float: Unknown
objectTemplate.newCar2.wheelLatPeakAt float -> float: Unknown
objectTemplate.newCar2.wheelLatScale float -> float: Unknown
objectTemplate.newCar2.wheelLongDriveFrictionMod float -> float: Unknown
objectTemplate.newCar2.wheelLongFrictionMod float -> float: Unknown
objectTemplate.newCar2.wheelLongMinDynamicFriction float -> float: Unknown
objectTemplate.newCar2.wheelLongPeakAt float -> float: Unknown
objectTemplate.newCar2.wheelLongScale float -> float: Unknown
objectTemplate.noEffectAtPerpSpeed float -> float: Unknown
objectTemplate.noPassengerTimeToLive int -> int: Unknown
objectTemplate.noPhysics bool -> bool: Unknown
objectTemplate.noPropellerEffectAtSpeed float -> float: Unknown
objectTemplate.nosePos Vec3 -> Vec3: Unknown
objectTemplate.notCycledIfOccupied bool -> bool: Unknown
objectTemplate.noVertRegAngle float -> float: Unknown
objectTemplate.nrOfObjectToSpawn int -> int: Unknown
objectTemplate.nrOfRespawns int -> int: Unknown
objectTemplate.numberOfGears int -> int: Unknown
objectTemplate.NumberOfLinks int -> int: Unknown
objectTemplate.numNetworkedEffects int -> int: Unknown
objectTemplate.numPlanes int -> int: Unknown
objectTemplate.objectShadows bool -> bool: Unknown
objectTemplate.objectTemplate std::string -> std::string: Unknown
objectTemplate.onlyTakeableByTeam U32 -> U32: Unknown
objectTemplate.onlyWhenOccupied bool -> bool: Unknown
objectTemplate.otherCollisionLod int -> int: Unknown
objectTemplate.overheatPenalty float -> float: Unknown
objectTemplate.pan float -> float: Unknown
objectTemplate.ParticleMaxSize float -> float

:Used in Vehicle .con and .tweak files :"Defines what materials the vehicle should use : which references the materialdefine file. Use BfMeshViewer to find out what numbers belong to what sides."

objectTemplate.particleSystemTemplate std::string -> std::string

:Same as above :Same as above

objectTemplate.particleType std::string -> std::string: Unknown
objectTemplate.pcoFlags int -> int: Unknown
objectTemplate.pcoId int -> int: Unknown
objectTemplate.penetrate.allowLiquidPenetration bool -> bool: Unknown
objectTemplate.penetrate.allowSolidPenetration bool -> bool

: :

objectTemplate.penetrate.neverPenetrate bool -> bool: Unknown
objectTemplate.physicsFrequency int -> int: Unknown
objectTemplate.physicsType PhysicsType -> PhysicsType

:Vehicles :"None' for no collision : 'Point' for projectile (Ignores mesh) : 'Mesh' if object has collision mesh"

objectTemplate.pitch float -> float: Unknown
objectTemplate.pitchEnvelope std::string -> std::string: Unknown
objectTemplate.pitchOffset float -> float: Unknown
objectTemplate.pivotOffset Vec2 -> Vec2: Unknown
objectTemplate.PivotPosition Math: :Vec3 -> Math::Vec3; Unknown
objectTemplate.playAtEventPosition bool -> bool: Unknown
objectTemplate.playAtPlayerPosition bool -> bool: Unknown
objectTemplate.portalPassingPosition Vec3 -> Vec3: Unknown
objectTemplate.poseCameraPosition int Vec3 -> void: Unknown
objectTemplate.position Vec3 -> Vec3: Unknown
objectTemplate.positionalSpeedInDof RandomDistribution -> RandomDistribution: Unknown
objectTemplate.positionalSpeedInRight RandomDistribution -> RandomDistribution: Unknown
objectTemplate.positionalSpeedInUp RandomDistribution -> RandomDistribution: Unknown
objectTemplate.positionOffset Math: :Vec3 -> Math::Vec3; Unknown
objectTemplate.postProcess.tvDistortionFreq float -> float: Unknown
objectTemplate.postProcess.tvDistortionRoll float -> float: Unknown
objectTemplate.postProcess.tvDistortionScale float -> float: Unknown
objectTemplate.postProcess.tvInterference float -> float: Unknown
objectTemplate.preCacheObject bool -> bool: Unknown
objectTemplate.preWarmTime float -> float: Unknown
ObjectTemplate.printScript world: :IObjectTemplate_ptrproxy -> std::string; Unknown
objectTemplate.projectileTemplate std::string -> std::string

:"In Weapons : Vehicles .tweak GenericFirearm" :Defines the projectile that the GenericFirearm should use. Looks for the GenericProjectile that is defined in all .tweak files.

objectTemplate.projectOnHeightmap bool -> bool: Unknown
objectTemplate.projectorApplyMask bool -> bool: Unknown
objectTemplate.projectorAspect float -> float: Unknown
objectTemplate.projectorFar float -> float: Unknown
objectTemplate.projectorFov float -> float: Unknown
objectTemplate.projectorNear float -> float: Unknown
objectTemplate.projectorTexture std::string -> std::string: Unknown
objectTemplate.propRotAxis int -> int: Unknown
objectTemplate.pureRotational bool -> bool: Unknown
objectTemplate.QualityLevel std::string -> std::string: Unknown
objectTemplate.radialDirection float -> float: Unknown
objectTemplate.radio.destroyedMessage std::string -> std::string: Unknown
objectTemplate.radio.failMessage std::string -> std::string: Unknown
objectTemplate.radio.repairedMessage std::string -> std::string: Unknown
objectTemplate.radio.spottedMessage std::string -> std::string: Unknown
objectTemplate.radio.useMessage std::string -> std::string: Unknown
objectTemplate.radius float -> float: Unknown
objectTemplate.radiusOffset Vec3 -> Vec3: Unknown
objectTemplate.ragdollLandedDelay float -> float: Unknown
objectTemplate.randomAgeFactor RandomDistribution -> RandomDistribution: Unknown
objectTemplate.randomColorIntensity float -> float: Unknown
objectTemplate.randomDirectionAngle Vec3 -> Vec3: Unknown
objectTemplate.randomIntensity float -> float: Unknown
objectTemplate.randomizeGeomPart bool -> bool: Unknown
objectTemplate.randomRadialDirection float -> float: Unknown
objectTemplate.randomRotation float -> float: Unknown
objectTemplate.randomRotation Vec3 -> Vec3: Unknown
objectTemplate.randomRotationSpeed Vec3 -> Vec3: Unknown
objectTemplate.randomRotationSpeed float -> float: Unknown
objectTemplate.randomSize float -> float: Unknown
objectTemplate.randomSpeed float -> float: Unknown
objectTemplate.randomTimeToLive float -> float: Unknown
objectTemplate.rcType RemoteControlledObjectType -> RemoteControlledObjectType: Unknown
objectTemplate.readBinary std::string -> void: Unknown
objectTemplate.recoil.cameraRecoilSize float -> float: Unknown
objectTemplate.recoil.cameraRecoilSpeed float -> float: Unknown
objectTemplate.recoil.goBackOnRecoil bool -> bool: Unknown
objectTemplate.recoil.hasRecoilForce bool -> bool: Unknown
objectTemplate.recoil.recoilForce float -> float: Unknown
objectTemplate.recoil.recoilForceLeftRight RandomDistribution -> RandomDistribution: Unknown
objectTemplate.recoil.recoilForceUp RandomDistribution -> RandomDistribution: Unknown
objectTemplate.recoil.recoilGraphExponent float -> float: Unknown
objectTemplate.recoil.recoilGraphFrameCount int -> int: Unknown
objectTemplate.recoil.recoilGraphTotalMovement float -> float: Unknown
objectTemplate.recoil.recoilSize float -> float: Unknown
objectTemplate.recoil.recoilSpeed float -> float: Unknown
objectTemplate.recoil.recoilSpeedGB float -> float: Unknown
objectTemplate.recoil.zoomModifier float -> float: Unknown
objectTemplate.refillAmmoSpeed float -> float: Unknown
objectTemplate.regulatePitch Vec2 -> Vec2: Unknown
objectTemplate.regulatePitchInput io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.regulateRoll Vec2 -> Vec2: Unknown
objectTemplate.regulateRollInput io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.regulateToLift float -> float: Unknown
objectTemplate.regulateVerticalPos Vec2 -> Vec2: Unknown
objectTemplate.regulateVerticalPosInput io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.regulateYaw Vec2 -> Vec2: Unknown
objectTemplate.regulateYawInput io: :PlayerInputMap -> io::PlayerInputMap

:In the effects .tweak when creating an effect :Allows an effect template to be used with custom settings.

objectTemplate.regWhenMinInput float -> float: Unknown
objectTemplate.relativePositionInDof RandomDistribution -> RandomDistribution: Unknown
objectTemplate.relativePositionInRight RandomDistribution -> RandomDistribution: Unknown
objectTemplate.relativePositionInUp RandomDistribution -> RandomDistribution: Unknown
objectTemplate.relativePositionOffset Vec3 -> Vec3: Unknown
objectTemplate.rememberExcessInput bool -> bool: Unknown
objectTemplate.remoteEngineInput int -> int: Unknown
objectTemplate.removeTemplate int -> void: Unknown
objectTemplate.replaceItem std::string -> void

:In the .con and .tweak :

objectTemplate.respawnDelay float -> float

:In the .con and .tweak :

objectTemplate.restoreRotationOnExit bool -> bool: Unknown
objectTemplate.restoreSpeed float -> float: Unknown
objectTemplate.reverbLevel float -> float: Unknown
objectTemplate.ropeScaleFactor float -> float: Unknown
objectTemplate.rotateAsAnimatedUV bool -> bool: Unknown
objectTemplate.rotateAsAnimatedUVObject std::string -> std::string: Unknown
objectTemplate.rotateAsAnimatedUVReverse bool -> bool: Unknown
objectTemplate.rotateUV bool -> bool: Unknown
objectTemplate.rotation float -> float: Unknown
objectTemplate.rotationalForce Vec3 -> Vec3: Unknown
objectTemplate.rotationalSpeedInDof RandomDistribution -> RandomDistribution: Unknown
objectTemplate.rotationalSpeedInRight RandomDistribution -> RandomDistribution: Unknown
objectTemplate.rotationalSpeedInUp RandomDistribution -> RandomDistribution: Unknown
objectTemplate.rotationAxle int -> int: Unknown
objectTemplate.rotationGraph Vec4 -> Vec4: Unknown
objectTemplate.rotationSpeed Vec3 -> Vec3: Unknown
objectTemplate.rotationSpeed float -> float: Unknown
objectTemplate.rotationSpeedMod float -> float: Unknown
objectTemplate.rotationSpeedModBlur float -> float: Unknown
ObjectTemplate.save world: :IObjectTemplate_ptrproxy -> bool; Unknown
ObjectTemplate.saveAll -> bool: Unknown
objectTemplate.saveInSeparateFile bool -> bool: Unknown
objectTemplate.scale Vec3 -> Vec3: Unknown
objectTemplate.seatAnimationSystem std::string -> std::string

:In Vehicles .tweak :Defines the location of the .inc animation file for the seat. Example: Passenger.inc

objectTemplate.seatInformation std::string Vec3 Vec3 -> void: Unknown
objectTemplate.seatLeftRotationLimit float -> float: Unknown
objectTemplate.seatParent std::string -> std::string: Unknown
objectTemplate.seatPosition Vec3 -> Vec3: Unknown
objectTemplate.seatRightRotationLimit float -> float: Unknown
objectTemplate.seatRotation Vec3 -> Vec3

:In Vehicles .tweak :Allows the PCO to be rotated. Uses X/Y/Z. Relevant to Seat X Y Z Arrow. See BF2Editor Vehicle for more info. For example -10/0/0 wil rotate the player backwards.

objectTemplate.secondaryProjectileTemplate std::string -> std::string: Unknown
objectTemplate.seek.directionBonus float -> float: Unknown
objectTemplate.seek.maxAngleLock float -> float: Unknown
objectTemplate.seek.maxDistLock float -> float: Unknown
objectTemplate.seek.reLockTime float -> float: Unknown
objectTemplate.seek.targetType TargetType -> TargetType: Unknown
objectTemplate.seek.trackingDelay float -> float: Unknown
objectTemplate.selfLights bool -> bool: Unknown
objectTemplate.selfShadowIntensity float -> float: Unknown
objectTemplate.selfShadows bool -> bool: Unknown
objectTemplate.setActiveTemplate int -> void: Unknown
objectTemplate.setAIEnterOnSpawn bool -> void: Unknown
objectTemplate.setAllowSpawnCloseToVehicle bool -> void: Unknown
objectTemplate.setAnimationFrameHeightRelative float -> void: Unknown
objectTemplate.setAnimationFrameWidthRelative float -> void: Unknown
objectTemplate.setAxisFixation Math: :Vec3 -> void; Unknown
objectTemplate.setCollisionMesh std::string -> void: Unknown
objectTemplate.setEnterOnSpawn bool -> void: Unknown
objectTemplate.setExplodePartAtDestroy bool -> void: Unknown
objectTemplate.setGearRatios float float float -> void: Unknown
objectTemplate.setHasTarget bool -> void: Unknown
objectTemplate.setHealth int float float -> void: Unknown
objectTemplate.setHeatBarType heatBarType -> void: Unknown
objectTemplate.setMinSpawnHeight float -> void: Unknown
objectTemplate.setNumWindows int -> void: Unknown
objectTemplate.setObjectTemplate int std::string -> void: Unknown
objectTemplate.setOnlyForAI bool -> void: Unknown
objectTemplate.setOnlyForHuman bool -> void: Unknown
objectTemplate.setPosition Math: :Vec3 int -> void; Unknown
objectTemplate.setPositionalFixation Math: :Vec3 -> void; Unknown
objectTemplate.setRotation Math: :Vec3 int -> void; Unknown
objectTemplate.setScatterSpawnPositions bool -> void: Unknown
objectTemplate.setSkeletonCollisionBone std::string int Vec3 -> void: Unknown
objectTemplate.setSoldierExitLocation Vec3 Vec3 -> void: Unknown
objectTemplate.setSpawnAsParaTroper bool -> void: Unknown
objectTemplate.setSpawnDelay float -> void: Unknown
objectTemplate.setSpawnPositionOffset Math: :Vec3 -> void; Unknown
objectTemplate.setSpawnPreventionDelay float -> void: Unknown
objectTemplate.setSpawnRotation Math: :Vec3 -> void; Unknown
objectTemplate.setTeamGeometry int std::string -> void: Unknown
objectTemplate.setToolTipType dice: :hfe::world::ToolTipType -> void; Unknown
objectTemplate.setVehicleType dice: :hfe::world::VehicleType -> void; Unknown
objectTemplate.shadowIntensity float -> float: Unknown
objectTemplate.shakeFactor float -> float: Unknown
objectTemplate.sharedStorageSize float -> float: Unknown
objectTemplate.showInFirstPerson bool -> bool: Unknown
objectTemplate.showInThirdPerson bool -> bool: Unknown
objectTemplate.showOnMinimap bool -> bool: Unknown
objectTemplate.signalTriggerId int -> int: Unknown
objectTemplate.sinkingSpeedMod float -> float: Unknown
objectTemplate.size float -> float: Unknown
objectTemplate.size RandomDistribution -> RandomDistribution: Unknown
objectTemplate.sizeGraph Vec4 -> Vec4: Unknown
objectTemplate.sizeModifier Vec3 -> Vec3: Unknown
objectTemplate.sizeModifierX float -> float: Unknown
objectTemplate.sizeModifierY float -> float: Unknown
objectTemplate.sizeModifierZ float -> float: Unknown
objectTemplate.sizeOverTime OverTimeDistribution -> OverTimeDistribution: Unknown
objectTemplate.skeleton std::string -> void: Unknown
objectTemplate.skeleton1P std::string -> void: Unknown
objectTemplate.skeleton3P std::string -> void: Unknown
objectTemplate.snapToZeroOnNoInput bool -> bool: Unknown
objectTemplate.softness float -> float: Unknown
objectTemplate.soldierExitPosition Vec3 -> Vec3: Unknown
objectTemplate.soldierExitRotation Vec3 -> Vec3: Unknown
objectTemplate.sound.maxSoundsPerBurst int -> int: Unknown
objectTemplate.sound.noisy bool -> bool: Unknown
objectTemplate.soundFilename std::string -> std::string: Unknown
objectTemplate.soundFilter std::string -> std::string: Unknown
objectTemplate.soundIntensityFromAcceleration Vec2 -> Vec2: Unknown
objectTemplate.soundIntensityFromAltitude Vec2 -> Vec2: Unknown
objectTemplate.soundIntensityFromEngine Vec2 -> Vec2: Unknown
objectTemplate.soundIntensityFromRotationalSpeed Vec2 -> Vec2: Unknown
objectTemplate.soundIntensityFromSpeed Vec2 -> Vec2: Unknown
objectTemplate.soundIntensityFromSpeedInDof Vec2 -> Vec2: Unknown
objectTemplate.soundIntensityRange Vec2 -> Vec2: Unknown
objectTemplate.soundIntensityUsed bool -> bool: Unknown
objectTemplate.soundRadius float -> float: Unknown
objectTemplate.spawnDelay float -> void: Unknown
objectTemplate.spawnDelayAtStart bool -> bool: Unknown
objectTemplate.spawnOffset Vec3 -> Vec3: Unknown
objectTemplate.speccolor Vec3ColorFloatIntensity -> Vec3ColorFloatIntensity: Unknown
objectTemplate.specialToggleWeaponInput io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.speed float -> float: Unknown
objectTemplate.speedFromParticle float -> float: Unknown
objectTemplate.speedFromPhysics bool -> bool: Unknown
objectTemplate.spinWhenNoEngineInAir float -> float: Unknown
objectTemplate.sprintDissipationTime float -> float: Unknown
objectTemplate.sprintFactor float -> float: Unknown
objectTemplate.sprintGear1Dampen float -> float: Unknown
objectTemplate.sprintGear2Dampen float -> float: Unknown
objectTemplate.sprintGear3Dampen float -> float: Unknown
objectTemplate.sprintGear4Dampen float -> float: Unknown
objectTemplate.sprintGear5Dampen float -> float: Unknown
objectTemplate.sprintLimit float -> float: Unknown
objectTemplate.sprintLossAtJump float -> float: Unknown
objectTemplate.sprintRecoverTime float -> float: Unknown
objectTemplate.sprintStaminaDissipationFactor float -> float: Unknown
objectTemplate.startAgeFromAcceleration Vec2 -> Vec2: Unknown
objectTemplate.startAgeFromAltitude Vec2 -> Vec2: Unknown
objectTemplate.startAgeFromEngine Vec2 -> Vec2: Unknown
objectTemplate.startAgeFromRotationalSpeed Vec2 -> Vec2: Unknown
objectTemplate.startAgeFromSpeed Vec2 -> Vec2: Unknown
objectTemplate.startAgeFromSpeedInDof Vec2 -> Vec2: Unknown
objectTemplate.startAgeRange Vec2 -> Vec2: Unknown
objectTemplate.startAgeUsed bool -> bool: Unknown
objectTemplate.startAtCreation bool -> bool: Unknown
objectTemplate.startAutoRotateOnEnter bool -> bool: Unknown
objectTemplate.startDelay float -> float: Unknown
objectTemplate.startDistance float -> float: Unknown
objectTemplate.startLodPercentageOfLodDistance float -> float: Unknown
objectTemplate.startOnEffects int -> int: Unknown
objectTemplate.startProbability float -> float: Unknown
objectTemplate.startRotation RandomDistribution -> RandomDistribution: Unknown
objectTemplate.startTeam int -> int: Unknown
objectTemplate.stopOnEffects int -> int: Unknown
objectTemplate.stopType int -> int: Unknown
objectTemplate.strategicObject.3dMapIcon int -> int: Unknown
objectTemplate.strategicObject.destroyedIcon std::string -> std::string: Unknown
objectTemplate.strategicObject.intactIcon std::string -> std::string: Unknown
objectTemplate.strategicObject.isOnePiece bool -> bool: Unknown
objectTemplate.strategicObject.part int -> int: Unknown
objectTemplate.strategicObject.strategicObjectName std::string -> std::string: Unknown
objectTemplate.strength float -> float: Unknown
objectTemplate.supplyGroupId int -> int: Unknown
objectTemplate.supplyGroupNeeded int int bool -> void: Unknown
objectTemplate.supplyValueNeededTeam1 int -> int: Unknown
objectTemplate.supplyValueNeededTeam2 int -> int: Unknown
objectTemplate.supplyValueTeam1 int -> int: Unknown
objectTemplate.supplyValueTeam2 int -> int: Unknown
objectTemplate.supportsEmitter bool -> bool: Unknown
objectTemplate.supportsGlow bool -> bool: Unknown
objectTemplate.supportsPerPixel bool -> bool: Unknown
objectTemplate.supportsPerVertex bool -> bool: Unknown
objectTemplate.target.connectionEffect std::string -> std::string: Unknown
objectTemplate.target.connectionEffectOnlyWhenZoomed bool -> bool: Unknown
objectTemplate.target.disableFireWhenActiveMissile bool -> bool: Unknown
objectTemplate.target.disableGuidanceOnReload bool -> bool: Unknown
objectTemplate.target.lockAngle float -> float: Unknown
objectTemplate.target.lockDelay float -> float: Unknown
objectTemplate.target.loseLockDelay float -> float: Unknown
objectTemplate.target.maxDistance float -> float: Unknown
objectTemplate.target.maxVelocity float -> float: Unknown
objectTemplate.target.minVelocity float -> float: Unknown
objectTemplate.target.onLockChangeToWeapon bool std::string -> void: Unknown
objectTemplate.target.sendVehicleLockWarning bool -> bool: Unknown
objectTemplate.target.setTargetAtMaxDistance bool -> bool: Unknown
objectTemplate.target.targetInput io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.target.targetObjectTemplate std::string -> std::string: Unknown
objectTemplate.target.targetSystem TargetSystem -> TargetSystem: Unknown
objectTemplate.target.updateInterval float -> float: Unknown
objectTemplate.target.useCameraDirectionToTarget bool -> bool: Unknown
objectTemplate.target.useDynamicVelocity bool -> bool: Unknown
objectTemplate.target.velocityModifier float -> float: Unknown
objectTemplate.targetType TargetType -> TargetType: Unknown
objectTemplate.team int -> int: Unknown
objectTemplate.team U32 -> U32: Unknown
objectTemplate.team int -> void: Unknown
objectTemplate.teamChange bool -> bool: Unknown
objectTemplate.teamFromClosestCP bool -> bool: Unknown
objectTemplate.teamOnVehicle bool -> bool: Unknown
objectTemplate.template std::string -> std::string: Unknown
objectTemplate.templateHasBeenUsed bool -> bool: Unknown
objectTemplate.textureName std::string -> std::string: Unknown
objectTemplate.textureOffsetVelocity float -> float: Unknown
objectTemplate.textureTileFactor float -> float: Unknown
objectTemplate.throwStrength float -> float: Unknown
objectTemplate.throwStrength2 float -> float: Unknown
objectTemplate.Timeout float -> float: Unknown
objectTemplate.timeToGetControl float -> float: Unknown
objectTemplate.timeToLive RandomDistribution -> RandomDistribution: Unknown
objectTemplate.timeToLive float -> float: Unknown
objectTemplate.timeToLiveAfterDeath float -> float: Unknown
objectTemplate.timeToLoseControl float -> float: Unknown
objectTemplate.timeToRemoveTK float -> float: Unknown
objectTemplate.toggleMouseLook bool -> bool: Unknown
objectTemplate.toggleWeapon bool -> bool: Unknown
objectTemplate.tolerance float -> float: Unknown
objectTemplate.torque float -> float: Unknown
objectTemplate.tracerConvergeDistance float -> float

:Used in Projectiles (Weapons) :"At what distance the tracers (which start from the gunbarrel) and the projectile : which start from the camera : converges. Only relevant if FireInCameraDof is checked."

objectTemplate.tracerInterval int -> int

:Used in Projectiles (Weapons) :"Set one for tracer on every shot : 2 for every other and so on."

objectTemplate.tracerScaler float -> float

:Used in Projectiles (Weapons) :How long the tracer effect will be as default.

objectTemplate.tracerSizeModifier float -> float

:Used in Projectiles (Weapons) :How fat the tracer will be.

objectTemplate.tracerTemplate std::string -> std::string: Unknown
objectTemplate.trackTurnAcceleration float -> float: Unknown
objectTemplate.trackTurnHighAmplitude float -> float: Unknown
objectTemplate.trackTurnHighOffset float -> float: Unknown
objectTemplate.trackTurnLowAmplitude float -> float: Unknown
objectTemplate.trackTurnLowOffset float -> float: Unknown
objectTemplate.trackTurnSpeed float -> float: Unknown
objectTemplate.trailEffectTemplate std::string -> std::string: Unknown
objectTemplate.Transparency RandomDistribution -> RandomDistribution: Unknown
objectTemplate.transparencyGraph Vec4 -> Vec4: Unknown
objectTemplate.treeCollisionDiameter float -> float: Unknown
objectTemplate.triggerForEachActivatingPlayer bool -> bool: Unknown
objectTemplate.triggerId int -> int: Unknown
objectTemplate.triggerRadius float -> float: Unknown
objectTemplate.turnVelocity float -> float: Unknown
ObjectTemplate.type world: :IObjectTemplate_ptrproxy -> std::string; Unknown
objectTemplate.type int -> int: Unknown
objectTemplate.uavVehicleFlightHeight float -> float: Unknown
objectTemplate.uavVehicleRadius float -> float: Unknown
objectTemplate.uavVehicleSampleResolution float -> float: Unknown
objectTemplate.uavVehicleSpeed float -> float: Unknown
objectTemplate.uavVehicleTemplate std::string -> std::string: Unknown
objectTemplate.unableToChangeTeam bool -> bool: Unknown
objectTemplate.unlockIndex int -> int: Unknown
objectTemplate.unlockLevel int -> int: Unknown
ObjectTemplate.update world: :IObjectTemplate_ptrproxy -> void; Unknown
ObjectTemplate.updateAll -> void: Unknown
objectTemplate.upDropBoost float -> float: Unknown
objectTemplate.upThrowBoost float -> float: Unknown
objectTemplate.upThrowBoost2 float -> float: Unknown
objectTemplate.useAbsoluteDirection bool -> bool: Unknown
objectTemplate.useButtonRadius float -> float: Unknown
objectTemplate.useCameraOrientation bool -> bool: Unknown
objectTemplate.usedByAi bool -> bool: Unknown
objectTemplate.useDeAcceleration bool -> bool: Unknown
objectTemplate.usedOnTransparentMaterials bool -> bool: Unknown
objectTemplate.usedOnTransparentSurface bool -> bool: Unknown
objectTemplate.useGeomPart int -> int: Unknown
objectTemplate.useProjectileCamera bool -> bool: Unknown
objectTemplate.vehicleCameraShake CameraShakeTriggers -> CameraShakeTriggers: Unknown
objectTemplate.vehicleCategory dice: :hfe::world::VehicleCategory -> dice::hfe::world::VehicleCategory; Unknown
objectTemplate.vehicleFov float -> float: Unknown
objectTemplate.vehicleHud.AbilityIcon std::string -> std::string: Unknown
objectTemplate.vehicleHud.addAbilityIcon std::string -> void: Unknown
objectTemplate.vehicleHud.addShowOnCamMode int -> void: Unknown
objectTemplate.vehicleHud.addVehicleIcon std::string -> void: Unknown
objectTemplate.vehicleHud.disableOnSprint bool -> bool: Unknown
objectTemplate.vehicleHud.displaySelectionOnEnter bool -> bool: Unknown
objectTemplate.vehicleHud.enablePostProcessingOnGuiIndex bool -> bool: Unknown
objectTemplate.vehicleHud.getShowOnCamMode int -> bool: Unknown
objectTemplate.vehicleHud.guiIndex int -> int

:Vehicles and Weapons .tweak :Defines the Vehicle General User Inferface Index to use like the Blackhawk green HUD. Gui Index is located in the .cons of menu\HUD\HudSetup\Vehicles

objectTemplate.vehicleHud.hasTurretIcon bool -> bool: Unknown
objectTemplate.vehicleHud.hudName std::string -> std::string: Unknown
objectTemplate.vehicleHud.injurySound std::string -> std::string: Unknown
objectTemplate.vehicleHud.isCoDriver bool -> bool: Unknown
objectTemplate.vehicleHud.maxClimbSpeed int -> int: Unknown
objectTemplate.vehicleHud.miniMapIcon std::string -> std::string: Unknown
objectTemplate.vehicleHud.miniMapIconLeaderSize std::string -> std::string: Unknown
objectTemplate.vehicleHud.miniMapIconSize int -> int: Unknown
objectTemplate.vehicleHud.pantingSound std::string -> std::string: Unknown
objectTemplate.vehicleHud.showCrossHair bool -> bool: Unknown
objectTemplate.vehicleHud.showInfo bool -> bool: Unknown
objectTemplate.vehicleHud.showOnCamMode int -> int: Unknown
objectTemplate.vehicleHud.spottedIcon std::string -> std::string: Unknown
objectTemplate.vehicleHud.spottedIconSize int -> int: Unknown
objectTemplate.vehicleHud.standardHelpEnabled bool -> bool: Unknown
objectTemplate.vehicleHud.typeIcon std::string -> std::string: Unknown
objectTemplate.vehicleHud.useChildHud bool -> bool: Unknown
objectTemplate.vehicleHud.usePlayerIcon bool -> bool: Unknown
objectTemplate.vehicleHud.useSelectionIcons bool -> bool: Unknown
objectTemplate.vehicleHud.useVehicleCommRose bool -> bool: Unknown
objectTemplate.vehicleHud.vehicleIcon std::string -> std::string: Unknown
objectTemplate.vehicleHud.vehicleIconPos Vec2 -> Vec2: Unknown
objectTemplate.vehicleHud.vehicleType int -> int: Unknown
objectTemplate.velocity float -> float

:"Used in GenericFirearms (Weapons : Projectiles)" :"The speed of the projectile : measured in Rate of Fire (ROF). Lower ROF are affected by gravity/bullet drop while higher ones fire with lower bullet drop"

objectTemplate.visibleOn3dMap bool -> bool: Unknown
objectTemplate.volume float -> float

: :The loudness of the sound.

objectTemplate.volumeEnvelope std::string -> std::string: Unknown
objectTemplate.volumeGroup int -> int: Unknown
objectTemplate.warningHud.firstWarningSound std::string -> std::string

:Used in Vehicle .tweak :Defines the 1st warning sound when getting locked onto. Uses the file path pointing to a .wav or an .ogg file along with usual sound configuration code. 'Beep Beep Beep'

objectTemplate.warningHud.secondWarningSound std::string -> std::string

:Used in Vehicle .tweak :Defines the 2nd warning sound when getting locked onto. Uses the file path pointing to a .wav or an .ogg file along with usual sound configuration code. 'Beeeeeeeeeeep'

objectTemplate.warningHud.warningIcon std::string -> std::string

:Used in Vehicle .tweak :Defines the location of the warning icon. Example: ObjectTemplate.WarningHud.warningIcon Ingame\GeneralIcons\Action_Icons\mylaserlockicon.tga

objectTemplate.warningHud.warningType int -> int: Unknown
objectTemplate.waterHeight float -> float: Unknown
objectTemplate.waterSurfaceOffset float -> float: Unknown
objectTemplate.weaponHud.addShowOnCamMode int -> void: Unknown
objectTemplate.weaponHud.altCrosshairIcon std::string -> std::string: Unknown
objectTemplate.weaponHud.altGuiIndex int -> int: Unknown
objectTemplate.weaponHud.altWeaponIcon std::string -> std::string: Unknown
objectTemplate.weaponHud.ammoBarBackIcon std::string -> std::string: Unknown
objectTemplate.weaponHud.ammoBarFrontIcon std::string -> std::string: Unknown
objectTemplate.weaponHud.ammoIcon std::string -> std::string: Unknown
objectTemplate.weaponHud.clipIcon std::string -> std::string: Unknown
objectTemplate.weaponHud.crosshairIcon std::string -> std::string: Unknown
objectTemplate.weaponHud.crosshairIconSize int -> int: Unknown
objectTemplate.weaponHud.deviationFactor int -> int: Unknown
objectTemplate.weaponHud.disableOnSprint bool -> bool

:Used in Weapons/Vehicles .tweak :

objectTemplate.weaponHud.displaySelectOnActivation bool -> bool: Unknown
objectTemplate.weaponHud.enableMouse bool -> bool: Unknown
objectTemplate.weaponHud.enablePostProcessingOnGuiIndex int -> int

:Used in Weapons/Vehicles .tweak :Makes the GuiIndex have a black and white effect. Use with all objectTemplate.postProcess.tv code to adjust the TV effect

objectTemplate.weaponHud.firstLockSound std::string -> std::string

: :The first lock sound that plays when there is a lock in progress on the jet

objectTemplate.weaponHud.getShowOnCamMode int -> bool: Unknown
objectTemplate.weaponHud.guiIndex int -> int

:"Used in Weapons : Vehicle .tweak" :Defines the Weapon General User Inferface Index to use like the repair bar. Gui Index is located in the .cons of menu\HUD\HudSetup\Vehicles

objectTemplate.weaponHud.hasFireRate bool -> bool

:Used in Weapons .tweak :

objectTemplate.weaponHud.hasMag bool -> bool: Unknown
objectTemplate.weaponHud.hasRangeFinder bool -> bool: Unknown
objectTemplate.weaponHud.hudName std::string -> std::string: Unknown
objectTemplate.weaponHud.maxVisualDeviation int -> int: Unknown
objectTemplate.weaponHud.minVisualDeviation int -> int: Unknown
objectTemplate.weaponHud.overheatSound std::string -> std::string

:"Used in Weapons : Vehicle .tweak" :"For the overheat sound. Adding it makes the engine reference the std::string defined with MenuSound.con. Usually it's S_Weapon_Handheld_Overheat : S_Vehicle_Handheld_Overheat but can be anything and custom ones can be used if needed"

objectTemplate.weaponHud.secondLockSound std::string -> std::string

:"Used in Weapons : Vehicle .tweak" :The second lock sound that plays when the lock has been set

objectTemplate.weaponHud.selectIcon std::string -> std::string: Unknown
objectTemplate.weaponHud.showAmmo bool -> bool: Unknown
objectTemplate.weaponHud.ShowClips bool -> bool: Unknown
objectTemplate.weaponHud.showInfo bool -> bool: Unknown
objectTemplate.weaponHud.showOnCamMode int -> int: Unknown
objectTemplate.weaponHud.specialAbilityIcon std::string -> std::string: Unknown
objectTemplate.weaponHud.switchGuiOnCamera bool -> bool: Unknown
objectTemplate.weaponHud.weaponIcon std::string -> std::string: Unknown
objectTemplate.weaponType int -> int: Unknown
objectTemplate.widnBlowTime float -> float: Unknown
objectTemplate.windAffectionFactor float -> float: Unknown
objectTemplate.windAgingFactor float -> float: Unknown
objectTemplate.windBlowTime float -> float: Unknown
objectTemplate.windDirection Vec3 -> Vec3: Unknown
objectTemplate.windFalloff float -> float: Unknown
objectTemplate.windIsDynamic bool -> bool: Unknown
objectTemplate.windowSizeVector Vec3 -> Vec3

:"Used in Projectiles : Vehicles : Effect" :

objectTemplate.windRadialFalloff float -> float: Unknown
objectTemplate.windSpeed float -> float: Unknown
objectTemplate.windSpeedAgeDistance float -> float: Unknown
objectTemplate.windType std::string -> std::string: Unknown
objectTemplate.wingLift float -> float

:"Planes : Helis" :How much speed will affect object lifting on control surface.

objectTemplate.wingToRegulatorRatio float -> float: Unknown
objectTemplate.workOnSoldiers bool -> bool

:Supply Objects :Allows the soldier to receive HP/Ammo depending on the type of supply set

objectTemplate.workOnVehicles bool -> bool

:Supply Objects :Allows the vehicle to receive HP/Ammo depending on the type of supply set

objectTemplate.worldFOV float -> float: Unknown
objectTemplate.writeBinary std::string -> void: Unknown
objectTemplate.writeZ bool -> bool: Unknown
objectTemplate.yawSpeed float -> float: Unknown
objectTemplate.ziplineSoldierHeight float -> float: Unknown
objectTemplate.zoom.addZoomFactor float -> void: Unknown
objectTemplate.zoom.allowUntoggledFire bool -> bool: Unknown
objectTemplate.zoom.changeCameraId int -> int: Unknown
objectTemplate.zoom.changeCameraViewMode CameraViewMode -> CameraViewMode: Unknown
objectTemplate.zoom.changeFovDelay float -> float: Unknown
objectTemplate.zoom.disableMuzzleWhenZoomed bool -> bool: Unknown
objectTemplate.zoom.mouseSpeedMod float -> float: Unknown
objectTemplate.zoom.onlyZoomWhenProne bool -> bool: Unknown
objectTemplate.zoom.startCameraId int -> int: Unknown
objectTemplate.zoom.startCameraViewMode CameraViewMode -> CameraViewMode: Unknown
objectTemplate.zoom.useProjectileCamera bool -> bool: Unknown
objectTemplate.zoom.zoomDelay float -> float: Unknown
objectTemplate.zoom.zoomInput io: :PlayerInputMap -> io::PlayerInputMap; Unknown
objectTemplate.zoom.zoomLod int -> int: Unknown
objectTemplate.zoom.zoomOutAfterFire bool -> bool: Unknown
objectTemplate.zRotation RandomDistribution -> RandomDistribution: Unknown
objectTemplate.zRotationSnap float -> float: Unknown
object.togglePause -> void: Unknown

overgrowth

overgrowth.addMaterial std::string uint -> bool: Unknown
overgrowth.addType std::string -> bool: Unknown
overgrowth.closeDistFade float -> float: Unknown
overgrowth.closeDistPercentage float -> float: Unknown
overgrowth.editorEnable float -> float: Unknown
overgrowth.exportToTerrainTexture -> void: Unknown
overgrowth.generateAll -> void: Unknown
overgrowth.generateAtlas -> void: Unknown
overgrowth.getActiveMaterialName -> std::string: Unknown
overgrowth.getGeometryList -> std::string: Unknown
overgrowth.getLodDistance -> float: Unknown
overgrowth.getMaterialList -> std::string: Unknown
overgrowth.getTypeList -> std::string: Unknown
overgrowth.lodTimer float -> float: Unknown
overgrowth.paintMaterial float float float -> void: Unknown
overgrowth.paintShadowmap float float float -> void: Unknown
overgrowth.path std::string -> std::string: Unknown
overgrowth.postLoad -> void: Unknown
overgrowth.preLoad -> void: Unknown
overgrowth.removeActiveMaterial -> bool: Unknown
overgrowth.removeActiveType -> bool: Unknown
overgrowth.save -> void: Unknown
overgrowth.setActiveMaterial std::string -> void: Unknown
overgrowth.setActiveType std::string -> void: Unknown
overgrowthType.density float -> float: Unknown
overgrowthType.geometry std::string -> std::string: Unknown
overgrowthType.minRadiusToOthers float -> float: Unknown
overgrowthType.minRadiusToSame float -> float: Unknown
overgrowthType.normalScale float -> float: Unknown
overgrowthType.randomScale Vec2 -> Vec2: Unknown
overgrowthType.rotationScale float -> float: Unknown
overgrowth.viewDistance float -> float: Unknown
overgrowth.viewDistanceScale float -> float: Unknown
Particles.enableOldParticles bool -> bool: Unknown
Particles.enableParticles bool -> bool: Unknown

particleSystemManager

particleSystemManager.affectedByWind bool -> bool: Unknown
particleSystemManager.drawBoundingBoxEnable bool -> bool: Unknown
particleSystemManager.drawStats bool -> bool: Unknown
particleSystemManager.generateTexture -> bool: Unknown
particleSystemManager.overdrawScale float -> float: Unknown
particleSystemManager.particleSystemShaderQuality uint -> uint: Unknown
particleSystemManager.qualityLevel int -> int: Unknown
particleSystemManager.resetStats -> void: Unknown
particleSystemManager.startFadePercentageOfViewDistance float -> float: Unknown
particleSystemManager.startLodPercentageOfLodDistance float -> float: Unknown
particleSystemManager.viewDistance float -> float: Unknown
physics.airDensityZeroAtHeight float -> float: Unknown
physics.gravity float -> float: Unknown
physics.listProperties -> std::string: Unknown
physics.wind Vec3 -> Vec3: Unknown

Player

Player.active IPlayer* -> IPlayer*: Unknown
Player.create std::string std::string -> IPlayer*: Unknown
player.isAi bool -> bool: Unknown
player.isAlive bool -> bool: Unknown
player.isNetwork bool -> bool: Unknown
player.kit int -> int: Unknown
Player.list -> std::string: Unknown
Player.listPlayerClasses -> std::string: Unknown
player.moveTo Vec3 -> std::string: Unknown
player.name -> std::string: Unknown
player.pickup std::string -> void: Unknown
Player.saveAll std::string -> bool: Unknown
player.setFov float float -> void: Unknown
player.setVehicleWithInputId IObject_ptrproxy int -> bool: Unknown
player.spawnGroup int -> int: Unknown
player.team int -> int: Unknown
player.vehicle IObject_ptrproxy -> IObject_ptrproxy: Unknown
portal.debugLevel int -> int: Unknown
portal.showStats bool -> bool: Unknown

profile

profile.activateCharacterProfile std::string -> bool: Unknown
profile.activatePlayerProfile std::string -> bool: Unknown
profile.activeCharacterProfile std::string -> std::string: Unknown
profile.activeMod std::string -> std::string: Unknown
profile.activePlayerProfile std::string -> std::string: Unknown
profile.addCharacterProfile std::string -> bool: Unknown
profile.addModSetting std::string -> bool: Unknown
profile.applySettings -> void: Unknown
profile.createPlayerProfile std::string -> bool: Unknown
profile.defaultKit int -> int: Unknown
profile.getIndexForKit std::string int -> void: Unknown
profile.playerName std::string -> std::string: Unknown
profile.rank int -> int: Unknown
profile.setIndexForKit std::string int int -> void: Unknown
profile.tagIcon std::string -> std::string: Unknown
profile.tagText std::string -> std::string: Unknown
profile.visualUnlockLevel int -> int: Unknown

pythonHost

pythonHost.reinitialize -> bool: Unknown
pythonHost.sendCommand std::string std::string std::string -> bool: Unknown

radio

radio.answer bool -> void: Unknown
radio.callForAmmo -> void: Unknown
radio.callForMedic -> void: Unknown
radio.callForRepair -> void: Unknown
radioInterface.selectOrder std::string -> bool: Unknown
radioInterface.setstd::stringMap std::string std::string std::string -> void: Unknown
radio.sendKitMessage -> void: Unknown
radio.sendSpottedMessage bool world: :VehicleType -> void; Unknown
radio.setSpottedMenuActive -> void: Unknown
radioVehicleInterface.selectOrder std::string -> bool: Unknown
radioVehicleInterface.setstd::stringMap std::string std::string std::string -> void: Unknown
ragDoll.active bool -> void: Unknown
ragDoll.addAngularConstraint int int int -> void: Unknown
ragDoll.addBone int int -> void: Unknown
ragDoll.addCapsuleCollision int int -> void: Unknown
ragDoll.addConstraint int int -> void: Unknown
ragDoll.addDihedralAngleConstraint int int int -> void: Unknown
ragDoll.addDistanceLessThanConstraint int int float -> void: Unknown
ragDoll.addForce int Vec3 -> void: Unknown
ragDoll.addJointConstraint int int -> void: Unknown
ragDoll.addParticle int float -> void: Unknown
ragDoll.drawConstraints bool -> void: Unknown
ragDoll.gravity float -> void: Unknown
ragDoll.linkMode int int -> void: Unknown
ragDoll.lockBone int int -> void: Unknown
ragDoll.removeConstraint int int -> void: Unknown
ragDoll.reset -> void: Unknown
ragDoll.save -> void: Unknown
ragDoll.setParticleCollisionCriteria float float -> void: Unknown
ragDoll.skeleton std::string -> void: Unknown
ragDoll.toSkeleton int int int -> void: Unknown

renderer

renderer.allowA2M bool -> bool: Unknown
renderer.allowOnDemandPostProcessing bool -> bool: Unknown
renderer.ambientIlluminationRange Vec4 -> Vec4: Unknown
renderer.ambientSun bool -> bool: Unknown
renderer.clearColor BaseVector3<int> -> BaseVector3<int>: Unknown
renderer.coronaFadeSpeed float -> float: Unknown
renderer.disableFadeOnRoads bool -> bool: Unknown
renderer.distanceCullConst float -> float: Unknown
renderer.distanceCullConstPCO float -> float: Unknown
renderer.divAccum float -> float: Unknown
renderer.draw1pMeshes bool -> bool: Unknown
renderer.draw1pZOnly bool -> bool: Unknown
renderer.drawBundledMeshes bool -> bool: Unknown
renderer.drawConsole bool -> bool: Turns off access to the in-game console if set to 0
renderer.drawDeferred bool -> bool: Unknown
renderer.drawFps int -> int: Displays the current frames per seconds and the time in milliseconds between frames
renderer.drawGraphs bool -> bool: Unknown
renderer.drawHud bool -> bool: Turns the heads up display (HUD) on or off
renderer.drawNametags bool -> bool: Unknown
renderer.drawObjects bool -> bool: Unknown
renderer.drawOvergrowth bool -> bool: Unknown
renderer.drawParticles bool -> bool: Unknown
renderer.drawPostProduction bool -> bool: Unknown
renderer.drawRoads bool -> bool: Unknown
renderer.drawSkinnedMeshes bool -> bool: Unknown
renderer.drawSkyDome bool -> bool: Unknown
renderer.drawStaticMeshes bool -> bool: Unknown
renderer.drawSunFlare bool -> bool: Unknown
renderer.drawTerrain bool -> bool: Unknown
renderer.drawTrees bool -> bool: Unknown
renderer.drawUndergrowth bool -> bool: Unknown
renderer.drawWatermark bool -> bool: Unknown
renderer.dumpScreen std::string -> void: Unknown
renderer.enableHWOcclusion bool -> bool: Unknown
renderer.fakeHDRBlendingFactor float -> float: Unknown
renderer.fakeHDRBlendingTimeDark double -> double: Unknown
renderer.fakeHDRBlendingTimeLight double -> double: Unknown
renderer.fakeHDREnabled bool -> bool: Unknown
renderer.fakeHDRHorizWeights std::string -> std::string: Unknown
renderer.fakeHDRPassGate float -> float: Unknown
renderer.fakeHDRVertWeights std::string -> std::string: Unknown
renderer.fakeHDRWeights std::string -> std::string: Unknown
Renderer.fieldOfView1p float -> float: Unknown
renderer.fogColor Vec3 -> Vec3: Unknown
renderer.fogStartEndAndBase Vec4 -> Vec4: Unknown
renderer.forceBundledMeshLod int -> int: Unknown
renderer.forceSkinnedMeshLod int -> int: Unknown
renderer.forceStaticMeshMaxPolyPercentage int -> int: Unknown
renderer.forceStaticMeshSkipLod int -> int: Unknown
renderer.getQualityLodDistanceBM int -> float: Unknown
renderer.getQualityLodDistanceSKM int -> float: Unknown
renderer.getQualityLodDistanceSTM int -> float: Unknown
renderer.globalBundleMeshLodDistanceScale float -> float: Unknown
renderer.globalSkinnedMeshLodDistanceScale float -> float: Unknown
renderer.globalStaticMeshLodDistanceScale float -> float: Unknown
renderer.glowEnabled bool -> bool: Unknown
renderer.glowStrength float -> float: Unknown
renderer.isNightMap bool -> bool: Unknown
renderer.lightBlurStrength float -> float: Unknown
renderer.listScreenModes -> void: Unknown
renderer.makeTopWorldScreen U32 std::string Vec3 -> void: Unknown
renderer.minCullDistance float -> float: Unknown
renderer.nightMode uint -> uint: Unknown
renderer.nightVisionEnabled bool -> bool: Unknown
renderer.nightVisionGradient std::string -> std::string: Unknown
renderer.nightVisionMaxPower float -> float: Unknown
renderer.nightVisionRegenRPS float -> float: Unknown
renderer.occlusionObjectsMaxFrames int -> int: Unknown
renderer.occlusionTerrainMaxFrames int -> int: Unknown
renderer.presentAsync bool -> bool: Unknown
renderer.presentSpinIfBusy bool -> bool: Unknown
renderer.qualityLodEnabled bool -> bool: Unknown
renderer.renderAheadLimit uint -> uint: Unknown
renderer.roadDepthBias float -> float: Unknown
renderer.roadLodDistMod float -> float: Unknown
renderer.roadSlopeScaleDepthBias float -> float: Unknown
renderer.screenDumpPath std::string -> std::string: Unknown
renderer.screenMode int -> int: Unknown
renderer.setQualityLodDistanceALL int float -> void: Unknown
renderer.setQualityLodDistanceBM int float -> void: Unknown
renderer.setQualityLodDistanceSKM int float -> void: Unknown
renderer.setQualityLodDistanceSTM int float -> void: Unknown
Renderer.soldier.debugCharacterMode int -> int: Unknown
Renderer.soldier.debugDrawCollision bool -> bool: Unknown
Renderer.soldier.debugDrawSkeletons bool -> bool: Unknown
renderer.stopRenderMovie -> void: Unknown
renderer.tearGasStrength float -> float: Unknown
renderer.tvAmbient float -> float: Unknown
renderer.tvColor Vec3 -> Vec3: Unknown
renderer.tvEnabled bool -> bool: Unknown
renderer.tvGranularity float -> float: Unknown
renderer.tvInterference float -> float: Unknown
renderer.tweakFarPlane1p float -> float: Unknown
renderer.tweakNearPlane float -> float: Unknown
renderer.tweakNearPlane1p float -> float: Unknown
renderer.vsync bool -> bool: Unknown
renderer.waterAnimSpeed float -> float

: :Sets the water speed.

renderer.waterColor Vec3 -> Vec3: Unknown
renderer.waterFogColor Vec3 -> Vec3: Unknown
renderer.waterFogStartEndAndBase Vec4 -> Vec4: Unknown
renderer.watermarkFilename std::string -> std::string: Unknown
renderer.watermarkPos Vec2 -> Vec2: Unknown
renderer.watermarkScale float -> float: Unknown
renderer.waterNormalMap std::string -> std::string: Unknown
renderer.waterScroll Vec2 -> Vec2: Unknown
renderer.waterSpecularColor Vec4 -> Vec4: Unknown
renderer.waterSpecularPower float -> float: Unknown
renderer.xpPerfFlags int -> int: Unknown
renderer.xpPerfFlags2 int -> int: Unknown
reservedSlots.addNick std::string -> void: Unknown
reservedSlots.clear -> void: Unknown
reservedSlots.configFile std::string -> std::string: Unknown
reservedSlots.list -> std::string: Unknown
reservedSlots.load -> bool: Unknown
reservedSlots.removeNick std::string -> void: Unknown
reservedSlots.save -> bool: Unknown

scoreboard

scoreboard.setToggleShow int -> void: Unknown
scoreboard.singleClick int -> void: Unknown

scoreManager

scoreManager.ammo int -> int: Unknown
scoreManager.ammoScoreLimit float -> float: Unknown
scoreManager.assistKill int -> int: Unknown
scoreManager.controlPointCapture int -> int: Unknown
scoreManager.death int -> int: Unknown
scoreManager.driverPassenger int -> int: Unknown
scoreManager.flagCapture int -> int: Unknown
scoreManager.flagReturn int -> int: Unknown
scoreManager.heal int -> int: Unknown
scoreManager.healScoreLimit float -> float: Unknown
scoreManager.inDirectKill int -> int: Unknown
scoreManager.kill int -> int: Unknown
scoreManager.objective int -> int: Unknown
scoreManager.repair int -> int: Unknown
scoreManager.repairScoreLimit float -> float: Unknown
scoreManager.soldierRevive int -> int: Unknown
scoreManager.teamDamage int -> int: Unknown
scoreManager.teamDamageLimit float -> float: Unknown
scoreManager.teamVehicleDamage int -> int: Unknown
scoreManager.teamVehicleDamageLimit float -> float: Unknown
scoreManager.TK int -> int: Unknown
scoreManager.vehicleRevive int -> int: Unknown
SettingsManager.boolGet std::string -> bool: Unknown
SettingsManager.boolSet std::string bool -> bool: Unknown
SettingsManager.floatGet std::string -> float: Unknown
SettingsManager.floatSet std::string float -> bool: Unknown
SettingsManager.intGet std::string -> int: Unknown
SettingsManager.intSet std::string int -> bool: Unknown
SettingsManager.std::stringGet std::string -> std::string: Unknown
SettingsManager.std::stringSet std::string std::string -> bool: Unknown
SettingsManager.U32Get std::string -> U32: Unknown
SettingsManager.U32Set std::string U32 -> bool: Unknown

shadermanager

shadermanager.byPassDiceStates bool -> bool: Unknown
shadermanager.compileDebugTerrain bool -> bool: Unknown
shadermanager.compilePartialPrecisionTypes bool -> bool: Unknown
shadermanager.compileSkipOptimizations bool -> bool: Unknown
shadermanager.compileUsePartialPrecision bool -> bool: Unknown
shadermanager.compileUsePreShaders bool -> bool: Unknown
shadermanager.compileUsePS2A bool -> bool: Unknown
shadermanager.compileWithDebug bool -> bool: Unknown
shadermanager.listEffects -> void: Unknown
shadermanager.reloadAllEffects -> void: Unknown
shadermanager.reloadEffect std::string -> void: Unknown
shadowManager.allowAlphaShadows bool -> bool: Unknown
shadowManager.alphaShadowThreshold float -> float: Unknown
shadowManager.dropShadowClipHeightOffset float -> float: Unknown
shadowManager.dynamic1pShadowsEnabled bool -> bool: Unknown
shadowManager.dynamicShadowsEnabled bool -> bool: Unknown
shadowManager.dynamicStaticMeshShadowsEnabled bool -> bool: Unknown
shadowManager.lightmapIntensityBias float -> float: Unknown
shadowManager.occludedSkyNightIntensity float -> float: Unknown
shadowManager.shadow80Line float -> float: Unknown
shadowManager.shadowFromBundledMeshLod int -> int: Unknown
shadowManager.shadowFromSkinnedMeshLod int -> int: Unknown
shadowManager.shadowFromStaticMeshLod int -> int: Unknown
shadowManager.shadowFromTerrainLod int -> int: Unknown
shadowManager.shadowIntensityBias float -> float: Unknown
shadowManager.shadowMapBitDepth int -> int: Unknown
shadowManager.shadowMapDepthBias float -> float: Unknown
shadowManager.shadowMapDepthDistance float -> float: Unknown
shadowManager.shadowMapIncludeStaticMeshes bool -> bool: Unknown
shadowManager.shadowMapObjectSize int -> int: Unknown
shadowManager.shadowMapSize int -> int: Unknown
shadowManager.shadowMapSlopeBias float -> float: Unknown
shadowManager.shadowMergeDynamicShadowFrustums bool -> bool: Unknown
shadowManager.shadowOccluderOversizeFactor float -> float: Unknown
shadowManager.shadowOverrideQuality int -> int: Unknown
shadowManager.shadowPSMFovY float -> float: Unknown
shadowManager.shadowPSMUseSlideback bool -> bool: Unknown
shadowManager.shadowPSMUseUnitCubeClipping bool -> bool: Unknown
shadowManager.shadowPSMZFarOffset float -> float: Unknown
shadowManager.shadowPSMZMinInfinityZ float -> float: Unknown
shadowManager.shadowPSMZNearOffset float -> float: Unknown
shadowManager.shadowShowFrustums bool -> bool: Unknown
shadowManager.shadowSunExtrusionLength float -> float: Unknown
shadowManager.shadowSunHeightOverFade Vec2 -> Vec2: Unknown
shadowManager.shadowSunScalePower float -> float: Unknown
shadowManager.shadowTestBelowRayLenght float -> float: Unknown
shadowManager.shadowTSMFocus float -> float: Unknown
shadowManager.shadowUpdateFactor float -> float: Unknown
shadowManager.shadowUpdatesEnabled bool -> bool: Unknown
shadowManager.shadowUseSweepTest bool -> bool: Unknown
shadowManager.useLSSMOptimizations bool -> bool: Unknown
shadowManager.usePSMOptimizations bool -> bool: Unknown
skinnedMeshRenderer.shaderQuality ShaderQuality -> ShaderQuality: Unknown
skyDome.cloudLerpFactors Vec2 -> Vec2: Unknown
skyDome.cloudTemplate std::string -> std::string: Unknown
skyDome.cloudTexture std::string -> std::string: Unknown
skyDome.cloudTexture2 std::string -> std::string: Unknown
skyDome.domePosition Vec3 -> Vec3: Unknown
skyDome.domeRotation float -> float: Unknown
skyDome.domeSize float -> float: Unknown
skyDome.fadeCloudsDistances Vec2 -> Vec2: Unknown
skyDome.flareDirection Vec3 -> Vec3: Unknown
skyDome.flareFadeAdd float -> float: Unknown
skyDome.flareFadeMul float -> float: Unknown
skyDome.flareTemplate std::string -> std::string: Unknown
skyDome.flareTexture std::string -> std::string

:Map: Sky.con :"The texture of the sunflare/actual sunflare. When switching to a map with no sunflare : it will still use the previous maps one. So for maps like Fallujah West/Saaremaa : an invisible texture needs to be defined instead to prevent the sunflare bug. Usage: Skydome.flareTexture common\textures\sunflare\Sunglow_no"

skyDome.hasCloudLayer bool -> bool: Unknown
skyDome.hasCloudLayer2 bool -> bool: Unknown
skyDome.lightingBlend float -> float: Unknown
skyDome.lightingColor Vec3 -> Vec3: Unknown
skyDome.scrollDirection Vec2 -> Vec2: Unknown
skyDome.scrollDirection2 Vec2 -> Vec2: Unknown
skyDome.skyTemplate std::string -> std::string: Unknown
skyDome.skyTexture std::string -> std::string: Unknown
sound.addMenuSound std::string std::string float -> void: Unknown
sound.addSound std::string -> void: Unknown
sound.addTrigger std::string -> void: Unknown
sound.dopplerEffect float -> float: Unknown
sound.getAllSoundTemplates -> std::string: Unknown
sound.getProperty std::string -> std::string: Unknown
sound.getVolumeForGroup int -> float: Unknown
sound.initialize int std::string int -> SoundInitResult: Unknown
sound.interactiveMode bool -> bool: Unknown
sound.listenerReverb float -> float: Unknown
sound.loadMusic std::string -> bool: Unknown
sound.masterVolume float -> float: Unknown
sound.playMusic -> bool: Unknown
sound.playSound std::string -> void: Unknown
sound.removeAllTriggers -> void: Unknown
sound.setProperty std::string float -> void: Unknown
sound.setReverb std::string -> void: Unknown
sound.setVolumeForGroup int float -> void: Unknown
sound.showSoundSources bool -> bool: Unknown
sound.showStats bool -> bool: Unknown
Sound.startEngines bool -> bool: Unknown
sound.stopMusic float -> bool: Unknown
sound.stopSound std::string -> void: Unknown
sound.tinnitusSetup std::string float float -> void: Unknown
sound.tweakTemplate std::string float float -> void: Unknown
sound.windSetup std::string float -> void: Unknown
spawnManager.commitSuicide -> void: Unknown
spawnManager.listSpawnGroups -> void: Unknown
spawnManager.selectNextUnlock int -> void: Unknown
spawnManager.setPlayerKit int -> void: Unknown
spawnManager.setPlayerTeam int -> void: Unknown
spawnManager.toggleMembers bool -> void: Unknown
squadInterface.selectOrder std::string -> bool: Unknown
squadInterface.setstd::stringMap std::string std::string std::string -> void: Unknown
squadLeaderInterface.selectOrder std::string -> bool: Unknown
squadLeaderInterface.setstd::stringMap std::string std::string std::string -> void: Unknown
squadLeader.sendOrder int bool -> void: Unknown
squadLeader.sendRequest int bool -> void: Unknown
squadLeader.sendRequestForOrder -> void: Unknown
squad.leaveSquad -> void: Unknown
squadManager.changeSquadName std::string bool -> void: Unknown
squadManager.joinSquad int -> void: Unknown
squadManager.leaveSquad int -> void: Unknown
squadManager.listSquadMembers int int -> std::string: Unknown
squadManager.listSquads int -> std::string: Unknown
squadManager.makeMeCommander -> void: Unknown
squadManager.popNextCommanderApplicant int -> void: Unknown
squadMenu.applyInviteList -> void: Unknown
squadMenu.createSquad -> void: Unknown
squadMenu.doubleClickInvite -> void: Unknown
squadMenu.doubleClickNew -> void: Unknown
squadMenu.setShowInviteList bool -> void: Unknown
squadMenu.setSquadCreateSelect bool -> void: Unknown
squadMenu.setSquadNameSelect -> void: Unknown
squadMenu.singleClickInvite -> void: Unknown
squadMenu.singleClickNew -> void: Unknown
squadMenu.squadCreateLockToggle -> void: Unknown
staticMeshRenderer.allowAnisoFiltering bool -> bool: Unknown
staticMeshRenderer.convertLightmapName std::string -> std::string: Unknown
staticMeshRenderer.enableLightIndexes bool -> bool: Unknown
staticMeshRenderer.enableLightMapAtlas bool -> bool: Unknown
staticMeshRenderer.enableNewLightmapNames bool -> bool: Unknown
staticMeshRenderer.enableRendering bool -> bool: Unknown
staticMeshRenderer.enableUnifiedIndexlist bool -> bool: Unknown
staticMeshRenderer.loadAllLightMapFiles std::string std::string -> bool: Unknown
staticMeshRenderer.loadAllLightMapFilesDLL std::string std::string -> bool: Unknown
staticMeshRenderer.materialCullingEnabled bool -> bool: Unknown
staticMeshRenderer.maxLightMappedLod int -> int: Unknown
staticMeshRenderer.noLods bool -> bool: Unknown

sv

sv.adminScript std::string -> std::string: Unknown
sv.allowExternalViews bool -> bool: Unknown
sv.allowFreeCam bool -> bool: Unknown
sv.allowNATNegotiation bool -> bool: Unknown
sv.allowNoseCam bool -> bool: Unknown
sv.autoBalanceTeam bool -> bool: Unknown
sv.autoDemoHook std::string -> std::string: Unknown
sv.autoRecord bool -> bool: Unknown
sv.communityLogoURL std::string -> std::string: Unknown
sv.configFile std::string -> std::string: Unknown
sv.coopBotCount int -> int: Unknown
sv.coopBotDifficulty float -> float: Unknown
sv.coopBotRatio float -> float: Unknown
sv.demoDownloadURL std::string -> std::string: Unknown
sv.demoIndexURL std::string -> std::string: Unknown
sv.demoQuality int -> int: Unknown
sv.endDelay int -> int: Unknown
sv.endOfRoundDelay int -> int: Unknown
sv.friendlyFireWithMines bool -> bool: Unknown
sv.gameSpyPort int -> int: Unknown
sv.hitIndicator bool -> bool: Unknown
sv.interfaceIP std::string -> std::string: Unknown
sv.internet bool -> std::string

: :1 = Adds the server to the server list. Tested this with the PRBF2_repo_w32ded.exe shortcut tool

sv.load -> bool: Unknown
sv.manDownTime float -> float: Unknown
sv.maxConnectionType ConnectionType -> ConnectionType: Unknown
sv.maxPlayers int -> std::string

: :Increases the player number count in the W32 Dedicated to the number specified. Effect Unknown. Maximum allowed is 100 though not sure if it's a BF2 thing or not

sv.minPlayersForVoting int -> int: Unknown
sv.notEnoughPlayersRestartDelay float -> float: Unknown
sv.noVehicles float -> float: Unknown
sv.numPlayersNeededToStart int -> int: Unknown
sv.numReservedSlots int -> std::string: Unknown
sv.password std::string -> std::string: Unknown
sv.punkBuster bool -> bool: Unknown
sv.radioBlockedDurationTime int -> int: Unknown
sv.radioMaxSpamFlagCount int -> int: Unknown
: Unknown
sv.ranked bool -> bool: Unknown
sv.roundsPerMap int -> int: Unknown
sv.save -> bool: Unknown
sv.scoreLimit int -> int: Unknown
sv.serverIP std::string -> std::string: Unknown
sv.serverName std::string -> std::string: Unknown
sv.serverPort int -> std::string: Unknown
sv.soldierFriendlyFire int -> int: Unknown
sv.soldierSplashFriendlyFire int -> int: Unknown
sv.spawnTime float -> float: Unknown
sv.sponsorLogoURL std::string -> std::string: Unknown
sv.sponsorText std::string -> std::string: Unknown
sv.startDelay int -> int: Unknown
sv.teamRatioPercent float -> float: Unknown
sv.teamVoteOnly bool -> bool: Unknown
sv.ticketRatio int -> int: Unknown
sv.timeBeforeRestartMap float -> float: Unknown
sv.timeLimit int -> int: Unknown
sv.tkNumPunishToKick int -> int: Unknown
sv.tkPunishByDefault bool -> bool: Unknown
sv.tkPunishEnabled bool -> bool: Unknown
sv.useGlobalRank bool -> bool: Unknown
sv.useGlobalUnlocks bool -> bool: Unknown
sv.vehicleFriendlyFire int -> int: Unknown
sv.vehicleSplashFriendlyFire int -> int: Unknown
sv.voipBFClientPort int -> int: Unknown
sv.voipBFServerPort int -> int: Unknown
sv.voipEnabled bool -> bool: Unknown
sv.voipQuality int -> int: Unknown
sv.voipServerPort int -> int: Unknown
sv.voipServerRemote bool -> bool: Unknown
sv.voipServerRemoteIP std::string -> std::string: Unknown
sv.voipSharedPassword std::string -> std::string: Unknown
sv.voteTime int -> int: Unknown
sv.votingEnabled bool -> bool: Unknown
sv.welcomeMessage std::string -> std::string: Unknown
swiffHost.addAward int int int -> void: Unknown
swiffHost.addCredit std::string int -> void: Unknown
swiffHost.addGameMode std::string std::string -> void: Unknown
swiffHost.addRank int int int -> void: Unknown
swiffHost.enableScroller bool -> void: Unknown
swiffHost.loadImage std::string -> bool: Unknown
swiffHost.serverBrowserFrameSkips int -> int: Unknown
swiffHost.setScrollerRect int int int -> void: Unknown
swiffHost.setScrollFadeSpeed int -> void: Unknown
swiffHost.setScrollSpeed float -> void: Unknown
terrain.ambientColor Vec3 -> Vec3: Unknown
terrain.create std::string -> void: Unknown
terrainCuller.baseCellSize int -> int: Unknown
terrainCuller.checkInside bool -> bool: Unknown
terrainCuller.cullerType int -> int: Unknown
terrainCuller.detailCullMaxLevel int -> int: Unknown
terrainCuller.lod0SwitchStart float -> float: Unknown
terrainCuller.lod0SwitchStop float -> float: Unknown
terrainCuller.lod1SwitchStart float -> float: Unknown
terrainCuller.lod1SwitchStop float -> float: Unknown
terrainCuller.lod2Start float -> float: Unknown
terrainCuller.lodSwitchDistance int -> int: Unknown
terrainCuller.updateLodLevel bool -> bool: Unknown
terrainCuller.useStitchedLods bool -> bool: Unknown
terrain.forceRenderStyle int -> int: Unknown
terrain.GIColor Vec3 -> Vec3: Unknown
terrain.GIColorHigh Vec3 -> Vec3: Unknown
terrain.GIColorLow Vec3 -> Vec3: Unknown
terrain.init -> void: Unknown
terrain.load std::string -> void: Unknown
terrain.refreshTerrainSampling -> void: Unknown
terrain.sunColor Vec3 -> Vec3: Unknown
terrain.terrainWaterColor Vec3 -> Vec3: Unknown
terrain.waterAlphaAdd float -> float: Unknown
terrain.waterAlphaHeightMul float -> float: Unknown
terrain.waterAnimSpeed float -> float: Unknown
terrain.waterColor Vec3 -> Vec3: Unknown
terrain.waterNormalMap std::string -> std::string: Unknown
terrain.waterQuality int -> int: Unknown
terrain.waterReflectivity float -> float: Unknown
terrain.waterScroll Vec2 -> Vec2: Unknown
terrain.waterSpecularColor Vec4 -> Vec4: Unknown
terrain.waterSpecularPower float -> float: Unknown
terrain.waterSunIntensity float -> float: Unknown
terrain.waterTransparency float -> float: Unknown
texturemanager.customTextureSuffix std::string -> std::string: Unknown
undergrowth.dynamicShadowsEnable bool -> bool: Unknown
undergrowth.enabled bool -> bool: Unknown
undergrowth.load std::string -> void: Unknown
undergrowth.reload -> void: Unknown
undergrowth.simpleShaderEnable bool -> bool: Unknown
undergrowth.test uint -> uint: Unknown
undergrowth.test2 float -> float: Unknown
undergrowth.viewDistanceFade float -> float: Unknown
undergrowth.viewDistanceScale float -> float: Unknown
undergrowth.zPassPatchCount uint -> uint: Unknown
Vars.set std::string std::string -> void: Unknown
videoSettings.setAntialiasing std::string -> void: Unknown
videoSettings.setDynamicLightingQuality int -> void: Unknown
videoSettings.setDynamicShadowsQuality int -> void: Unknown
videoSettings.setEffectsQuality int -> void: Unknown
videoSettings.setGeometryQuality int -> void: Unknown
videoSettings.setLightingQuality int -> void: Unknown
videoSettings.setResolution std::string -> void: Unknown
videoSettings.setTerrainQuality int -> void: Unknown
videoSettings.setTextureFilteringQuality int -> void: Unknown
videoSettings.setTextureQuality int -> void: Unknown
videoSettings.setVideoOptionScheme int -> void: Unknown
videoSettings.setViewDistanceScale float -> void: Unknown
weatherManager.doubleStrikeMaxDelay float -> float: Unknown
weatherManager.doubleStrikeMinDelay float -> float: Unknown
weatherManager.doubleStrikeProbability float -> float: Unknown
weatherManager.inFadeSegments float -> float: Unknown
weatherManager.lightningBlendOutTime float -> float: Unknown
weatherManager.lightningColor Vec4 -> Vec4: Unknown
weatherManager.lightningDuration float -> float: Unknown
weatherManager.lightningGroundPenetration float -> float: Unknown
weatherManager.lightningMaxInterval float -> float: Unknown
weatherManager.lightningMaxPos Vec3 -> Vec3: Unknown
weatherManager.lightningMinInterval float -> float: Unknown
weatherManager.lightningMinPos Vec3 -> Vec3: Unknown
weatherManager.lightningPertubation float -> float: Unknown
weatherManager.lightningScale Vec2 -> Vec2: Unknown
weatherManager.lightningSegments int -> int: Unknown
weatherManager.lightningSFXDelay float -> float: Unknown
weatherManager.lightningSFXName std::string -> std::string: Unknown
weatherManager.outFadeSegments float -> float: Unknown
weatherManager.skyBlendOutTime float -> float: Unknown
weatherManager.stormEnabled bool -> bool: Unknown
windManager.globalWindDirection Vec3 -> Vec3: Unknown
windManager.globalWindSpeed float -> float: Unknown
: Unknown
All Vars.Set Codes

:Usage :Description

EngineRunningTimer 5.000000: Unknown
anim-soldier-1p-speed-crouch 1.700000: Unknown
anim-soldier-1p-speed-prone 3.000000: Unknown
anim-soldier-spring-clamp 0.001000: Unknown
anim-soldier-spring-zoom-factor 6.000000: Unknown
anim_offsetBackwardTime 0.500000: Unknown
anim_playCameraAnimations 1: Unknown
anim_playSoldierAnimations 1: Unknown
anim_playSoldierPostAnimations 1: Unknown
anim_playVehicleAnimations 1: Unknown
anim_playWeaponAnimations 1: Unknown
anim_skipSync 0: Unknown
anim_smoothSet 10.000000: Unknown
anim_startJumpAtSpeed 2.500000: Unknown
anim_startLandAtHeight 1.000000: Unknown
anim_startLandAtSpeed -0.500000: Unknown
anim_startLeftOffset 0.200000: Unknown
anim_startRightOffset 0.700000: Unknown
anim_test 0.250000: Unknown
armor-invunerable-time 1.000000: Unknown
armor-invunerable-time-afterwreck 1.000000: Unknown
armor-max-soldier-wrecktime 60.000000: Unknown
armor-water-safetycheck-time 2.500000: Unknown
cFric 1.000000: Unknown
cRest 1.000000: Unknown
cam-dist 2.000000: Unknown
cam-fast 10.000000: Unknown
cam-interpolate-attachobject 1.200000: Unknown
cam-normal 1.000000: Unknown
cam-slow 0.100000: Unknown
cam-stiffness 1.500000: Unknown
cam_use_acc 0.000000: Unknown
camera-check-closevehicle-freq 1.000000: Unknown
camera-expshake-amp 5.000000: Unknown
camera-expshake-freq 10.000000: Unknown
camera-expshake-insidevehicle-mod 5.000000: Unknown
camera-expshake-time 0.400000: Unknown
camera-movement-speed-on-crouch 0.150000: Unknown
camera-movement-speed-on-prone 0.100000: Unknown
camera-movement-speed-on-stand 0.100000: Unknown
camera-recoil-amplitude 0.600000: Unknown
camera-recoil-speedmod 1.000000: Unknown
camera-recoil-type 0: Unknown
camera-shake-amp 2.0: Unknown
camera-shake-amplitude 0.200000: Unknown
camera-shake-distance 7.000000: Unknown
camera-shake-freq 10.0: Unknown
camera-shake-frequency 10.000000: Unknown
camera-shake-time 0.2: Unknown
camera-surface-snap-offset 0.090000: Unknown
coll-cull-sphere-obb 1: Unknown
coll-depth 3.000000: Unknown
coll-draw-cyl 0: Unknown
coll-draw-int 0: Unknown
coll-draw-line-width 0.010000: Unknown
coll-draw-lines 0: Unknown
coll-draw-point-physics-radius 0.000000: Unknown
coll-draw-soldier 0: Unknown
coll-draw-tested_faces 0: Unknown
coll-dump-all-tests 0: Unknown
coll-edge 1: Unknown
coll-edge-limit 0.866000: Unknown
coll-forceOff-debugmeshes 0: Unknown
coll-load-debugmeshes 0: Unknown
coll-normal-limit 0.100000: Unknown
coll-obb-cull-mode 1: Unknown
coll-obb-cull-radius 0.577350: Unknown
coll-obb-cull-vertex-limit 10: Unknown
coll-soldier-collision-adjust-mod 2.000000: Unknown
coll-soldier-collision-test-count 8: Unknown
coll-soldier-collision-test-count-start-backAt 3: Unknown
coll-soldier-collision-test-radius-mod 0.999000: Unknown
coll-soldier-crouch-height 1.400000: Unknown
coll-soldier-crush-depth 0.050000: Unknown
coll-soldier-debug-proj-hit 0: Unknown
coll-soldier-extend-ray 0.900000: Unknown
coll-soldier-overrun-impact-mod 2.500000: Unknown
coll-soldier-pivot-height 1.000000: Unknown
coll-soldier-prone-height 0.800000: Unknown
coll-soldier-radius 0.250000: Unknown
coll-soldier-stand-height 1.700000: Unknown
coll-static-vertex-limit 20: Unknown
coll-use-cyl 1: Unknown
coll-use-cyl-normal 1: Unknown
coll-use-face 1: Unknown
coll-use-fast-sphere-at-length 0.010000: Unknown
coll-vel-dot-norm 0: Unknown
collision-debug-default-terrain 0: Unknown
collision-impact-speed-limit 4.000000: Unknown
collision-skip-multcolls 1: Unknown
collision-skip-multcolls-debug 0: Unknown
collision-skip-multcolls-th 0.010000: Unknown
collision-test-lod-distance-factor 0.060000: Unknown
collision-test-lod-min-distance 25.000000: Unknown
collision-test-projectile-lod-distance-factor 3.000000: Unknown
collision-use-cubic-speedmod 0: Unknown
collision-use-mod-on-soldier 1: Unknown
conn-packetsize-override 0: Unknown
damage-angle-mod-choke 0.000000: Unknown
deathcam-terrainoffset 0.800000: Unknown
debug-draw-test-ray 0: Unknown
debug-engine 0 bool -> bool

:Activate in Console in Debugger :"Shows the RPM : Speed : Acceleration in a 3d text. May need !restart to work and is somewhat buggy"

debug-outputNewObject 0: Unknown
debug-spring 0 bool -> bool

:Activate in Console in Debugger and normal :"Shows lines when approaching a vehicle. You can see what direction the vehicle will go when turning : and has a bunch of other information regarding wheels"

demo-cam-360-capture 0: Unknown
demo-cam-360-capture-move 0.000000: Unknown
demo-cam-mouse-wheel-scale 0.850000: Unknown
demo-cam-offset 1: Unknown
demo-cam-offset-min 0.200000: Unknown
demo-cam-offset-slow 0.800000: Unknown
demo-cam-offset-speed 1.000000: Unknown
demo-fspeed 100.000000: Unknown
demo-slomo-cam 0.000000: Unknown
detonation-collface-offset 0.070000: Unknown
detonation-collface-offset-speedmod 0.050000: Unknown
detonation-collface-offset-speedmod-max 500.000000: Unknown
engine-audio-material-tweak 10.000000: Unknown
engine-audio-sway-amplitude-first 0.050000: Unknown
engine-audio-sway-amplitude-last 0.010000: Unknown
engine-audio-sway-frequency-first 80.000000: Unknown
engine-audio-sway-frequency-last 35.000000: Unknown
engine-audio-sway-time-first 0.700000: Unknown
engine-audio-sway-time-last 0.700000: Unknown
engine-inertia 0.050000: Unknown
engine-inertia2 0.990000: Unknown
engine-inertia3 0.960000: Unknown
engine-slope-no-gear-up-limit 0.174000: Unknown
engine-slope-torque-mod-1st-gear 0.000000: Unknown
engine-sound-smooth-time 0.100000: Unknown
event-delay 0: Unknown
event-delay-ticks 32: Unknown
explosion-camshake-insidevehicle-mod 0.200000: Unknown
explosion-camshake-maxdamage 150.000000: Unknown
explosion-camshake-maxforce 20.000000: Unknown
explosion-camshake-mod 4.000000: Unknown
explosion-camshake-ownvehicle-mod 0.100000: Unknown
explosion-hotspot 0.200000: Unknown
explosion-hotspot-ray 0.020000: Unknown
explosion-hotspot-ray-max 0.500000: Unknown
explosion-latencyComp 1: Unknown
explosion-soldier-expforce-ymod 5.000000: Unknown
fb-mod 1.000000: Unknown
feedback-mod 1.000000: Unknown
fire-delay-after-jump 1.100000: Unknown
fire-delay-from-prone 0.600000: Unknown
flying_height 110.000000: Unknown
follow-component-prediction-factor 0.100000: Unknown
force-reg-limit 20.000000: Unknown
hack-ignore-asserts 1: Unknown
hc_dump 0: Unknown
hc_freeze 0: Unknown
hc_normals 0: Unknown
hc_water 0: Unknown
ignoreFriendlyTimer 1.000000: Unknown
jump-delay-after-prone 1.200000

:Vars.set :Delay in seconds after prone to block the jump input. Setting it to 0 allows jumping when pressing space while moving from prone to standing

ladder-bottom-marginal 0.050000: Unknown
ladder-climb-speed-mod 0.045000: Unknown
ladder-down-angle-limit 35.000000: Unknown
ladder-down-ray-mag 0.200000: Unknown
ladder-down-ray-mag-skid 0.300000: Unknown
ladder-end-camera-offset 0.400000: Unknown
ladder-exit-offset 0.750000: Unknown
ladder-getoff-ray-min 0.300000: Unknown
ladder-getoff-speed-mod 1.150000: Unknown
ladder-offset-top 0.360000: Unknown
ladder-ray-debug 0: Unknown
ladder-ray-debug2 0: Unknown
ladder-skid-speed-mod 4.000000: Unknown
ladder-soldier-dist 0.600000: Unknown
ladder-soldier-start-getoff 1.800000: Unknown
ladder-step-size 0.300000: Unknown
ladder-top-exit-offset 0.750000: Unknown
ladder-up-ray-mag-skid 1.700000: Unknown
ladder-water-limit 1.200000: Unknown
local-prediction 0: Unknown
local-prediction-confirmtime 30: Unknown
local-prediction-lerpTime 1.000000: Unknown
local-prediction-minDelay 0.150000: Unknown
maxDistKillMissile 15.000000: Unknown
network-engine-fullPrecision 0: Unknown
network-spring-fullPrecision 0: Unknown
objectManager-cullHandleUpdateOnClientFactor 0.500000: Unknown
objectspawner-draw-lines 0: Unknown
objectspawner-inner-circle 0.300000: Unknown
objectspawner-num-tries 7: Unknown
old-turn-limit 1.000000: Unknown
old-turn-mod 1.500000: Unknown
opt-late-loading 0: Unknown
opt-nosound 1: Unknown
overheadCamera-acceleration 250.000000: Unknown
overheadCamera-maxPositionDelta 7.000000: Unknown
p-pos-damp 0.990000: Unknown
p-pos-damp-water 0.900000: Unknown
p-rot-damp 0.990000: Unknown
p-rot-damp-water 0.900000: Unknown
parachute-collapse-angle 0.300000: Unknown
parachute-collapse-time 0.050000: Unknown
parachute-collapse-time-water 0.050000: Unknown
parachute-debug 0: Unknown
parachute-spawn-debug 0: Unknown
parachute-start-landing-height 8.000000: Unknown
pco-exitpos-testlod 2: Unknown
pco-min-playing-ticks 20: Unknown
pco-show-gcs-stats 0: Unknown
pco-unmanned-max-minor-axis 0.400000: Unknown
pco-unmanned-min-major-axis 0.600000: Unknown
phy-ang-vel 0.500000: Unknown
phy-break-mod 0.950000: Unknown
phy-bsp-stats 0: Unknown
phy-contact-adjust-gravity-count 2: Unknown
phy-convert-collision-meshes 0: Unknown
phy-damage-frame-count 3: Unknown
phy-damage-scale 100.000000: Unknown
phy-damage-scale-limit 0.500000: Unknown
phy-draw-soldier-bullet-collision 0: Unknown
phy-engine-inertia 0.050000: Unknown
phy-engine-slope 1.000000: Unknown
phy-force-awake 0: Unknown
phy-force-sleeping 0: Unknown
phy-fri-dyn 0.800000: Unknown
phy-fri-exp 3: Unknown
phy-fri-lat 5.000000: Unknown
phy-fri-mod 1.000000: Unknown
phy-fri-mul 1.000000: Unknown
phy-fri-stat 1.200000: Unknown
phy-fri-wheel 0.990000: Unknown
phy-fri-wheel2 1.000000: Unknown
phy-gas 1.000000: Unknown
phy-gravity-compensation-size 0.500000: Unknown
phy-gravity-contact-mod 0.100000: Unknown
phy-hand-break-adjust 0.050000: Unknown
phy-hand-break-release 10: Unknown
phy-hand-break-rpm 0.100000: Unknown
phy-i-mod 1.500000: Unknown
phy-imp-mod 1.000000: Unknown
phy-imp-wakeup 1.000000: Unknown
phy-impulse-limit 0.050000: Unknown
phy-latencyComp-debug -1.000000: Unknown
phy-latencyComp-default 0.050000: Unknown
phy-latencyComp-max 0.300000: Unknown
phy-latencyComp-maxRenderAheadTime 0.033333: Unknown
phy-latencyComp-pingFactor 0.500000: Unknown
phy-latencyComp-useClientWindow 1: Unknown
phy-latencyComp-useInput 1: Unknown
phy-latencyComp-useRenderAhead 0: Unknown
phy-lin-acc 1.600000: Unknown
phy-lin-mod 0.500000: Unknown
phy-lin-vel 0.500000: Unknown
phy-list-physics-nodes 0: Unknown
phy-list-response-physics 0: Unknown
phy-max-imp 1000.000000: Unknown
phy-max-speed 1500.000000: Unknown
phy-new-collision-meshes 0: Unknown
phy-print -1: Unknown
phy-proj-collision-count 3: Unknown
phy-proj-collision-depth 0.050000: Unknown
phy-proj-precision 0.001000: Unknown
phy-proj-spring-on-up-axis 1: Unknown
phy-sep-fifty-fifty 10.000000: Unknown
phy-soldier-acceleration 0.120000: Unknown
phy-soldier-air-movement-factor 0: Unknown
phy-soldier-crawl-speed 0.800000: Unknown
phy-soldier-crouch-speed 2.000000: Unknown
phy-soldier-crush-minposspeedsqr 12.000000: Unknown
phy-soldier-crush-minrotspeedsqr 0.010000: Unknown
phy-soldier-crush-minvehicleposspeedsqr 2.000000: Unknown
phy-soldier-deceleration 0.350000: Unknown
phy-soldier-elasticity 0.000000: Unknown
phy-soldier-feet-contact-normal 0.500000: Unknown
phy-soldier-feet-level -0.040000: Unknown
phy-soldier-friction 1.000000: Unknown
phy-soldier-imp-feet 1.000000: Unknown
phy-soldier-inair-speed 2.000000: Unknown
phy-soldier-jump-factor 0.800000: Unknown
phy-soldier-jump-length-factor 0.980000: Unknown
phy-soldier-look-factor-x 5.000000: Unknown
phy-soldier-look-factor-y 5.000000: Unknown
phy-soldier-resistance 0.020000: Unknown
phy-soldier-run-speed 3.900000: Unknown
phy-soldier-skydive-speed 15.000000: Unknown
phy-soldier-skydiveat-speed -10.000000: Unknown
phy-soldier-speed-factor 0.850000: Unknown
phy-soldier-sprint-dissipation-time 10.000000: Unknown
phy-soldier-sprint-limit 0.500000: Unknown
phy-soldier-sprint-recover-time 120.000000: Unknown
phy-soldier-sprint-speed 7.000000: Unknown
phy-soldier-start-float 0.990000: Unknown
phy-soldier-stop-float 0.900000: Unknown
phy-soldier-swim-speed 2.100000: Unknown
phy-soldier-swimcrawl-speed 3.645000: Unknown
phy-soldier-take-fall-damage 1: Unknown
phy-soldier-walk-speed 1.500000: Unknown
phy-spring-client-debug 0: Unknown
phy-spring-server-debug 1: Unknown
phy-tank-engine-inertia 0.070000: Unknown
phy-turn 0.100000: Unknown
phy-wing-water-mod 10.000000: Unknown
phy-wreck 1: Unknown
pose-crawl-crouch 0.500000: Unknown
pose-crawl-run 0.500000: Unknown
pose-crawl-sprint 0.500000: Unknown
pose-crawl-swim 0.500000: Unknown
pose-crawl-swimCrawl 0.500000: Unknown
pose-crawl-walk 0.500000: Unknown
pose-crouch-crawl 0.500000: Unknown
pose-crouch-run 0.250000: Unknown
pose-crouch-sprint 0.250000: Unknown
pose-crouch-swim 0.500000: Unknown
pose-crouch-swimCrawl 0.500000: Unknown
pose-crouch-walk 0.250000: Unknown
pose-run-crawl 0.500000: Unknown
pose-run-crouch 0.250000: Unknown
pose-run-sprint 0.250000: Unknown
pose-run-swim 0.500000: Unknown
pose-run-swimCrawl 0.500000: Unknown
pose-run-walk 0.250000: Unknown
pose-sprint-crawl 0.500000: Unknown
pose-sprint-crouch 0.250000: Unknown
pose-sprint-run 0.250000: Unknown
pose-sprint-swim 0.500000: Unknown
pose-sprint-swimCrawl 0.500000: Unknown
pose-sprint-walk 0.250000: Unknown
pose-walk-crawl 0.500000: Unknown
pose-walk-crouch 0.250000: Unknown
pose-walk-run 0.250000: Unknown
pose-walk-sprint 0.250000: Unknown
pose-walk-swim 0.500000: Unknown
pose-walk-swimCrawl 0.500000: Unknown
prone-delay-after-jump 1.200000: Unknown
prone-delay-from-stand 1.200000: Unknown
ragdoll-max-inherit-speed 5.000000: Unknown
ragdoll_bodyBoneSize 0.120000: Unknown
ragdoll_boneSize 0.100000: Unknown
ragdoll_clientMaxUpdateTime 0.002000: Unknown
ragdoll_collMid 0.999900: Unknown
ragdoll_completeCollRadius 1.500000: Unknown
ragdoll_dT 0.011111: Unknown
ragdoll_enableForce 0: Unknown
ragdoll_expRotateForce 13.000000: Unknown
ragdoll_gravityOverTime 0.500000: Unknown
ragdoll_iterations 2: Unknown
ragdoll_kneeBoneSize 0.050000: Unknown
ragdoll_legBackAngle -0.100000: Unknown
ragdoll_legForwardAngle 10.000000: Unknown
ragdoll_legForwardFactor 0.000000: Unknown
ragdoll_legPointForwardAngle 0.500000: Unknown
ragdoll_legPointForwardFactor 0.010000: Unknown
ragdoll_net_boneEnable 15: Unknown
ragdoll_net_debug 0: Unknown
ragdoll_net_interpolate 0.100000: Unknown
ragdoll_sleep 5.000000: Unknown
ragdoll_sleepDelta 0.020000: Unknown
ragdoll_slowMotion 1.000000: Unknown
ragdoll_useAngularConstraints 1: Unknown
ragdoll_useCapsuleCollision 1: Unknown
ragdoll_useConstraints 1: Unknown
ragdoll_useLandCollision 1: Unknown
ragdoll_useObjectCollision 1: Unknown
rd_dieForce 0.0: Unknown
rd_dieInVehicleForce 100.000000: Unknown
rd_expForceMod 1.000000: Unknown
rd_hitForce 0.000000: Unknown
rd_hitUp 0.000000: Unknown
replenish-checkaim-freq 1.000000: Unknown
replenish-checkaim-maint-freq 0.500000: Unknown
replenish-ignoreteam 0: Unknown
rot-use-old 1: Unknown
rotationalbundle-max-speed-mod 30.000000: Unknown
rotationalbundle-sound-smooth-time 0.150000: Unknown
rpm-k 10.000000: Unknown
rpm-wheel 0.060000

:No effect :

server-sleep-overhead-time 0.005000: Unknown
shoot-mag 10.000000

:No effect :

show-damage-ndicator-for-all 1: Unknown
show-engine 0

:No effect :

soldier-drop-max 1.500000: Unknown
soldier-drop-min 0.500000: Unknown
soldier-drown-damage 8.000000: Unknown
soldier-footstep-effect-cull-distance 20.000000: Unknown
soldier-footstep-offset-dof-prone 0.000000: Unknown
soldier-footstep-offset-dof-stand 0.130000: Unknown
soldier-footstep-offset-y -0.990000: Unknown
soldier-fov1p 0.820000

:No effect :

soldier-impact-speed-limit 10.000000: Unknown
soldier-impact-speed-limit-2 3.000000: Unknown
soldier-lookDown 70.000000

:No effect :

soldier-lookMaxAngle 40.000000/85.000000/0.000000: Unknown
soldier-lookSideRestore 4.000000: Unknown
soldier-lookUp -70.000000: Unknown
soldier-mandown-rotspeed 0.100000: Unknown
soldier-mandown-speed 5.000000: Unknown
soldier-prone-inwater-limit 1.100000

:Vars.Set :"The number referenced is the angle. Setting it to 0 allows you to prone into water. Can shoot walls when it's in water : but not walls from the surface. Setting it to 2 prevents you from proning near water in which you automatically go to the standing position"

soldier-proneLookDown 5.000000: Unknown
soldier-proneLookUp -30.000000: Unknown
soldier-revive-disableinputtime 2.100000: Unknown
soldier-terrain-speed-limit 9.100000: Unknown
soldier-timeToEnableWeapon 1.250000: Unknown
soldier_lookIdleAngle 15.000000: Unknown
soldier_lookIdleTime 2.500000: Unknown
soldier_lookSmooth 10.000000: Unknown
soldier_throwGun 0.025000: Unknown
soldier_throwGunForward 1.000000: Unknown
soldier_throwHelmet 0.025000: Unknown
soldier_throwKitPartsDelay 0.300000: Unknown
sound-listener-radius 0.200000: Unknown
sound-obstruction-disable 0: Unknown
sound-obstruction-max 0.800000: Unknown
sound-obstruction-max-reuse-frames 15: Unknown
sound-obstruction-opt0 1: Unknown
sound-obstruction-opt1 1: Unknown
sound-obstruction-radius 2.000000: Unknown
sound-obstruction-reuse-frames 0: Unknown
sound-tinnitus-range 0.600000: Unknown
spawnpoint-scatter-maxdist 9.000000: Unknown
spawnpoint-scatter-mindist 3.000000: Unknown
spawnpoint-scatter-testlod 2: Unknown
spawnpoint-terrain-offset 1.010000: Unknown
sprint-recharge-delay-after-jump 2.000000: Unknown
stand-delay-from-prone 1.500000: Unknown
stick-default-distance 0.050000: Unknown
tank-square 1: Unknown
targetYOffset 0.000000: Unknown
use-loading-profiler 0: Unknown
weapon-detonationDebug 0: Unknown
weapon-detonationTriggerFreq 0.250000: Unknown
wh-torque-mult 0.500000: Unknown
wh-torque-offs 1.000000: Unknown
wh-use-slip-ratio 0: Unknown
wheel-inertia 0.100000: Unknown
wheel-mod 1.000000: Unknown
wp-delay-pingfactor 2: Unknown
wp-delay-reloadfactor 1: Unknown
wp-delay-ticks 15: Unknown
zipline-soldier-height 1.490000: Unknown

BF2 Console Commands

AnimationBundle

AnimationManager

AnimationSystem

animationTrigger

animationValueHolder

audioSettings

collisionManager

combatArea

commander

commanderInterface

commanderMenu

Console

controlMap

DecalManager

demo

Editor

effectTweak

gameLogic

gameServerSettings

generalSettings

geometryTemplate

globalSettings

hapticSettings

heightmapcluster

hudBuilder

lightManager

localPlayer

localProfile

maplist

material

menuTeamManager

minimap

nametags

networkableInfo

object

objectTemplate

overgrowth

particleSystemManager

Player

profile

pythonHost

radio

renderer

scoreboard

scoreManager

shadermanager

sv

Navigation menu